dnim/rust-postgres
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Make SSL infrastructure implementation agnostic

Browse Source
This commit is contained in:
Steven Fackler 2015-04-26 23:21:46 -07:00
parent 627f101c78
commit be49982286
5 changed files with 161 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/error.rs
View File

@ -1,7 +1,6 @@
pub use ugh_privacy::DbError; pub use ugh_privacy::DbError;
use byteorder; use byteorder;
use openssl::ssl::error::SslError;
use phf; use phf;
use std::error; use std::error;
use std::convert::From; use std::convert::From;
@ -29,8 +28,8 @@ pub enum ConnectError {
UnsupportedAuthentication, UnsupportedAuthentication,
/// The Postgres server does not support SSL encryption. /// The Postgres server does not support SSL encryption.
NoSslSupport, NoSslSupport,
/// There was an error initializing the SSL session. /// There was an error initializing the SSL session
SslError(SslError), SslError(Box<error::Error>),
/// There was an error communicating with the server. /// There was an error communicating with the server.
IoError(io::Error), IoError(io::Error),
/// The server sent an unexpected response. /// The server sent an unexpected response.
@ -67,7 +66,7 @@ impl error::Error for ConnectError {
fn cause(&self) -> Option<&error::Error> { fn cause(&self) -> Option<&error::Error> {
match *self { match *self {
ConnectError::DbError(ref err) => Some(err), ConnectError::DbError(ref err) => Some(err),
ConnectError::SslError(ref err) => Some(err), ConnectError::SslError(ref err) => Some(&**err),
ConnectError::IoError(ref err) => Some(err), ConnectError::IoError(ref err) => Some(err),
_ => None _ => None
} }
@ -86,12 +85,6 @@ impl From<DbError> for ConnectError {
} }
} }
impl From<SslError> for ConnectError {
fn from(err: SslError) -> ConnectError {
ConnectError::SslError(err)
}
}
impl From<byteorder::Error> for ConnectError { impl From<byteorder::Error> for ConnectError {
fn from(err: byteorder::Error) -> ConnectError { fn from(err: byteorder::Error) -> ConnectError {
ConnectError::IoError(From::from(err)) ConnectError::IoError(From::from(err))

81
src/io_util.rs
View File

@ -1,4 +1,5 @@
use openssl::ssl::{SslStream, MaybeSslStream}; use openssl::ssl::{SslStream, SslContext};
use std::error::Error;
use std::io; use std::io;
use std::io::prelude::*; use std::io::prelude::*;
use std::net::TcpStream; use std::net::TcpStream;
@ -6,19 +7,76 @@ use std::net::TcpStream;
use unix_socket::UnixStream; use unix_socket::UnixStream;
use byteorder::ReadBytesExt; use byteorder::ReadBytesExt;
use {ConnectParams, SslMode, ConnectTarget, ConnectError}; use {ConnectParams, ConnectTarget, ConnectError};
use message; use message;
use message::WriteMessage; use message::WriteMessage;
use message::FrontendMessage::SslRequest; use message::FrontendMessage::SslRequest;
const DEFAULT_PORT: u16 = 5432; const DEFAULT_PORT: u16 = 5432;
pub trait StreamWrapper<S: Read+Write>: Read+Write+Send {
fn get_ref(&self) -> &S;
fn get_mut(&mut self) -> &mut S;
}
impl<S: Read+Write+Send> StreamWrapper<S> for SslStream<S> {
fn get_ref(&self) -> &S {
self.get_ref()
}
fn get_mut(&mut self) -> &mut S {
self.get_mut()
}
}
pub trait NegotiateSsl {
fn negotiate_ssl<S>(&mut self, stream: S) -> Result<Box<StreamWrapper<S>>, Box<Error>>
where S: Read+Write+Send+'static;
}
impl NegotiateSsl for SslContext {
fn negotiate_ssl<S>(&mut self, stream: S) -> Result<Box<StreamWrapper<S>>, Box<Error>>
where S: Read+Write+Send+'static {
let stream = try!(SslStream::new(self, stream));
Ok(Box::new(stream))
}
}
/// Specifies the SSL support requested for a new connection.
pub enum SslMode<N = NoSsl> {
/// The connection will not use SSL.
None,
/// The connection will use SSL if the backend supports it.
Prefer(N),
/// The connection must use SSL.
Require(N),
}
pub enum NoSsl {}
impl NegotiateSsl for NoSsl {
fn negotiate_ssl<S: Read+Write>(&mut self, stream: S)
-> Result<Box<StreamWrapper<S>>, Box<Error>> {
match *self {}
}
}
pub enum InternalStream { pub enum InternalStream {
Tcp(TcpStream), Tcp(TcpStream),
#[cfg(feature = "unix_socket")] #[cfg(feature = "unix_socket")]
Unix(UnixStream), Unix(UnixStream),
} }
impl StreamWrapper<InternalStream> for InternalStream {
fn get_ref(&self) -> &InternalStream {
self
}
fn get_mut(&mut self) -> &mut InternalStream {
self
}
}
impl Read for InternalStream { impl Read for InternalStream {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
match *self { match *self {
@ -62,14 +120,15 @@ fn open_socket(params: &ConnectParams) -> Result<InternalStream, ConnectError> {
} }
} }
pub fn initialize_stream(params: &ConnectParams, ssl: &SslMode) pub fn initialize_stream<N>(params: &ConnectParams, ssl: &mut SslMode<N>)
-> Result<MaybeSslStream<InternalStream>, ConnectError> { -> Result<Box<StreamWrapper<InternalStream>>, ConnectError>
where N: NegotiateSsl {
let mut socket = try!(open_socket(params)); let mut socket = try!(open_socket(params));
let (ssl_required, ctx) = match *ssl { let (ssl_required, negotiator) = match *ssl {
SslMode::None => return Ok(MaybeSslStream::Normal(socket)), SslMode::None => return Ok(Box::new(socket)),
SslMode::Prefer(ref ctx) => (false, ctx), SslMode::Prefer(ref mut negotiator) => (false, negotiator),
SslMode::Require(ref ctx) => (true, ctx) SslMode::Require(ref mut negotiator) => (true, negotiator),
}; };
try!(socket.write_message(&SslRequest { code: message::SSL_CODE })); try!(socket.write_message(&SslRequest { code: message::SSL_CODE }));
@ -79,12 +138,12 @@ pub fn initialize_stream(params: &ConnectParams, ssl: &SslMode)
if ssl_required { if ssl_required {
return Err(ConnectError::NoSslSupport); return Err(ConnectError::NoSslSupport);
} else { } else {
return Ok(MaybeSslStream::Normal(socket)); return Ok(Box::new(socket));
} }
} }
match SslStream::new(ctx, socket) { match negotiator.negotiate_ssl(socket) {
Ok(stream) => Ok(MaybeSslStream::Ssl(stream)), Ok(stream) => Ok(stream),
Err(err) => Err(ConnectError::SslError(err)) Err(err) => Err(ConnectError::SslError(err))
} }
} }

30
src/lib.rs
View File

@ -59,7 +59,6 @@ extern crate debug_builders;
use bufstream::BufStream; use bufstream::BufStream;
use debug_builders::DebugStruct; use debug_builders::DebugStruct;
use openssl::crypto::hash::{self, Hasher}; use openssl::crypto::hash::{self, Hasher};
use openssl::ssl::{SslContext, MaybeSslStream};
use serialize::hex::ToHex; use serialize::hex::ToHex;
use std::ascii::AsciiExt; use std::ascii::AsciiExt;
use std::borrow::{ToOwned, Cow}; use std::borrow::{ToOwned, Cow};
@ -80,6 +79,7 @@ use std::path::PathBuf;
pub use error::{Error, ConnectError, SqlState, DbError, ErrorPosition}; pub use error::{Error, ConnectError, SqlState, DbError, ErrorPosition};
#[doc(inline)] #[doc(inline)]
pub use types::{Oid, Type, Kind, ToSql, FromSql}; pub use types::{Oid, Type, Kind, ToSql, FromSql};
pub use io_util::{SslMode, NegotiateSsl, StreamWrapper, NoSsl};
use types::IsNull; use types::IsNull;
#[doc(inline)] #[doc(inline)]
pub use types::Slice; pub use types::Slice;
@ -387,8 +387,9 @@ pub struct CancelData {
/// # let _ = /// # let _ =
/// postgres::cancel_query(url, &SslMode::None, cancel_data); /// postgres::cancel_query(url, &SslMode::None, cancel_data);
/// ``` /// ```
pub fn cancel_query<T>(params: T, ssl: &SslMode, data: CancelData) pub fn cancel_query<T, N>(params: T, ssl: &mut SslMode<N>, data: CancelData)
-> result::Result<(), ConnectError> where T: IntoConnectParams { -> result::Result<(), ConnectError>
where T: IntoConnectParams, N: NegotiateSsl {
let params = try!(params.into_connect_params()); let params = try!(params.into_connect_params());
let mut socket = try!(io_util::initialize_stream(&params, ssl)); let mut socket = try!(io_util::initialize_stream(&params, ssl));
@ -464,7 +465,7 @@ struct CachedStatement {
} }
struct InnerConnection { struct InnerConnection {
stream: BufStream<MaybeSslStream<InternalStream>>, stream: BufStream<Box<StreamWrapper<InternalStream>>>,
notice_handler: Box<HandleNotice>, notice_handler: Box<HandleNotice>,
notifications: VecDeque<Notification>, notifications: VecDeque<Notification>,
cancel_data: CancelData, cancel_data: CancelData,
@ -486,8 +487,9 @@ impl Drop for InnerConnection {
} }
impl InnerConnection { impl InnerConnection {
fn connect<T>(params: T, ssl: &SslMode) -> result::Result<InnerConnection, ConnectError> fn connect<T, N>(params: T, ssl: &mut SslMode<N>)
where T: IntoConnectParams { -> result::Result<InnerConnection, ConnectError>
where T: IntoConnectParams, N: NegotiateSsl {
let params = try!(params.into_connect_params()); let params = try!(params.into_connect_params());
let stream = try!(io_util::initialize_stream(&params, ssl)); let stream = try!(io_util::initialize_stream(&params, ssl));
@ -1005,8 +1007,9 @@ impl Connection {
/// let conn = try!(Connection::connect(params, &SslMode::None)); /// let conn = try!(Connection::connect(params, &SslMode::None));
/// # Ok(()) }; /// # Ok(()) };
/// ``` /// ```
pub fn connect<T>(params: T, ssl: &SslMode) -> result::Result<Connection, ConnectError> pub fn connect<T, N>(params: T, ssl: &mut SslMode<N>)
where T: IntoConnectParams { -> result::Result<Connection, ConnectError>
where T: IntoConnectParams, N: NegotiateSsl {
InnerConnection::connect(params, ssl).map(|conn| { InnerConnection::connect(params, ssl).map(|conn| {
Connection { conn: RefCell::new(conn) } Connection { conn: RefCell::new(conn) }
}) })
@ -1244,17 +1247,6 @@ impl Connection {
} }
} }
/// Specifies the SSL support requested for a new connection.
#[derive(Debug)]
pub enum SslMode {
/// The connection will not use SSL.
None,
/// The connection will use SSL if the backend supports it.
Prefer(SslContext),
/// The connection must use SSL.
Require(SslContext)
}
/// Represents a transaction on a database connection. /// Represents a transaction on a database connection.
/// ///
/// The transaction will roll back by default. /// The transaction will roll back by default.

138
tests/test.rs
View File

@ -41,17 +41,17 @@ mod types;
#[test] #[test]
fn test_non_default_database() { fn test_non_default_database() {
or_panic!(Connection::connect("postgres://postgres@localhost/postgres", &SslMode::None)); or_panic!(Connection::connect("postgres://postgres@localhost/postgres", &mut SslMode::None));
} }
#[test] #[test]
fn test_url_terminating_slash() { fn test_url_terminating_slash() {
or_panic!(Connection::connect("postgres://postgres@localhost/", &SslMode::None)); or_panic!(Connection::connect("postgres://postgres@localhost/", &mut SslMode::None));
} }
#[test] #[test]
fn test_prepare_err() { fn test_prepare_err() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let stmt = conn.prepare("invalid sql database"); let stmt = conn.prepare("invalid sql database");
match stmt { match stmt {
Err(Error::DbError(ref e)) if e.code() == &SyntaxError && e.position() == Some(&Normal(1)) => {} Err(Error::DbError(ref e)) if e.code() == &SyntaxError && e.position() == Some(&Normal(1)) => {}
@ -62,7 +62,7 @@ fn test_prepare_err() {
#[test] #[test]
fn test_unknown_database() { fn test_unknown_database() {
match Connection::connect("postgres://postgres@localhost/asdf", &SslMode::None) { match Connection::connect("postgres://postgres@localhost/asdf", &mut SslMode::None) {
Err(ConnectError::DbError(ref e)) if e.code() == &InvalidCatalogName => {} Err(ConnectError::DbError(ref e)) if e.code() == &InvalidCatalogName => {}
Err(resp) => panic!("Unexpected result {:?}", resp), Err(resp) => panic!("Unexpected result {:?}", resp),
_ => panic!("Unexpected result"), _ => panic!("Unexpected result"),
@ -71,14 +71,14 @@ fn test_unknown_database() {
#[test] #[test]
fn test_connection_finish() { fn test_connection_finish() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
assert!(conn.finish().is_ok()); assert!(conn.finish().is_ok());
} }
#[test] #[test]
#[cfg_attr(not(feature = "unix_socket"), ignore)] #[cfg_attr(not(feature = "unix_socket"), ignore)]
fn test_unix_connection() { fn test_unix_connection() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let stmt = or_panic!(conn.prepare("SHOW unix_socket_directories")); let stmt = or_panic!(conn.prepare("SHOW unix_socket_directories"));
let result = or_panic!(stmt.query(&[])); let result = or_panic!(stmt.query(&[]));
let unix_socket_directories: String = result.iter().map(|row| row.get(0)).next().unwrap(); let unix_socket_directories: String = result.iter().map(|row| row.get(0)).next().unwrap();
@ -92,13 +92,13 @@ fn test_unix_connection() {
let path = url::percent_encoding::utf8_percent_encode( let path = url::percent_encoding::utf8_percent_encode(
unix_socket_directory, url::percent_encoding::USERNAME_ENCODE_SET); unix_socket_directory, url::percent_encoding::USERNAME_ENCODE_SET);
let url = format!("postgres://postgres@{}", path); let url = format!("postgres://postgres@{}", path);
let conn = or_panic!(Connection::connect(&url[..], &SslMode::None)); let conn = or_panic!(Connection::connect(&url[..], &mut SslMode::None));
assert!(conn.finish().is_ok()); assert!(conn.finish().is_ok());
} }
#[test] #[test]
fn test_transaction_commit() { fn test_transaction_commit() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[]));
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
@ -114,7 +114,7 @@ fn test_transaction_commit() {
#[test] #[test]
fn test_transaction_commit_finish() { fn test_transaction_commit_finish() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[]));
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
@ -130,7 +130,7 @@ fn test_transaction_commit_finish() {
#[test] #[test]
fn test_transaction_commit_method() { fn test_transaction_commit_method() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[]));
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
@ -145,7 +145,7 @@ fn test_transaction_commit_method() {
#[test] #[test]
fn test_transaction_rollback() { fn test_transaction_rollback() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[]));
or_panic!(conn.execute("INSERT INTO foo (id) VALUES ($1)", &[&1i32])); or_panic!(conn.execute("INSERT INTO foo (id) VALUES ($1)", &[&1i32]));
@ -162,7 +162,7 @@ fn test_transaction_rollback() {
#[test] #[test]
fn test_transaction_rollback_finish() { fn test_transaction_rollback_finish() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[]));
or_panic!(conn.execute("INSERT INTO foo (id) VALUES ($1)", &[&1i32])); or_panic!(conn.execute("INSERT INTO foo (id) VALUES ($1)", &[&1i32]));
@ -179,7 +179,7 @@ fn test_transaction_rollback_finish() {
#[test] #[test]
fn test_nested_transactions() { fn test_nested_transactions() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[]));
or_panic!(conn.execute("INSERT INTO foo (id) VALUES (1)", &[])); or_panic!(conn.execute("INSERT INTO foo (id) VALUES (1)", &[]));
@ -225,7 +225,7 @@ fn test_nested_transactions() {
#[test] #[test]
fn test_nested_transactions_finish() { fn test_nested_transactions_finish() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[]));
or_panic!(conn.execute("INSERT INTO foo (id) VALUES (1)", &[])); or_panic!(conn.execute("INSERT INTO foo (id) VALUES (1)", &[]));
@ -281,7 +281,7 @@ fn test_nested_transactions_finish() {
#[test] #[test]
#[should_panic(expected = "active transaction")] #[should_panic(expected = "active transaction")]
fn test_conn_trans_when_nested() { fn test_conn_trans_when_nested() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let _trans = or_panic!(conn.transaction()); let _trans = or_panic!(conn.transaction());
conn.transaction().unwrap(); conn.transaction().unwrap();
} }
@ -289,7 +289,7 @@ fn test_conn_trans_when_nested() {
#[test] #[test]
#[should_panic(expected = "active transaction")] #[should_panic(expected = "active transaction")]
fn test_trans_with_nested_trans() { fn test_trans_with_nested_trans() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
let _trans2 = or_panic!(trans.transaction()); let _trans2 = or_panic!(trans.transaction());
trans.transaction().unwrap(); trans.transaction().unwrap();
@ -297,7 +297,7 @@ fn test_trans_with_nested_trans() {
#[test] #[test]
fn test_stmt_execute_after_transaction() { fn test_stmt_execute_after_transaction() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
let stmt = or_panic!(trans.prepare("SELECT 1")); let stmt = or_panic!(trans.prepare("SELECT 1"));
or_panic!(trans.finish()); or_panic!(trans.finish());
@ -307,7 +307,7 @@ fn test_stmt_execute_after_transaction() {
#[test] #[test]
fn test_stmt_finish() { fn test_stmt_finish() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY)", &[]));
let stmt = or_panic!(conn.prepare("SELECT * FROM foo")); let stmt = or_panic!(conn.prepare("SELECT * FROM foo"));
assert!(stmt.finish().is_ok()); assert!(stmt.finish().is_ok());
@ -315,7 +315,7 @@ fn test_stmt_finish() {
#[test] #[test]
fn test_batch_execute() { fn test_batch_execute() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let query = "CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY); let query = "CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY);
INSERT INTO foo (id) VALUES (10);"; INSERT INTO foo (id) VALUES (10);";
or_panic!(conn.batch_execute(query)); or_panic!(conn.batch_execute(query));
@ -328,7 +328,7 @@ fn test_batch_execute() {
#[test] #[test]
fn test_batch_execute_error() { fn test_batch_execute_error() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let query = "CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY); let query = "CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY);
INSERT INTO foo (id) VALUES (10); INSERT INTO foo (id) VALUES (10);
asdfa; asdfa;
@ -345,7 +345,7 @@ fn test_batch_execute_error() {
#[test] #[test]
fn test_transaction_batch_execute() { fn test_transaction_batch_execute() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
let query = "CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY); let query = "CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY);
INSERT INTO foo (id) VALUES (10);"; INSERT INTO foo (id) VALUES (10);";
@ -359,7 +359,7 @@ fn test_transaction_batch_execute() {
#[test] #[test]
fn test_query() { fn test_query() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY)", &[]));
or_panic!(conn.execute("INSERT INTO foo (id) VALUES ($1), ($2)", or_panic!(conn.execute("INSERT INTO foo (id) VALUES ($1), ($2)",
&[&1i64, &2i64])); &[&1i64, &2i64]));
@ -371,7 +371,7 @@ fn test_query() {
#[test] #[test]
fn test_error_after_datarow() { fn test_error_after_datarow() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let stmt = or_panic!(conn.prepare(" let stmt = or_panic!(conn.prepare("
SELECT SELECT
(SELECT generate_series(1, ss.i)) (SELECT generate_series(1, ss.i))
@ -388,7 +388,7 @@ FROM (SELECT gs.i
#[test] #[test]
fn test_lazy_query() { fn test_lazy_query() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
or_panic!(trans.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[])); or_panic!(trans.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[]));
@ -405,8 +405,8 @@ fn test_lazy_query() {
#[test] #[test]
#[should_panic(expected = "same `Connection` as")] #[should_panic(expected = "same `Connection` as")]
fn test_lazy_query_wrong_conn() { fn test_lazy_query_wrong_conn() {
let conn1 = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn1 = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let conn2 = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn2 = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let trans = or_panic!(conn1.transaction()); let trans = or_panic!(conn1.transaction());
let stmt = or_panic!(conn2.prepare("SELECT 1::INT")); let stmt = or_panic!(conn2.prepare("SELECT 1::INT"));
@ -415,14 +415,14 @@ fn test_lazy_query_wrong_conn() {
#[test] #[test]
fn test_param_types() { fn test_param_types() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let stmt = or_panic!(conn.prepare("SELECT $1::INT, $2::VARCHAR")); let stmt = or_panic!(conn.prepare("SELECT $1::INT, $2::VARCHAR"));
assert_eq!(stmt.param_types(), &[Type::Int4, Type::Varchar][..]); assert_eq!(stmt.param_types(), &[Type::Int4, Type::Varchar][..]);
} }
#[test] #[test]
fn test_columns() { fn test_columns() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let stmt = or_panic!(conn.prepare("SELECT 1::INT as a, 'hi'::VARCHAR as b")); let stmt = or_panic!(conn.prepare("SELECT 1::INT as a, 'hi'::VARCHAR as b"));
let cols = stmt.columns(); let cols = stmt.columns();
assert_eq!(2, cols.len()); assert_eq!(2, cols.len());
@ -434,7 +434,7 @@ fn test_columns() {
#[test] #[test]
fn test_execute_counts() { fn test_execute_counts() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
assert_eq!(0, or_panic!(conn.execute("CREATE TEMPORARY TABLE foo ( assert_eq!(0, or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (
id SERIAL PRIMARY KEY, id SERIAL PRIMARY KEY,
b INT b INT
@ -447,7 +447,7 @@ fn test_execute_counts() {
#[test] #[test]
fn test_wrong_param_type() { fn test_wrong_param_type() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
match conn.execute("SELECT $1::VARCHAR", &[&1i32]) { match conn.execute("SELECT $1::VARCHAR", &[&1i32]) {
Err(Error::WrongType(_)) => {} Err(Error::WrongType(_)) => {}
res => panic!("unexpected result {:?}", res) res => panic!("unexpected result {:?}", res)
@ -457,20 +457,20 @@ fn test_wrong_param_type() {
#[test] #[test]
#[should_panic(expected = "expected 2 parameters but got 1")] #[should_panic(expected = "expected 2 parameters but got 1")]
fn test_too_few_params() { fn test_too_few_params() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let _ = conn.execute("SELECT $1::INT, $2::INT", &[&1i32]); let _ = conn.execute("SELECT $1::INT, $2::INT", &[&1i32]);
} }
#[test] #[test]
#[should_panic(expected = "expected 2 parameters but got 3")] #[should_panic(expected = "expected 2 parameters but got 3")]
fn test_too_many_params() { fn test_too_many_params() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let _ = conn.execute("SELECT $1::INT, $2::INT", &[&1i32, &2i32, &3i32]); let _ = conn.execute("SELECT $1::INT, $2::INT", &[&1i32, &2i32, &3i32]);
} }
#[test] #[test]
fn test_index_named() { fn test_index_named() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let stmt = or_panic!(conn.prepare("SELECT 10::INT as val")); let stmt = or_panic!(conn.prepare("SELECT 10::INT as val"));
let result = or_panic!(stmt.query(&[])); let result = or_panic!(stmt.query(&[]));
@ -480,7 +480,7 @@ fn test_index_named() {
#[test] #[test]
#[should_panic] #[should_panic]
fn test_index_named_fail() { fn test_index_named_fail() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let stmt = or_panic!(conn.prepare("SELECT 10::INT as id")); let stmt = or_panic!(conn.prepare("SELECT 10::INT as id"));
let result = or_panic!(stmt.query(&[])); let result = or_panic!(stmt.query(&[]));
@ -489,7 +489,7 @@ fn test_index_named_fail() {
#[test] #[test]
fn test_get_named_err() { fn test_get_named_err() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let stmt = or_panic!(conn.prepare("SELECT 10::INT as id")); let stmt = or_panic!(conn.prepare("SELECT 10::INT as id"));
let result = or_panic!(stmt.query(&[])); let result = or_panic!(stmt.query(&[]));
@ -501,7 +501,7 @@ fn test_get_named_err() {
#[test] #[test]
fn test_get_was_null() { fn test_get_was_null() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let stmt = or_panic!(conn.prepare("SELECT NULL::INT as id")); let stmt = or_panic!(conn.prepare("SELECT NULL::INT as id"));
let result = or_panic!(stmt.query(&[])); let result = or_panic!(stmt.query(&[]));
@ -513,7 +513,7 @@ fn test_get_was_null() {
#[test] #[test]
fn test_get_off_by_one() { fn test_get_off_by_one() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let stmt = or_panic!(conn.prepare("SELECT 10::INT as id")); let stmt = or_panic!(conn.prepare("SELECT 10::INT as id"));
let result = or_panic!(stmt.query(&[])); let result = or_panic!(stmt.query(&[]));
@ -536,7 +536,7 @@ fn test_custom_notice_handler() {
} }
let conn = or_panic!(Connection::connect( let conn = or_panic!(Connection::connect(
"postgres://postgres@localhost?client_min_messages=NOTICE", &SslMode::None)); "postgres://postgres@localhost?client_min_messages=NOTICE", &mut SslMode::None));
conn.set_notice_handler(Box::new(Handler)); conn.set_notice_handler(Box::new(Handler));
or_panic!(conn.execute("CREATE FUNCTION pg_temp.note() RETURNS INT AS $$ or_panic!(conn.execute("CREATE FUNCTION pg_temp.note() RETURNS INT AS $$
BEGIN BEGIN
@ -550,7 +550,7 @@ fn test_custom_notice_handler() {
#[test] #[test]
fn test_notification_iterator_none() { fn test_notification_iterator_none() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
assert!(conn.notifications().next().is_none()); assert!(conn.notifications().next().is_none());
} }
@ -561,7 +561,7 @@ fn check_notification(expected: Notification, actual: Notification) {
#[test] #[test]
fn test_notification_iterator_some() { fn test_notification_iterator_some() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let mut it = conn.notifications(); let mut it = conn.notifications();
or_panic!(conn.execute("LISTEN test_notification_iterator_one_channel", &[])); or_panic!(conn.execute("LISTEN test_notification_iterator_one_channel", &[]));
or_panic!(conn.execute("LISTEN test_notification_iterator_one_channel2", &[])); or_panic!(conn.execute("LISTEN test_notification_iterator_one_channel2", &[]));
@ -591,11 +591,11 @@ fn test_notification_iterator_some() {
#[test] #[test]
fn test_notifications_next_block() { fn test_notifications_next_block() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("LISTEN test_notifications_next_block", &[])); or_panic!(conn.execute("LISTEN test_notifications_next_block", &[]));
let _t = thread::spawn(|| { let _t = thread::spawn(|| {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
thread::sleep_ms(500); thread::sleep_ms(500);
or_panic!(conn.execute("NOTIFY test_notifications_next_block, 'foo'", &[])); or_panic!(conn.execute("NOTIFY test_notifications_next_block, 'foo'", &[]));
}); });
@ -611,11 +611,11 @@ fn test_notifications_next_block() {
/* /*
#[test] #[test]
fn test_notifications_next_block_for() { fn test_notifications_next_block_for() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("LISTEN test_notifications_next_block_for", &[])); or_panic!(conn.execute("LISTEN test_notifications_next_block_for", &[]));
let _t = thread::spawn(|| { let _t = thread::spawn(|| {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
timer::sleep(Duration::milliseconds(500)); timer::sleep(Duration::milliseconds(500));
or_panic!(conn.execute("NOTIFY test_notifications_next_block_for, 'foo'", &[])); or_panic!(conn.execute("NOTIFY test_notifications_next_block_for, 'foo'", &[]));
}); });
@ -630,11 +630,11 @@ fn test_notifications_next_block_for() {
#[test] #[test]
fn test_notifications_next_block_for_timeout() { fn test_notifications_next_block_for_timeout() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("LISTEN test_notifications_next_block_for_timeout", &[])); or_panic!(conn.execute("LISTEN test_notifications_next_block_for_timeout", &[]));
let _t = thread::spawn(|| { let _t = thread::spawn(|| {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
timer::sleep(Duration::seconds(2)); timer::sleep(Duration::seconds(2));
or_panic!(conn.execute("NOTIFY test_notifications_next_block_for_timeout, 'foo'", &[])); or_panic!(conn.execute("NOTIFY test_notifications_next_block_for_timeout, 'foo'", &[]));
}); });
@ -653,12 +653,12 @@ fn test_notifications_next_block_for_timeout() {
#[test] #[test]
// This test is pretty sad, but I don't think there's a better way :( // This test is pretty sad, but I don't think there's a better way :(
fn test_cancel_query() { fn test_cancel_query() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let cancel_data = conn.cancel_data(); let cancel_data = conn.cancel_data();
let _t = thread::spawn(move || { let _t = thread::spawn(move || {
thread::sleep_ms(500); thread::sleep_ms(500);
assert!(postgres::cancel_query("postgres://postgres@localhost", &SslMode::None, assert!(postgres::cancel_query("postgres://postgres@localhost", &mut SslMode::None,
cancel_data).is_ok()); cancel_data).is_ok());
}); });
@ -673,7 +673,7 @@ fn test_cancel_query() {
fn test_require_ssl_conn() { fn test_require_ssl_conn() {
let ctx = SslContext::new(SslMethod::Sslv23).unwrap(); let ctx = SslContext::new(SslMethod::Sslv23).unwrap();
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", let conn = or_panic!(Connection::connect("postgres://postgres@localhost",
&SslMode::Require(ctx))); &mut SslMode::Require(ctx)));
or_panic!(conn.execute("SELECT 1::VARCHAR", &[])); or_panic!(conn.execute("SELECT 1::VARCHAR", &[]));
} }
@ -681,18 +681,18 @@ fn test_require_ssl_conn() {
fn test_prefer_ssl_conn() { fn test_prefer_ssl_conn() {
let ctx = SslContext::new(SslMethod::Sslv23).unwrap(); let ctx = SslContext::new(SslMethod::Sslv23).unwrap();
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", let conn = or_panic!(Connection::connect("postgres://postgres@localhost",
&SslMode::Prefer(ctx))); &mut SslMode::Prefer(ctx)));
or_panic!(conn.execute("SELECT 1::VARCHAR", &[])); or_panic!(conn.execute("SELECT 1::VARCHAR", &[]));
} }
#[test] #[test]
fn test_plaintext_pass() { fn test_plaintext_pass() {
or_panic!(Connection::connect("postgres://pass_user:password@localhost/postgres", &SslMode::None)); or_panic!(Connection::connect("postgres://pass_user:password@localhost/postgres", &mut SslMode::None));
} }
#[test] #[test]
fn test_plaintext_pass_no_pass() { fn test_plaintext_pass_no_pass() {
let ret = Connection::connect("postgres://pass_user@localhost/postgres", &SslMode::None); let ret = Connection::connect("postgres://pass_user@localhost/postgres", &mut SslMode::None);
match ret { match ret {
Err(ConnectError::MissingPassword) => (), Err(ConnectError::MissingPassword) => (),
Err(err) => panic!("Unexpected error {:?}", err), Err(err) => panic!("Unexpected error {:?}", err),
@ -702,7 +702,7 @@ fn test_plaintext_pass_no_pass() {
#[test] #[test]
fn test_plaintext_pass_wrong_pass() { fn test_plaintext_pass_wrong_pass() {
let ret = Connection::connect("postgres://pass_user:asdf@localhost/postgres", &SslMode::None); let ret = Connection::connect("postgres://pass_user:asdf@localhost/postgres", &mut SslMode::None);
match ret { match ret {
Err(ConnectError::DbError(ref e)) if e.code() == &InvalidPassword => {} Err(ConnectError::DbError(ref e)) if e.code() == &InvalidPassword => {}
Err(err) => panic!("Unexpected error {:?}", err), Err(err) => panic!("Unexpected error {:?}", err),
@ -712,12 +712,12 @@ fn test_plaintext_pass_wrong_pass() {
#[test] #[test]
fn test_md5_pass() { fn test_md5_pass() {
or_panic!(Connection::connect("postgres://md5_user:password@localhost/postgres", &SslMode::None)); or_panic!(Connection::connect("postgres://md5_user:password@localhost/postgres", &mut SslMode::None));
} }
#[test] #[test]
fn test_md5_pass_no_pass() { fn test_md5_pass_no_pass() {
let ret = Connection::connect("postgres://md5_user@localhost/postgres", &SslMode::None); let ret = Connection::connect("postgres://md5_user@localhost/postgres", &mut SslMode::None);
match ret { match ret {
Err(ConnectError::MissingPassword) => (), Err(ConnectError::MissingPassword) => (),
Err(err) => panic!("Unexpected error {:?}", err), Err(err) => panic!("Unexpected error {:?}", err),
@ -727,7 +727,7 @@ fn test_md5_pass_no_pass() {
#[test] #[test]
fn test_md5_pass_wrong_pass() { fn test_md5_pass_wrong_pass() {
let ret = Connection::connect("postgres://md5_user:asdf@localhost/postgres", &SslMode::None); let ret = Connection::connect("postgres://md5_user:asdf@localhost/postgres", &mut SslMode::None);
match ret { match ret {
Err(ConnectError::DbError(ref e)) if e.code() == &InvalidPassword => {} Err(ConnectError::DbError(ref e)) if e.code() == &InvalidPassword => {}
Err(err) => panic!("Unexpected error {:?}", err), Err(err) => panic!("Unexpected error {:?}", err),
@ -737,7 +737,7 @@ fn test_md5_pass_wrong_pass() {
#[test] #[test]
fn test_execute_copy_from_err() { fn test_execute_copy_from_err() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT)", &[]));
let stmt = or_panic!(conn.prepare("COPY foo (id) FROM STDIN")); let stmt = or_panic!(conn.prepare("COPY foo (id) FROM STDIN"));
match stmt.execute(&[]) { match stmt.execute(&[]) {
@ -754,7 +754,7 @@ fn test_execute_copy_from_err() {
#[test] #[test]
fn test_copy_in() { fn test_copy_in() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT, name VARCHAR)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT, name VARCHAR)", &[]));
let stmt = or_panic!(conn.prepare_copy_in("foo", &["id", "name"])); let stmt = or_panic!(conn.prepare_copy_in("foo", &["id", "name"]));
@ -773,7 +773,7 @@ fn test_copy_in() {
#[test] #[test]
fn test_copy_in_bad_column_count() { fn test_copy_in_bad_column_count() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT, name VARCHAR)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT, name VARCHAR)", &[]));
let stmt = or_panic!(conn.prepare_copy_in("foo", &["id", "name"])); let stmt = or_panic!(conn.prepare_copy_in("foo", &["id", "name"]));
@ -810,7 +810,7 @@ fn test_copy_in_bad_column_count() {
#[test] #[test]
fn test_copy_in_bad_type() { fn test_copy_in_bad_type() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT, name VARCHAR)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT, name VARCHAR)", &[]));
let stmt = or_panic!(conn.prepare_copy_in("foo", &["id", "name"])); let stmt = or_panic!(conn.prepare_copy_in("foo", &["id", "name"]));
@ -842,7 +842,7 @@ fn test_copy_in_weird_names() {
#[test] #[test]
fn test_batch_execute_copy_from_err() { fn test_batch_execute_copy_from_err() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT)", &[]));
match conn.batch_execute("COPY foo (id) FROM STDIN") { match conn.batch_execute("COPY foo (id) FROM STDIN") {
Err(Error::DbError(ref err)) if err.message().contains("COPY") => {} Err(Error::DbError(ref err)) if err.message().contains("COPY") => {}
@ -858,7 +858,7 @@ fn test_generic_connection() {
or_panic!(t.execute("SELECT 1", &[])); or_panic!(t.execute("SELECT 1", &[]));
} }
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
f(&conn); f(&conn);
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
f(&trans); f(&trans);
@ -866,7 +866,7 @@ fn test_generic_connection() {
#[test] #[test]
fn test_custom_range_element_type() { fn test_custom_range_element_type() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
or_panic!(trans.execute("CREATE TYPE floatrange AS RANGE ( or_panic!(trans.execute("CREATE TYPE floatrange AS RANGE (
subtype = float8, subtype = float8,
@ -884,7 +884,7 @@ fn test_custom_range_element_type() {
#[test] #[test]
fn test_prepare_cached() { fn test_prepare_cached() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT)", &[]));
or_panic!(conn.execute("INSERT INTO foo (id) VALUES (1), (2)", &[])); or_panic!(conn.execute("INSERT INTO foo (id) VALUES (1), (2)", &[]));
@ -903,7 +903,7 @@ fn test_prepare_cached() {
#[test] #[test]
fn test_is_active() { fn test_is_active() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
assert!(conn.is_active()); assert!(conn.is_active());
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
assert!(!conn.is_active()); assert!(!conn.is_active());
@ -923,14 +923,14 @@ fn test_is_active() {
#[test] #[test]
fn test_parameter() { fn test_parameter() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
assert_eq!(Some("UTF8".to_string()), conn.parameter("client_encoding")); assert_eq!(Some("UTF8".to_string()), conn.parameter("client_encoding"));
assert_eq!(None, conn.parameter("asdf")); assert_eq!(None, conn.parameter("asdf"));
} }
#[test] #[test]
fn test_get_bytes() { fn test_get_bytes() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let stmt = or_panic!(conn.prepare("SELECT '\\x00010203'::BYTEA")); let stmt = or_panic!(conn.prepare("SELECT '\\x00010203'::BYTEA"));
let result = or_panic!(stmt.query(&[])); let result = or_panic!(stmt.query(&[]));
assert_eq!(b"\x00\x01\x02\x03", result.iter().next().unwrap().get_bytes(0).unwrap()); assert_eq!(b"\x00\x01\x02\x03", result.iter().next().unwrap().get_bytes(0).unwrap());
@ -938,7 +938,7 @@ fn test_get_bytes() {
#[test] #[test]
fn test_get_opt_wrong_type() { fn test_get_opt_wrong_type() {
let conn = Connection::connect("postgres://postgres@localhost", &SslMode::None).unwrap(); let conn = Connection::connect("postgres://postgres@localhost", &mut SslMode::None).unwrap();
let stmt = conn.prepare("SELECT 1::INT").unwrap(); let stmt = conn.prepare("SELECT 1::INT").unwrap();
let res = stmt.query(&[]).unwrap(); let res = stmt.query(&[]).unwrap();
match res.iter().next().unwrap().get_opt::<_, String>(0) { match res.iter().next().unwrap().get_opt::<_, String>(0) {
@ -957,7 +957,7 @@ fn url_encoded_password() {
#[test] #[test]
fn test_transaction_isolation_level() { fn test_transaction_isolation_level() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
assert_eq!(IsolationLevel::ReadCommitted, or_panic!(conn.transaction_isolation())); assert_eq!(IsolationLevel::ReadCommitted, or_panic!(conn.transaction_isolation()));
or_panic!(conn.set_transaction_isolation(IsolationLevel::ReadUncommitted)); or_panic!(conn.set_transaction_isolation(IsolationLevel::ReadUncommitted));
assert_eq!(IsolationLevel::ReadUncommitted, or_panic!(conn.transaction_isolation())); assert_eq!(IsolationLevel::ReadUncommitted, or_panic!(conn.transaction_isolation()));

16
tests/types/mod.rs
View File

@ -16,7 +16,7 @@ mod rustc_serialize;
mod serde; mod serde;
fn test_type<T: PartialEq+FromSql+ToSql, S: fmt::Display>(sql_type: &str, checks: &[(T, S)]) { fn test_type<T: PartialEq+FromSql+ToSql, S: fmt::Display>(sql_type: &str, checks: &[(T, S)]) {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
for &(ref val, ref repr) in checks.iter() { for &(ref val, ref repr) in checks.iter() {
let stmt = or_panic!(conn.prepare(&*format!("SELECT {}::{}", *repr, sql_type))); let stmt = or_panic!(conn.prepare(&*format!("SELECT {}::{}", *repr, sql_type)));
let result = or_panic!(stmt.query(&[])).iter().next().unwrap().get(0); let result = or_panic!(stmt.query(&[])).iter().next().unwrap().get(0);
@ -102,7 +102,7 @@ fn test_text_params() {
#[test] #[test]
fn test_bpchar_params() { fn test_bpchar_params() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo ( or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (
id SERIAL PRIMARY KEY, id SERIAL PRIMARY KEY,
b CHAR(5) b CHAR(5)
@ -118,7 +118,7 @@ fn test_bpchar_params() {
#[test] #[test]
fn test_citext_params() { fn test_citext_params() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo ( or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (
id SERIAL PRIMARY KEY, id SERIAL PRIMARY KEY,
b CITEXT b CITEXT
@ -156,7 +156,7 @@ fn test_hstore_params() {
} }
fn test_nan_param<T: PartialEq+ToSql+FromSql>(sql_type: &str) { fn test_nan_param<T: PartialEq+ToSql+FromSql>(sql_type: &str) {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let stmt = or_panic!(conn.prepare(&*format!("SELECT 'NaN'::{}", sql_type))); let stmt = or_panic!(conn.prepare(&*format!("SELECT 'NaN'::{}", sql_type)));
let result = or_panic!(stmt.query(&[])); let result = or_panic!(stmt.query(&[]));
let val: T = result.iter().next().unwrap().get(0); let val: T = result.iter().next().unwrap().get(0);
@ -175,7 +175,7 @@ fn test_f64_nan_param() {
#[test] #[test]
fn test_pg_database_datname() { fn test_pg_database_datname() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
let stmt = or_panic!(conn.prepare("SELECT datname FROM pg_database")); let stmt = or_panic!(conn.prepare("SELECT datname FROM pg_database"));
let result = or_panic!(stmt.query(&[])); let result = or_panic!(stmt.query(&[]));
@ -186,7 +186,7 @@ fn test_pg_database_datname() {
#[test] #[test]
fn test_slice() { fn test_slice() {
let conn = Connection::connect("postgres://postgres@localhost", &SslMode::None).unwrap(); let conn = Connection::connect("postgres://postgres@localhost", &mut SslMode::None).unwrap();
conn.batch_execute("CREATE TEMPORARY TABLE foo (id SERIAL PRIMARY KEY, f VARCHAR); conn.batch_execute("CREATE TEMPORARY TABLE foo (id SERIAL PRIMARY KEY, f VARCHAR);
INSERT INTO foo (f) VALUES ('a'), ('b'), ('c'), ('d');").unwrap(); INSERT INTO foo (f) VALUES ('a'), ('b'), ('c'), ('d');").unwrap();
@ -198,7 +198,7 @@ fn test_slice() {
#[test] #[test]
fn test_slice_wrong_type() { fn test_slice_wrong_type() {
let conn = Connection::connect("postgres://postgres@localhost", &SslMode::None).unwrap(); let conn = Connection::connect("postgres://postgres@localhost", &mut SslMode::None).unwrap();
conn.batch_execute("CREATE TEMPORARY TABLE foo (id SERIAL PRIMARY KEY)").unwrap(); conn.batch_execute("CREATE TEMPORARY TABLE foo (id SERIAL PRIMARY KEY)").unwrap();
let stmt = conn.prepare("SELECT * FROM foo WHERE id = ANY($1)").unwrap(); let stmt = conn.prepare("SELECT * FROM foo WHERE id = ANY($1)").unwrap();
@ -211,7 +211,7 @@ fn test_slice_wrong_type() {
#[test] #[test]
fn test_slice_range() { fn test_slice_range() {
let conn = Connection::connect("postgres://postgres@localhost", &SslMode::None).unwrap(); let conn = Connection::connect("postgres://postgres@localhost", &mut SslMode::None).unwrap();
let stmt = conn.prepare("SELECT $1::INT8RANGE").unwrap(); let stmt = conn.prepare("SELECT $1::INT8RANGE").unwrap();
match stmt.query(&[&Slice(&[1i64])]) { match stmt.query(&[&Slice(&[1i64])]) {