rust-postgres/postgres/tests/test.rs

1498 lines
44 KiB
Rust
Raw Normal View History

2016-09-13 04:34:03 +00:00
extern crate fallible_iterator;
2018-01-10 05:18:34 +00:00
#[cfg(feature = "native-tls")]
extern crate native_tls;
#[cfg(feature = "with-openssl")]
extern crate openssl;
extern crate postgres;
2017-07-21 05:58:29 +00:00
#[macro_use]
extern crate postgres_shared;
#[cfg(feature = "with-security-framework")]
extern crate security_framework;
2018-01-10 05:18:34 +00:00
extern crate url;
2016-09-13 04:34:03 +00:00
use fallible_iterator::FallibleIterator;
2018-04-15 17:38:18 +00:00
use postgres::error::ErrorPosition::Normal;
2018-01-10 05:18:34 +00:00
use postgres::error::{DbError, CARDINALITY_VIOLATION, INVALID_CATALOG_NAME, INVALID_PASSWORD,
QUERY_CANCELED, SYNTAX_ERROR, UNDEFINED_TABLE};
use postgres::notification::Notification;
use postgres::params::IntoConnectParams;
2018-04-15 17:38:18 +00:00
use postgres::transaction::{self, IsolationLevel};
use postgres::types::{FLOAT8, INT4, Kind, Oid, Type, WrongType, VARCHAR};
use postgres::{Connection, GenericConnection, HandleNotice, TlsMode};
2016-09-13 04:34:03 +00:00
use std::io;
2018-04-15 17:38:18 +00:00
use std::thread;
2016-09-13 04:34:03 +00:00
use std::time::Duration;
2014-12-19 18:43:42 +00:00
macro_rules! or_panic {
2018-04-15 17:38:18 +00:00
($e:expr) => {
2014-03-28 05:43:10 +00:00
match $e {
Ok(ok) => ok,
2018-04-15 17:38:18 +00:00
Err(err) => panic!("{:#?}", err),
2014-03-28 05:43:10 +00:00
}
2018-04-15 17:38:18 +00:00
};
2014-12-19 18:43:42 +00:00
}
2014-03-28 05:43:10 +00:00
mod types;
2013-08-18 03:30:31 +00:00
2013-10-05 03:26:52 +00:00
#[test]
fn test_non_default_database() {
2017-07-01 03:35:17 +00:00
or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433/postgres",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2013-10-05 03:26:52 +00:00
}
2013-10-25 05:01:40 +00:00
#[test]
fn test_url_terminating_slash() {
2017-07-01 03:35:17 +00:00
or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433/",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2013-10-25 05:01:40 +00:00
}
#[test]
fn test_prepare_err() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2017-07-17 01:13:49 +00:00
let err = conn.prepare("invalid sql database").unwrap_err();
match err.as_db() {
Some(e) if e.code == SYNTAX_ERROR && e.position == Some(Normal(1)) => {}
_ => panic!("Unexpected result {:?}", err),
}
}
2013-10-25 05:01:40 +00:00
#[test]
fn test_unknown_database() {
2017-07-09 02:40:03 +00:00
match Connection::connect("postgres://postgres@localhost:5433/asdf", TlsMode::None) {
2017-07-17 01:13:49 +00:00
Err(ref e) if e.code() == Some(&INVALID_CATALOG_NAME) => {}
Err(resp) => panic!("Unexpected result {:?}", resp),
2014-10-30 04:26:03 +00:00
_ => panic!("Unexpected result"),
2013-10-25 05:01:40 +00:00
}
}
#[test]
fn test_connection_finish() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
assert!(conn.finish().is_ok());
}
#[test]
2017-07-09 02:46:15 +00:00
#[ignore] // doesn't work on our CI setup
fn test_unix_connection() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(conn.prepare("SHOW unix_socket_directories"));
let result = or_panic!(stmt.query(&[]));
let unix_socket_directories: String = result.iter().map(|row| row.get(0)).next().unwrap();
2014-04-22 04:01:44 +00:00
if unix_socket_directories.is_empty() {
2014-10-30 04:26:03 +00:00
panic!("can't test connect_unix; unix_socket_directories is empty");
}
2015-02-21 04:17:47 +00:00
let unix_socket_directory = unix_socket_directories.split(',').next().unwrap();
2017-07-01 03:35:17 +00:00
let path = url::percent_encoding::utf8_percent_encode(
unix_socket_directory,
url::percent_encoding::USERINFO_ENCODE_SET,
);
2015-01-17 06:07:04 +00:00
let url = format!("postgres://postgres@{}", path);
let conn = or_panic!(Connection::connect(&url[..], TlsMode::None));
assert!(conn.finish().is_ok());
}
#[test]
fn test_transaction_commit() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2018-04-15 17:38:18 +00:00
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[],));
2014-10-30 04:26:03 +00:00
let trans = or_panic!(conn.transaction());
or_panic!(trans.execute("INSERT INTO foo (id) VALUES ($1)", &[&1i32]));
2014-07-26 05:41:10 +00:00
trans.set_commit();
2013-12-05 06:24:49 +00:00
drop(trans);
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(conn.prepare("SELECT * FROM foo"));
let result = or_panic!(stmt.query(&[]));
2017-07-01 03:35:17 +00:00
assert_eq!(
vec![1i32],
result.iter().map(|row| row.get(0)).collect::<Vec<i32>>()
);
}
#[test]
fn test_transaction_commit_finish() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2018-04-15 17:38:18 +00:00
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[],));
2014-10-30 04:26:03 +00:00
let trans = or_panic!(conn.transaction());
or_panic!(trans.execute("INSERT INTO foo (id) VALUES ($1)", &[&1i32]));
2014-07-26 05:41:10 +00:00
trans.set_commit();
assert!(trans.finish().is_ok());
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(conn.prepare("SELECT * FROM foo"));
let result = or_panic!(stmt.query(&[]));
2017-07-01 03:35:17 +00:00
assert_eq!(
vec![1i32],
result.iter().map(|row| row.get(0)).collect::<Vec<i32>>()
);
}
2014-07-26 05:41:10 +00:00
#[test]
fn test_transaction_commit_method() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2018-04-15 17:38:18 +00:00
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[],));
2014-07-26 05:41:10 +00:00
2014-10-30 04:26:03 +00:00
let trans = or_panic!(conn.transaction());
or_panic!(trans.execute("INSERT INTO foo (id) VALUES ($1)", &[&1i32]));
2014-07-26 05:41:10 +00:00
assert!(trans.commit().is_ok());
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(conn.prepare("SELECT * FROM foo"));
let result = or_panic!(stmt.query(&[]));
2014-07-26 05:41:10 +00:00
2017-07-01 03:35:17 +00:00
assert_eq!(
vec![1i32],
result.iter().map(|row| row.get(0)).collect::<Vec<i32>>()
);
2014-07-26 05:41:10 +00:00
}
#[test]
fn test_transaction_rollback() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2018-04-15 17:38:18 +00:00
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[],));
2013-08-23 07:13:42 +00:00
2014-10-30 04:26:03 +00:00
or_panic!(conn.execute("INSERT INTO foo (id) VALUES ($1)", &[&1i32]));
2013-12-05 06:24:49 +00:00
2014-10-30 04:26:03 +00:00
let trans = or_panic!(conn.transaction());
or_panic!(trans.execute("INSERT INTO foo (id) VALUES ($1)", &[&2i32]));
2013-12-05 06:24:49 +00:00
drop(trans);
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(conn.prepare("SELECT * FROM foo"));
let result = or_panic!(stmt.query(&[]));
2017-07-01 03:35:17 +00:00
assert_eq!(
vec![1i32],
result.iter().map(|row| row.get(0)).collect::<Vec<i32>>()
);
2013-08-23 07:13:42 +00:00
}
2013-08-25 03:47:36 +00:00
#[test]
fn test_transaction_rollback_finish() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2018-04-15 17:38:18 +00:00
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[],));
2014-10-30 04:26:03 +00:00
or_panic!(conn.execute("INSERT INTO foo (id) VALUES ($1)", &[&1i32]));
2014-10-30 04:26:03 +00:00
let trans = or_panic!(conn.transaction());
or_panic!(trans.execute("INSERT INTO foo (id) VALUES ($1)", &[&2i32]));
assert!(trans.finish().is_ok());
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(conn.prepare("SELECT * FROM foo"));
let result = or_panic!(stmt.query(&[]));
2017-07-01 03:35:17 +00:00
assert_eq!(
vec![1i32],
result.iter().map(|row| row.get(0)).collect::<Vec<i32>>()
);
}
2013-09-05 06:28:44 +00:00
#[test]
fn test_nested_transactions() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2018-04-15 17:38:18 +00:00
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[],));
2013-09-05 06:28:44 +00:00
or_panic!(conn.execute("INSERT INTO foo (id) VALUES (1)", &[]));
2013-09-05 06:28:44 +00:00
2013-10-14 01:58:31 +00:00
{
2014-10-30 04:26:03 +00:00
let trans1 = or_panic!(conn.transaction());
or_panic!(trans1.execute("INSERT INTO foo (id) VALUES (2)", &[]));
2013-09-05 06:28:44 +00:00
2013-10-14 01:58:31 +00:00
{
2014-10-30 04:26:03 +00:00
let trans2 = or_panic!(trans1.transaction());
or_panic!(trans2.execute("INSERT INTO foo (id) VALUES (3)", &[]));
2013-09-05 06:28:44 +00:00
}
2013-10-14 01:58:31 +00:00
{
2014-10-30 04:26:03 +00:00
let trans2 = or_panic!(trans1.transaction());
or_panic!(trans2.execute("INSERT INTO foo (id) VALUES (4)", &[]));
2013-09-05 06:28:44 +00:00
2013-10-14 01:58:31 +00:00
{
2014-10-30 04:26:03 +00:00
let trans3 = or_panic!(trans2.transaction());
or_panic!(trans3.execute("INSERT INTO foo (id) VALUES (5)", &[]));
2013-09-05 06:28:44 +00:00
}
2013-10-14 01:58:31 +00:00
{
let sp = or_panic!(trans2.savepoint("custom"));
or_panic!(sp.execute("INSERT INTO foo (id) VALUES (6)", &[]));
assert!(sp.commit().is_ok());
2013-09-05 06:28:44 +00:00
}
2014-07-26 05:41:10 +00:00
assert!(trans2.commit().is_ok());
2013-09-05 06:28:44 +00:00
}
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(trans1.prepare("SELECT * FROM foo ORDER BY id"));
let result = or_panic!(stmt.query(&[]));
2013-09-05 06:28:44 +00:00
2017-07-01 03:35:17 +00:00
assert_eq!(
vec![1i32, 2, 4, 6],
result.iter().map(|row| row.get(0)).collect::<Vec<i32>>()
);
2013-09-05 06:28:44 +00:00
}
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(conn.prepare("SELECT * FROM foo ORDER BY id"));
let result = or_panic!(stmt.query(&[]));
2013-09-05 06:28:44 +00:00
2017-07-01 03:35:17 +00:00
assert_eq!(
vec![1i32],
result.iter().map(|row| row.get(0)).collect::<Vec<i32>>()
);
2013-09-05 06:28:44 +00:00
}
#[test]
fn test_nested_transactions_finish() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2018-04-15 17:38:18 +00:00
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[],));
or_panic!(conn.execute("INSERT INTO foo (id) VALUES (1)", &[]));
{
2014-10-30 04:26:03 +00:00
let trans1 = or_panic!(conn.transaction());
or_panic!(trans1.execute("INSERT INTO foo (id) VALUES (2)", &[]));
{
2014-10-30 04:26:03 +00:00
let trans2 = or_panic!(trans1.transaction());
or_panic!(trans2.execute("INSERT INTO foo (id) VALUES (3)", &[]));
assert!(trans2.finish().is_ok());
}
{
2014-10-30 04:26:03 +00:00
let trans2 = or_panic!(trans1.transaction());
or_panic!(trans2.execute("INSERT INTO foo (id) VALUES (4)", &[]));
{
2014-10-30 04:26:03 +00:00
let trans3 = or_panic!(trans2.transaction());
or_panic!(trans3.execute("INSERT INTO foo (id) VALUES (5)", &[]));
assert!(trans3.finish().is_ok());
}
{
let sp = or_panic!(trans2.savepoint("custom"));
or_panic!(sp.execute("INSERT INTO foo (id) VALUES (6)", &[]));
sp.set_commit();
assert!(sp.finish().is_ok());
}
2014-07-26 05:41:10 +00:00
trans2.set_commit();
assert!(trans2.finish().is_ok());
}
// in a block to unborrow trans1 for the finish call
{
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(trans1.prepare("SELECT * FROM foo ORDER BY id"));
let result = or_panic!(stmt.query(&[]));
2017-07-01 03:35:17 +00:00
assert_eq!(
vec![1i32, 2, 4, 6],
result.iter().map(|row| row.get(0)).collect::<Vec<i32>>()
);
}
assert!(trans1.finish().is_ok());
}
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(conn.prepare("SELECT * FROM foo ORDER BY id"));
let result = or_panic!(stmt.query(&[]));
2017-07-01 03:35:17 +00:00
assert_eq!(
vec![1i32],
result.iter().map(|row| row.get(0)).collect::<Vec<i32>>()
);
}
2014-05-19 02:46:21 +00:00
#[test]
2015-03-10 16:16:46 +00:00
#[should_panic(expected = "active transaction")]
fn test_conn_trans_when_nested() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2014-10-30 04:26:03 +00:00
let _trans = or_panic!(conn.transaction());
conn.transaction().unwrap();
2014-05-19 02:46:21 +00:00
}
#[test]
2015-03-10 16:16:46 +00:00
#[should_panic(expected = "active transaction")]
fn test_trans_with_nested_trans() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2014-10-30 04:26:03 +00:00
let trans = or_panic!(conn.transaction());
let _trans2 = or_panic!(trans.transaction());
trans.transaction().unwrap();
2014-05-19 02:46:21 +00:00
}
#[test]
#[should_panic(expected = "active transaction")]
fn test_trans_with_savepoints() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
let trans = or_panic!(conn.transaction());
let _sp = or_panic!(trans.savepoint("custom"));
trans.savepoint("custom2").unwrap();
}
#[test]
fn test_stmt_execute_after_transaction() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
let trans = or_panic!(conn.transaction());
let stmt = or_panic!(trans.prepare("SELECT 1"));
or_panic!(trans.finish());
let result = or_panic!(stmt.query(&[]));
2017-02-04 23:18:41 +00:00
assert_eq!(1i32, result.iter().next().unwrap().get::<_, i32>(0));
}
#[test]
fn test_stmt_finish() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2018-04-15 17:38:18 +00:00
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY)", &[],));
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(conn.prepare("SELECT * FROM foo"));
assert!(stmt.finish().is_ok());
}
2014-06-08 23:07:15 +00:00
#[test]
fn test_batch_execute() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2014-06-08 23:07:15 +00:00
let query = "CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY);
INSERT INTO foo (id) VALUES (10);";
2014-10-30 04:26:03 +00:00
or_panic!(conn.batch_execute(query));
2014-06-08 23:07:15 +00:00
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(conn.prepare("SELECT * from foo ORDER BY id"));
let result = or_panic!(stmt.query(&[]));
2014-06-08 23:07:15 +00:00
2017-07-01 03:35:17 +00:00
assert_eq!(
vec![10i64],
result.iter().map(|row| row.get(0)).collect::<Vec<i64>>()
);
2014-06-08 23:07:15 +00:00
}
#[test]
fn test_batch_execute_error() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2014-06-08 23:07:15 +00:00
let query = "CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY);
INSERT INTO foo (id) VALUES (10);
asdfa;
INSERT INTO foo (id) VALUES (11)";
2015-01-23 19:10:04 +00:00
conn.batch_execute(query).err().unwrap();
2014-06-08 23:07:15 +00:00
2015-02-12 21:29:50 +00:00
let stmt = conn.prepare("SELECT * FROM foo ORDER BY id");
match stmt {
2017-07-17 01:13:49 +00:00
Err(ref e) if e.code() == Some(&UNDEFINED_TABLE) => {}
Err(e) => panic!("unexpected error {:?}", e),
2014-10-30 04:26:03 +00:00
_ => panic!("unexpected success"),
2014-06-08 23:07:15 +00:00
}
}
2014-07-30 02:48:56 +00:00
#[test]
fn test_transaction_batch_execute() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2014-10-30 04:26:03 +00:00
let trans = or_panic!(conn.transaction());
2014-07-30 02:48:56 +00:00
let query = "CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY);
INSERT INTO foo (id) VALUES (10);";
2014-10-30 04:26:03 +00:00
or_panic!(trans.batch_execute(query));
2014-07-30 02:48:56 +00:00
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(trans.prepare("SELECT * from foo ORDER BY id"));
let result = or_panic!(stmt.query(&[]));
2014-07-30 02:48:56 +00:00
2017-07-01 03:35:17 +00:00
assert_eq!(
vec![10i64],
result.iter().map(|row| row.get(0)).collect::<Vec<i64>>()
);
2014-07-30 02:48:56 +00:00
}
2013-08-25 03:47:36 +00:00
#[test]
fn test_query() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2018-04-15 17:38:18 +00:00
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY)", &[],));
or_panic!(conn.execute("INSERT INTO foo (id) VALUES ($1), ($2)", &[&1i64, &2i64],));
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(conn.prepare("SELECT * from foo ORDER BY id"));
let result = or_panic!(stmt.query(&[]));
2013-08-25 03:47:36 +00:00
2017-07-01 03:35:17 +00:00
assert_eq!(
vec![1i64, 2],
result.iter().map(|row| row.get(0)).collect::<Vec<i64>>()
);
}
#[test]
fn test_error_after_datarow() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
let stmt = or_panic!(conn.prepare(
"
SELECT
(SELECT generate_series(1, ss.i))
FROM (SELECT gs.i
FROM generate_series(1, 2) gs(i)
ORDER BY gs.i
2017-07-01 03:35:17 +00:00
LIMIT 2) ss",
));
match stmt.query(&[]) {
2017-07-17 01:13:49 +00:00
Err(ref e) if e.code() == Some(&CARDINALITY_VIOLATION) => {}
Err(err) => panic!("Unexpected error {:?}", err),
2014-10-30 04:26:03 +00:00
Ok(_) => panic!("Expected failure"),
};
}
#[test]
fn test_lazy_query() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2014-10-30 04:26:03 +00:00
let trans = or_panic!(conn.transaction());
2018-01-10 05:18:34 +00:00
or_panic!(trans.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[],));
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(trans.prepare("INSERT INTO foo (id) VALUES ($1)"));
2017-05-22 05:36:26 +00:00
let values = vec![0i32, 1, 2, 3, 4, 5];
2016-11-20 00:04:28 +00:00
for value in &values {
2014-10-30 04:26:03 +00:00
or_panic!(stmt.execute(&[value]));
}
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(trans.prepare("SELECT id FROM foo ORDER BY id"));
let result = or_panic!(stmt.lazy_query(&trans, &[], 2));
2017-07-01 03:35:17 +00:00
assert_eq!(
values,
result.map(|row| row.get(0)).collect::<Vec<i32>>().unwrap()
);
}
#[test]
2015-03-10 16:16:46 +00:00
#[should_panic(expected = "same `Connection` as")]
fn test_lazy_query_wrong_conn() {
2017-07-01 03:35:17 +00:00
let conn1 = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
let conn2 = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2014-10-30 04:26:03 +00:00
let trans = or_panic!(conn1.transaction());
let stmt = or_panic!(conn2.prepare("SELECT 1::INT"));
stmt.lazy_query(&trans, &[], 1).unwrap();
}
#[test]
fn test_param_types() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(conn.prepare("SELECT $1::INT, $2::VARCHAR"));
2017-07-09 07:02:45 +00:00
assert_eq!(stmt.param_types(), &[INT4, VARCHAR][..]);
}
#[test]
fn test_columns() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(conn.prepare("SELECT 1::INT as a, 'hi'::VARCHAR as b"));
let cols = stmt.columns();
assert_eq!(2, cols.len());
assert_eq!(cols[0].name(), "a");
2017-07-09 07:02:45 +00:00
assert_eq!(cols[0].type_(), &INT4);
assert_eq!(cols[1].name(), "b");
2017-07-09 07:02:45 +00:00
assert_eq!(cols[1].type_(), &VARCHAR);
}
2014-01-02 05:54:13 +00:00
#[test]
fn test_execute_counts() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
assert_eq!(
0,
or_panic!(conn.execute(
"CREATE TEMPORARY TABLE foo (
id SERIAL PRIMARY KEY,
b INT
2017-05-22 05:36:26 +00:00
)",
2017-07-01 03:35:17 +00:00
&[],
))
);
assert_eq!(
3,
or_panic!(conn.execute(
"INSERT INTO foo (b) VALUES ($1), ($2), ($2)",
&[&1i32, &2i32],
))
);
assert_eq!(
2,
or_panic!(conn.execute("UPDATE foo SET b = 0 WHERE b = 2", &[]))
);
assert_eq!(3, or_panic!(conn.execute("SELECT * FROM foo", &[])));
2014-01-02 05:54:13 +00:00
}
2013-09-02 17:27:09 +00:00
#[test]
fn test_wrong_param_type() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2017-07-17 01:13:49 +00:00
let err = conn.execute("SELECT $1::VARCHAR", &[&1i32]).unwrap_err();
match err.as_conversion() {
Some(e) if e.is::<WrongType>() => {}
_ => panic!("unexpected result {:?}", err),
2014-03-28 05:43:10 +00:00
}
}
2013-09-12 05:33:19 +00:00
#[test]
2015-03-10 16:16:46 +00:00
#[should_panic(expected = "expected 2 parameters but got 1")]
2013-09-12 05:33:19 +00:00
fn test_too_few_params() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2015-02-01 03:44:39 +00:00
let _ = conn.execute("SELECT $1::INT, $2::INT", &[&1i32]);
2013-09-12 05:33:19 +00:00
}
#[test]
2015-03-10 16:16:46 +00:00
#[should_panic(expected = "expected 2 parameters but got 3")]
2013-09-12 05:33:19 +00:00
fn test_too_many_params() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2015-02-01 03:44:39 +00:00
let _ = conn.execute("SELECT $1::INT, $2::INT", &[&1i32, &2i32, &3i32]);
2013-09-12 05:33:19 +00:00
}
2013-09-03 00:07:08 +00:00
#[test]
fn test_index_named() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(conn.prepare("SELECT 10::INT as val"));
let result = or_panic!(stmt.query(&[]));
2017-07-01 03:35:17 +00:00
assert_eq!(
vec![10i32],
result
.iter()
.map(|row| row.get("val"))
.collect::<Vec<i32>>()
);
}
#[test]
2015-03-10 16:16:46 +00:00
#[should_panic]
fn test_index_named_fail() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(conn.prepare("SELECT 10::INT as id"));
let result = or_panic!(stmt.query(&[]));
let _: i32 = result.iter().next().unwrap().get("asdf");
2013-09-03 00:07:08 +00:00
}
#[test]
fn test_get_named_err() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(conn.prepare("SELECT 10::INT as id"));
let result = or_panic!(stmt.query(&[]));
match result.iter().next().unwrap().get_opt::<_, i32>("asdf") {
None => {}
res => panic!("unexpected result {:?}", res),
};
}
2014-03-30 02:01:23 +00:00
#[test]
fn test_get_was_null() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(conn.prepare("SELECT NULL::INT as id"));
let result = or_panic!(stmt.query(&[]));
2014-03-30 02:01:23 +00:00
match result.iter().next().unwrap().get_opt::<_, i32>(0) {
2017-07-17 01:13:49 +00:00
Some(Err(ref e)) if e.as_conversion().is_some() => {}
res => panic!("unexpected result {:?}", res),
2014-03-30 02:01:23 +00:00
};
}
2014-12-06 18:41:49 +00:00
#[test]
fn test_get_off_by_one() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2014-12-06 18:41:49 +00:00
let stmt = or_panic!(conn.prepare("SELECT 10::INT as id"));
let result = or_panic!(stmt.query(&[]));
2014-12-06 18:41:49 +00:00
match result.iter().next().unwrap().get_opt::<_, i32>(1) {
None => {}
res => panic!("unexpected result {:?}", res),
2014-12-06 18:41:49 +00:00
};
}
#[test]
fn test_custom_notice_handler() {
2016-11-20 00:04:28 +00:00
static mut COUNT: usize = 0;
struct Handler;
2015-02-22 23:05:19 +00:00
impl HandleNotice for Handler {
fn handle_notice(&mut self, notice: DbError) {
assert_eq!("note", notice.message);
2017-05-22 05:36:26 +00:00
unsafe {
COUNT += 1;
}
}
}
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433?client_min_messages=NOTICE",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
conn.set_notice_handler(Box::new(Handler));
2017-07-01 03:35:17 +00:00
or_panic!(conn.execute(
"CREATE FUNCTION pg_temp.note() RETURNS INT AS $$
BEGIN
RAISE NOTICE 'note';
RETURN 1;
2017-05-22 05:36:26 +00:00
END; $$ LANGUAGE plpgsql",
2017-07-01 03:35:17 +00:00
&[],
));
or_panic!(conn.execute("SELECT pg_temp.note()", &[]));
2016-11-20 00:04:28 +00:00
assert_eq!(unsafe { COUNT }, 1);
}
#[test]
fn test_notification_iterator_none() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2016-09-13 04:34:03 +00:00
assert!(conn.notifications().iter().next().unwrap().is_none());
}
fn check_notification(expected: Notification, actual: Notification) {
assert_eq!(&expected.channel, &actual.channel);
assert_eq!(&expected.payload, &actual.payload);
}
#[test]
fn test_notification_iterator_some() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2015-09-19 05:51:11 +00:00
let notifications = conn.notifications();
let mut it = notifications.iter();
2018-04-15 17:38:18 +00:00
or_panic!(conn.execute("LISTEN test_notification_iterator_one_channel", &[],));
or_panic!(conn.execute("LISTEN test_notification_iterator_one_channel2", &[],));
2017-07-01 03:35:17 +00:00
or_panic!(conn.execute(
"NOTIFY test_notification_iterator_one_channel, 'hello'",
&[],
));
or_panic!(conn.execute(
"NOTIFY test_notification_iterator_one_channel2, 'world'",
&[],
));
check_notification(
Notification {
process_id: 0,
channel: "test_notification_iterator_one_channel".to_string(),
payload: "hello".to_string(),
},
it.next().unwrap().unwrap(),
);
check_notification(
Notification {
process_id: 0,
channel: "test_notification_iterator_one_channel2".to_string(),
payload: "world".to_string(),
},
it.next().unwrap().unwrap(),
);
2016-09-13 04:34:03 +00:00
assert!(it.next().unwrap().is_none());
2018-04-15 17:38:18 +00:00
or_panic!(conn.execute("NOTIFY test_notification_iterator_one_channel, '!'", &[],));
2017-07-01 03:35:17 +00:00
check_notification(
Notification {
process_id: 0,
channel: "test_notification_iterator_one_channel".to_string(),
payload: "!".to_string(),
},
it.next().unwrap().unwrap(),
);
2016-09-13 04:34:03 +00:00
assert!(it.next().unwrap().is_none());
}
#[test]
fn test_notifications_next_block() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
or_panic!(conn.execute("LISTEN test_notifications_next_block", &[]));
2015-02-19 17:17:48 +00:00
let _t = thread::spawn(|| {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2015-12-06 02:57:17 +00:00
thread::sleep(Duration::from_millis(500));
2018-04-15 17:38:18 +00:00
or_panic!(conn.execute("NOTIFY test_notifications_next_block, 'foo'", &[],));
});
2015-09-19 05:51:11 +00:00
let notifications = conn.notifications();
2017-07-01 03:35:17 +00:00
check_notification(
Notification {
process_id: 0,
channel: "test_notifications_next_block".to_string(),
payload: "foo".to_string(),
},
notifications.blocking_iter().next().unwrap().unwrap(),
);
}
#[test]
fn test_notification_next_timeout() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
or_panic!(conn.execute("LISTEN test_notifications_next_timeout", &[]));
let _t = thread::spawn(|| {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2015-12-06 02:57:17 +00:00
thread::sleep(Duration::from_millis(500));
2018-04-15 17:38:18 +00:00
or_panic!(conn.execute("NOTIFY test_notifications_next_timeout, 'foo'", &[],));
2015-12-06 02:57:17 +00:00
thread::sleep(Duration::from_millis(1500));
2018-04-15 17:38:18 +00:00
or_panic!(conn.execute("NOTIFY test_notifications_next_timeout, 'foo'", &[],));
});
let notifications = conn.notifications();
let mut it = notifications.timeout_iter(Duration::from_secs(1));
2017-07-01 03:35:17 +00:00
check_notification(
Notification {
process_id: 0,
channel: "test_notifications_next_timeout".to_string(),
payload: "foo".to_string(),
},
it.next().unwrap().unwrap(),
);
2016-09-13 04:34:03 +00:00
assert!(it.next().unwrap().is_none());
}
#[test]
fn test_notification_disconnect() {
2018-04-15 17:38:18 +00:00
let conn = or_panic!(Connection::connect(
"postgres://postgres@localhost:5433",
TlsMode::None,
));
or_panic!(conn.execute("LISTEN test_notifications_disconnect", &[]));
let _t = thread::spawn(|| {
let conn = or_panic!(Connection::connect(
"postgres://postgres@localhost:5433",
TlsMode::None,
));
thread::sleep(Duration::from_millis(500));
or_panic!(conn.execute(
"SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE query = 'LISTEN test_notifications_disconnect'",
&[],
));
});
let notifications = conn.notifications();
assert!(notifications.blocking_iter().next().is_err());
}
2013-10-21 00:32:14 +00:00
#[test]
// This test is pretty sad, but I don't think there's a better way :(
2013-10-21 00:54:50 +00:00
fn test_cancel_query() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2013-10-21 00:32:14 +00:00
let cancel_data = conn.cancel_data();
let t = thread::spawn(move || {
2017-07-01 03:35:17 +00:00
thread::sleep(Duration::from_millis(500));
assert!(
postgres::cancel_query(
"postgres://postgres@localhost:5433",
TlsMode::None,
&cancel_data,
).is_ok()
2017-07-01 03:35:17 +00:00
);
});
2013-10-21 00:32:14 +00:00
match conn.execute("SELECT pg_sleep(10)", &[]) {
2017-07-17 01:13:49 +00:00
Err(ref e) if e.code() == Some(&QUERY_CANCELED) => {}
Err(res) => panic!("Unexpected result {:?}", res),
2014-10-30 04:26:03 +00:00
_ => panic!("Unexpected result"),
2013-10-21 00:32:14 +00:00
}
t.join().unwrap();
2013-10-21 00:32:14 +00:00
}
2013-11-10 05:55:29 +00:00
#[test]
#[cfg(feature = "with-openssl")]
fn test_require_ssl_conn() {
2018-01-10 05:18:34 +00:00
use openssl::ssl::{SslConnectorBuilder, SslMethod};
2016-10-02 00:38:18 +00:00
use postgres::tls::openssl::OpenSsl;
2016-11-06 04:01:26 +00:00
let mut builder = SslConnectorBuilder::new(SslMethod::tls()).unwrap();
2018-01-10 05:18:34 +00:00
builder.set_ca_file("../test/server.crt").unwrap();
2016-11-06 04:01:26 +00:00
let negotiator = OpenSsl::from(builder.build());
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::Require(&negotiator),
));
or_panic!(conn.execute("SELECT 1::VARCHAR", &[]));
2013-11-10 05:55:29 +00:00
}
#[test]
#[cfg(feature = "with-openssl")]
fn test_prefer_ssl_conn() {
2018-01-10 05:18:34 +00:00
use openssl::ssl::{SslConnectorBuilder, SslMethod};
2016-10-02 00:38:18 +00:00
use postgres::tls::openssl::OpenSsl;
2016-11-06 04:01:26 +00:00
let mut builder = SslConnectorBuilder::new(SslMethod::tls()).unwrap();
2018-01-10 05:18:34 +00:00
builder.set_ca_file("../test/server.crt").unwrap();
2016-11-06 04:01:26 +00:00
let negotiator = OpenSsl::from(builder.build());
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::Require(&negotiator),
));
or_panic!(conn.execute("SELECT 1::VARCHAR", &[]));
}
#[test]
#[cfg(feature = "with-security-framework")]
fn security_framework_ssl() {
2016-10-02 00:38:18 +00:00
use postgres::tls::security_framework::SecurityFramework;
use security_framework::certificate::SecCertificate;
2017-07-09 02:40:03 +00:00
let certificate = include_bytes!("../../test/server.der");
let certificate = or_panic!(SecCertificate::from_der(certificate));
2016-07-01 19:18:56 +00:00
let mut negotiator = SecurityFramework::new();
negotiator.builder_mut().anchor_certificates(&[certificate]);
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::Require(&negotiator),
));
or_panic!(conn.execute("SELECT 1::VARCHAR", &[]));
}
2016-11-09 21:33:04 +00:00
#[test]
2017-05-22 05:36:26 +00:00
#[ignore]
// need to ignore until native-tls supports extra root certs :(
2016-11-09 21:33:04 +00:00
#[cfg(feature = "with-native-tls")]
fn native_tls_ssl() {
use postgres::tls::native_tls::NativeTls;
let negotiator = NativeTls::new().unwrap();
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::Require(&negotiator),
));
2016-11-09 21:33:04 +00:00
or_panic!(conn.execute("SELECT 1::VARCHAR", &[]));
}
#[test]
fn test_plaintext_pass() {
2017-07-01 03:35:17 +00:00
or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://pass_user:password@localhost:5433/postgres",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
}
#[test]
fn test_plaintext_pass_no_pass() {
let ret = Connection::connect(
"postgres://pass_user@localhost:5433/postgres",
TlsMode::None,
);
match ret {
2017-07-17 01:13:49 +00:00
Err(ref e) if e.as_connection().is_some() => (),
Err(err) => panic!("Unexpected error {:?}", err),
2017-05-22 05:36:26 +00:00
_ => panic!("Expected error"),
}
}
#[test]
fn test_plaintext_pass_wrong_pass() {
2017-07-01 03:35:17 +00:00
let ret = Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://pass_user:asdf@localhost:5433/postgres",
2017-07-01 03:35:17 +00:00
TlsMode::None,
);
match ret {
2017-07-17 01:13:49 +00:00
Err(ref e) if e.code() == Some(&INVALID_PASSWORD) => {}
Err(err) => panic!("Unexpected error {:?}", err),
2017-05-22 05:36:26 +00:00
_ => panic!("Expected error"),
}
}
#[test]
fn test_md5_pass() {
2017-07-01 03:35:17 +00:00
or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://md5_user:password@localhost:5433/postgres",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
}
#[test]
fn test_md5_pass_no_pass() {
2017-07-09 02:40:03 +00:00
let ret = Connection::connect("postgres://md5_user@localhost:5433/postgres", TlsMode::None);
match ret {
2017-07-17 01:13:49 +00:00
Err(ref e) if e.as_connection().is_some() => (),
Err(err) => panic!("Unexpected error {:?}", err),
2017-05-22 05:36:26 +00:00
_ => panic!("Expected error"),
}
}
#[test]
fn test_md5_pass_wrong_pass() {
let ret = Connection::connect(
"postgres://md5_user:asdf@localhost:5433/postgres",
TlsMode::None,
);
2017-07-09 02:40:03 +00:00
match ret {
2017-07-17 01:13:49 +00:00
Err(ref e) if e.code() == Some(&INVALID_PASSWORD) => {}
2017-07-09 02:40:03 +00:00
Err(err) => panic!("Unexpected error {:?}", err),
_ => panic!("Expected error"),
}
}
#[test]
fn test_scram_pass() {
or_panic!(Connection::connect(
"postgres://scram_user:password@localhost:5433/postgres",
TlsMode::None,
));
}
#[test]
fn test_scram_pass_no_pass() {
let ret = Connection::connect(
"postgres://scram_user@localhost:5433/postgres",
TlsMode::None,
);
2017-07-09 02:40:03 +00:00
match ret {
2017-07-17 01:13:49 +00:00
Err(ref e) if e.as_connection().is_some() => (),
2017-07-09 02:40:03 +00:00
Err(err) => panic!("Unexpected error {:?}", err),
_ => panic!("Expected error"),
}
}
#[test]
fn test_scram_pass_wrong_pass() {
let ret = Connection::connect(
"postgres://scram_user:asdf@localhost:5433/postgres",
TlsMode::None,
);
match ret {
2017-07-17 01:13:49 +00:00
Err(ref e) if e.code() == Some(&INVALID_PASSWORD) => {}
Err(err) => panic!("Unexpected error {:?}", err),
2017-05-22 05:36:26 +00:00
_ => panic!("Expected error"),
}
}
2014-09-30 04:05:42 +00:00
#[test]
fn test_execute_copy_from_err() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT)", &[]));
2014-10-30 04:26:03 +00:00
let stmt = or_panic!(conn.prepare("COPY foo (id) FROM STDIN"));
2017-07-17 01:13:49 +00:00
let err = stmt.execute(&[]).unwrap_err();
match err.as_db() {
Some(err) if err.message.contains("COPY") => {}
_ => panic!("Unexpected error {:?}", err),
}
let err = stmt.execute(&[]).unwrap_err();
match err.as_db() {
Some(err) if err.message.contains("COPY") => {}
_ => panic!("Unexpected error {:?}", err),
2014-09-30 04:05:42 +00:00
}
}
2014-09-30 05:56:43 +00:00
2014-10-06 00:31:25 +00:00
#[test]
fn test_batch_execute_copy_from_err() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT)", &[]));
2017-07-17 01:13:49 +00:00
let err = conn.batch_execute("COPY foo (id) FROM STDIN").unwrap_err();
match err.as_db() {
Some(err) if err.message.contains("COPY") => {}
_ => panic!("Unexpected error {:?}", err),
2014-10-06 00:31:25 +00:00
}
}
#[test]
fn test_copy_io_error() {
struct ErrorReader;
impl io::Read for ErrorReader {
fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
Err(io::Error::new(io::ErrorKind::AddrNotAvailable, "boom"))
}
}
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT)", &[]));
let stmt = or_panic!(conn.prepare("COPY foo (id) FROM STDIN"));
2017-07-17 01:13:49 +00:00
let err = stmt.copy_in(&[], &mut ErrorReader).unwrap_err();
match err.as_io() {
Some(e) if e.kind() == io::ErrorKind::AddrNotAvailable => {}
_ => panic!("Unexpected error {:?}", err),
}
or_panic!(conn.execute("SELECT 1", &[]));
}
2015-05-26 03:40:57 +00:00
#[test]
fn test_copy() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2015-05-26 03:40:57 +00:00
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT)", &[]));
let stmt = or_panic!(conn.prepare("COPY foo (id) FROM STDIN"));
let mut data = &b"1\n2\n3\n5\n8\n"[..];
assert_eq!(5, or_panic!(stmt.copy_in(&[], &mut data)));
let stmt = or_panic!(conn.prepare("SELECT id FROM foo ORDER BY id"));
2017-07-01 03:35:17 +00:00
assert_eq!(
vec![1i32, 2, 3, 5, 8],
stmt.query(&[])
.unwrap()
.iter()
.map(|r| r.get(0))
.collect::<Vec<i32>>()
);
2015-05-26 03:40:57 +00:00
}
2015-08-16 03:39:13 +00:00
#[test]
2015-08-16 06:21:39 +00:00
fn test_query_copy_out_err() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
or_panic!(conn.batch_execute(
"
2015-08-16 03:39:13 +00:00
CREATE TEMPORARY TABLE foo (id INT);
2017-07-01 03:35:17 +00:00
INSERT INTO foo (id) VALUES (0), (1), (2), (3)",
));
2015-08-16 03:39:13 +00:00
let stmt = or_panic!(conn.prepare("COPY foo (id) TO STDOUT"));
2017-07-17 01:13:49 +00:00
let err = stmt.query(&[]).unwrap_err();
match err.as_io() {
Some(e) if e.to_string().contains("COPY") => {}
_ => panic!("unexpected error {:?}", err),
};
2015-08-16 03:39:13 +00:00
}
2015-05-26 03:40:57 +00:00
2015-08-16 06:21:39 +00:00
#[test]
fn test_copy_out() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
or_panic!(conn.batch_execute(
"
2015-08-16 06:21:39 +00:00
CREATE TEMPORARY TABLE foo (id INT);
2017-07-01 03:35:17 +00:00
INSERT INTO foo (id) VALUES (0), (1), (2), (3)",
));
2018-04-15 17:38:18 +00:00
let stmt = or_panic!(conn.prepare("COPY (SELECT id FROM foo ORDER BY id) TO STDOUT",));
let mut buf = vec![];
let count = or_panic!(stmt.copy_out(&[], &mut buf));
assert_eq!(count, 4);
assert_eq!(buf, b"0\n1\n2\n3\n");
2015-08-16 06:21:39 +00:00
or_panic!(conn.batch_execute("SELECT 1"));
}
#[test]
fn test_copy_out_error() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
or_panic!(conn.batch_execute(
"
CREATE TEMPORARY TABLE foo (id INT);
2017-07-01 03:35:17 +00:00
INSERT INTO foo (id) VALUES (0), (1), (2), (3)",
));
2018-04-15 17:38:18 +00:00
let stmt = or_panic!(conn.prepare("COPY (SELECT id FROM foo ORDER BY id) TO STDOUT (OIDS)",));
let mut buf = vec![];
2017-07-17 01:13:49 +00:00
let err = stmt.copy_out(&[], &mut buf).unwrap_err();
match err.as_db() {
Some(_) => {}
_ => panic!("unexpected error {}", err),
}
}
#[test]
// Just make sure the impls don't infinite loop
fn test_generic_connection() {
2017-05-22 05:36:26 +00:00
fn f<T>(t: &T)
2017-07-01 03:35:17 +00:00
where
T: GenericConnection,
2017-05-22 05:36:26 +00:00
{
or_panic!(t.execute("SELECT 1", &[]));
}
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
f(&conn);
2014-10-30 04:26:03 +00:00
let trans = or_panic!(conn.transaction());
f(&trans);
}
#[test]
fn test_custom_range_element_type() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
or_panic!(conn.execute(
"CREATE TYPE pg_temp.floatrange AS RANGE (
subtype = float8,
subtype_diff = float8mi
2017-05-22 05:36:26 +00:00
)",
2017-07-01 03:35:17 +00:00
&[],
));
let stmt = or_panic!(conn.prepare("SELECT $1::floatrange"));
2017-07-09 07:02:45 +00:00
let ty = &stmt.param_types()[0];
assert_eq!("floatrange", ty.name());
assert_eq!(&Kind::Range(FLOAT8), ty.kind());
}
#[test]
fn test_prepare_cached() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT)", &[]));
or_panic!(conn.execute("INSERT INTO foo (id) VALUES (1), (2)", &[]));
let stmt = or_panic!(conn.prepare_cached("SELECT id FROM foo ORDER BY id"));
2017-07-01 03:35:17 +00:00
assert_eq!(
vec![1, 2],
or_panic!(stmt.query(&[]))
.iter()
.map(|r| r.get(0))
.collect::<Vec<i32>>()
);
or_panic!(stmt.finish());
let stmt = or_panic!(conn.prepare_cached("SELECT id FROM foo ORDER BY id"));
2017-07-01 03:35:17 +00:00
assert_eq!(
vec![1, 2],
or_panic!(stmt.query(&[]))
.iter()
.map(|r| r.get(0))
.collect::<Vec<i32>>()
);
or_panic!(stmt.finish());
let stmt = or_panic!(conn.prepare_cached("SELECT id FROM foo ORDER BY id DESC"));
2017-07-01 03:35:17 +00:00
assert_eq!(
vec![2, 1],
or_panic!(stmt.query(&[]))
.iter()
.map(|r| r.get(0))
.collect::<Vec<i32>>()
);
or_panic!(stmt.finish());
}
#[test]
fn test_is_active() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
assert!(conn.is_active());
let trans = or_panic!(conn.transaction());
assert!(!conn.is_active());
assert!(trans.is_active());
{
let trans2 = or_panic!(trans.transaction());
assert!(!conn.is_active());
assert!(!trans.is_active());
assert!(trans2.is_active());
or_panic!(trans2.finish());
}
assert!(!conn.is_active());
assert!(trans.is_active());
or_panic!(trans.finish());
assert!(conn.is_active());
}
2015-02-16 04:22:56 +00:00
#[test]
fn test_parameter() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
2015-02-16 04:22:56 +00:00
assert_eq!(Some("UTF8".to_string()), conn.parameter("client_encoding"));
assert_eq!(None, conn.parameter("asdf"));
}
#[test]
fn test_get_bytes() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
let stmt = or_panic!(conn.prepare("SELECT '\\x00010203'::BYTEA"));
let result = or_panic!(stmt.query(&[]));
2017-07-01 03:35:17 +00:00
assert_eq!(
b"\x00\x01\x02\x03",
result.iter().next().unwrap().get_bytes(0).unwrap()
);
}
2015-02-15 01:16:25 +00:00
#[test]
fn url_unencoded_password() {
2017-07-01 03:35:17 +00:00
assert!(
2017-07-09 02:40:03 +00:00
"postgresql://username:password%1*@localhost:5433"
2017-07-01 03:35:17 +00:00
.into_connect_params()
.is_err()
)
}
#[test]
fn url_encoded_password() {
2017-07-09 02:40:03 +00:00
let params = "postgresql://username%7b%7c:password%7b%7c@localhost:5433"
2017-05-22 05:36:26 +00:00
.into_connect_params()
.unwrap();
2017-02-16 05:42:27 +00:00
assert_eq!("username{|", params.user().unwrap().name());
assert_eq!("password{|", params.user().unwrap().password().unwrap());
}
#[test]
fn test_transaction_isolation_level() {
2017-07-01 03:35:17 +00:00
let conn = or_panic!(Connection::connect(
2017-07-09 02:40:03 +00:00
"postgres://postgres@localhost:5433",
2017-07-01 03:35:17 +00:00
TlsMode::None,
));
assert_eq!(
IsolationLevel::ReadCommitted,
or_panic!(conn.transaction_isolation())
);
or_panic!(conn.set_transaction_config(
2018-01-10 05:18:34 +00:00
transaction::Config::new().isolation_level(IsolationLevel::ReadUncommitted,),
2017-07-01 03:35:17 +00:00
));
assert_eq!(
IsolationLevel::ReadUncommitted,
or_panic!(conn.transaction_isolation())
);
or_panic!(conn.set_transaction_config(
2018-01-10 05:18:34 +00:00
transaction::Config::new().isolation_level(IsolationLevel::RepeatableRead,),
2017-07-01 03:35:17 +00:00
));
assert_eq!(
IsolationLevel::RepeatableRead,
or_panic!(conn.transaction_isolation())
);
or_panic!(conn.set_transaction_config(
2018-01-10 05:18:34 +00:00
transaction::Config::new().isolation_level(IsolationLevel::Serializable,),
2017-07-01 03:35:17 +00:00
));
assert_eq!(
IsolationLevel::Serializable,
or_panic!(conn.transaction_isolation())
);
or_panic!(conn.set_transaction_config(
2018-01-10 05:18:34 +00:00
transaction::Config::new().isolation_level(IsolationLevel::ReadCommitted,),
2017-07-01 03:35:17 +00:00
));
assert_eq!(
IsolationLevel::ReadCommitted,
or_panic!(conn.transaction_isolation())
);
}
2015-06-07 16:15:52 +00:00
#[test]
fn test_rows_index() {
2017-07-09 02:40:03 +00:00
let conn = Connection::connect("postgres://postgres@localhost:5433", TlsMode::None).unwrap();
2017-07-01 03:35:17 +00:00
conn.batch_execute(
"
2015-06-07 16:15:52 +00:00
CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY);
INSERT INTO foo (id) VALUES (1), (2), (3);
2017-07-01 03:35:17 +00:00
",
).unwrap();
2015-06-07 16:15:52 +00:00
let stmt = conn.prepare("SELECT id FROM foo ORDER BY id").unwrap();
let rows = stmt.query(&[]).unwrap();
assert_eq!(3, rows.len());
2017-02-04 23:18:41 +00:00
assert_eq!(2i32, rows.get(1).get::<_, i32>(0));
2015-06-07 16:15:52 +00:00
}
#[test]
fn test_type_names() {
2017-07-09 02:40:03 +00:00
let conn = Connection::connect("postgres://postgres@localhost:5433", TlsMode::None).unwrap();
2017-07-01 03:35:17 +00:00
let stmt = conn.prepare(
"SELECT t.oid, t.typname
FROM pg_catalog.pg_type t, pg_namespace n
WHERE n.oid = t.typnamespace
AND n.nspname = 'pg_catalog'
AND t.oid < 10000
2017-07-01 03:35:17 +00:00
AND t.typtype != 'c'",
).unwrap();
for row in &stmt.query(&[]).unwrap() {
let id: Oid = row.get(0);
let name: String = row.get(1);
assert_eq!(Type::from_oid(id).unwrap().name(), name);
}
}
#[test]
fn test_conn_query() {
2017-07-09 02:40:03 +00:00
let conn = Connection::connect("postgres://postgres@localhost:5433", TlsMode::None).unwrap();
2017-07-01 03:35:17 +00:00
conn.batch_execute(
"
CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY);
INSERT INTO foo (id) VALUES (1), (2), (3);
2017-07-01 03:35:17 +00:00
",
).unwrap();
let ids = conn.query("SELECT id FROM foo ORDER BY id", &[])
2017-05-22 05:36:26 +00:00
.unwrap()
.iter()
.map(|r| r.get(0))
.collect::<Vec<i32>>();
assert_eq!(ids, [1, 2, 3]);
}
2016-02-25 06:29:09 +00:00
#[test]
fn transaction_config() {
2017-07-09 02:40:03 +00:00
let conn = Connection::connect("postgres://postgres@localhost:5433", TlsMode::None).unwrap();
2016-02-25 06:29:09 +00:00
let mut config = transaction::Config::new();
2017-05-22 05:36:26 +00:00
config
.isolation_level(IsolationLevel::Serializable)
.read_only(true)
.deferrable(true);
2016-02-25 06:29:09 +00:00
conn.set_transaction_config(&config).unwrap();
}
#[test]
fn transaction_config_one_setting() {
2017-07-09 02:40:03 +00:00
let conn = Connection::connect("postgres://postgres@localhost:5433", TlsMode::None).unwrap();
2017-05-22 05:36:26 +00:00
conn.set_transaction_config(transaction::Config::new().read_only(true))
.unwrap();
conn.set_transaction_config(transaction::Config::new().deferrable(true))
.unwrap();
}
2016-02-25 06:29:09 +00:00
#[test]
fn transaction_with() {
2017-07-09 02:40:03 +00:00
let conn = Connection::connect("postgres://postgres@localhost:5433", TlsMode::None).unwrap();
2016-02-25 06:29:09 +00:00
let mut config = transaction::Config::new();
2017-05-22 05:36:26 +00:00
config
.isolation_level(IsolationLevel::Serializable)
.read_only(true)
.deferrable(true);
2016-02-25 06:29:09 +00:00
conn.transaction_with(&config).unwrap().finish().unwrap();
}
#[test]
fn transaction_set_config() {
2017-07-09 02:40:03 +00:00
let conn = Connection::connect("postgres://postgres@localhost:5433", TlsMode::None).unwrap();
2016-02-25 06:29:09 +00:00
let trans = conn.transaction().unwrap();
let mut config = transaction::Config::new();
2017-05-22 05:36:26 +00:00
config
.isolation_level(IsolationLevel::Serializable)
.read_only(true)
.deferrable(true);
2016-02-25 06:29:09 +00:00
trans.set_config(&config).unwrap();
trans.finish().unwrap();
}
2018-04-15 17:38:18 +00:00
#[test]
fn keepalive() {
let params = "postgres://postgres@localhost:5433?keepalive=10"
.into_connect_params()
.unwrap();
assert_eq!(params.keepalive(), Some(Duration::from_secs(10)));
Connection::connect(params, TlsMode::None).unwrap();
}