use mimir::Result;
use mimir::{enums, flags};
use mimir::{AppContext, Context, ODPISubscrMessage};
extern "C" fn subscr_callback(
_ctxt: *mut ::std::os::raw::c_void,
_message: *mut ODPISubscrMessage,
) {
}
fn no_op(ctxt: &Context) -> Result<()> {
assert_eq!(
"12.2.0.1.0 (1202000100)",
format!("{}", ctxt.get_client_version()?)
);
Ok(())
}
fn ccp(ctxt: &Context) -> Result<()> {
let mut ccp = ctxt.init_common_create_params()?;
let default_flags = ccp.get_create_mode();
let new_flags = default_flags | flags::DPI_MODE_CREATE_THREADED;
let mut driver_name = String::from(env!("CARGO_PKG_NAME"));
driver_name.push(' ');
driver_name.push_str(env!("CARGO_PKG_VERSION"));
ccp.set_create_mode(new_flags);
ccp.set_edition("1.0")?;
ccp.set_encoding("UTF-8")?;
ccp.set_nchar_encoding("UTF-8")?;
assert_eq!(
ccp.get_create_mode(),
flags::DPI_MODE_CREATE_THREADED | flags::DPI_MODE_CREATE_DEFAULT
);
assert_eq!(ccp.get_encoding(), "UTF-8");
assert_eq!(ccp.get_nchar_encoding(), "UTF-8");
assert_eq!(ccp.get_edition(), "1.0");
assert_eq!(ccp.get_driver_name(), driver_name);
Ok(())
}
fn conn_cp(ctxt: &Context) -> Result<()> {
let mut conn = ctxt.init_conn_create_params()?;
let auth_default_flags = conn.get_auth_mode();
let auth_new_flags = auth_default_flags | flags::DPI_MODE_AUTH_SYSDBA;
let purity_default_flags = conn.get_purity();
let app_ctxt = AppContext::new("ns", "name", "value")?;
let app_ctxt_1 = AppContext::new("ns", "name1", "value1")?;
let mut app_ctxt_vec = Vec::new();
app_ctxt_vec.push(app_ctxt);
app_ctxt_vec.push(app_ctxt_1);
assert_eq!(purity_default_flags, enums::ODPIPurity::DefaultPurity);
conn.set_auth_mode(auth_new_flags);
conn.set_connection_class("conn_class")?;
conn.set_purity(enums::ODPIPurity::New);
conn.set_new_password("password")?;
conn.set_app_context(&app_ctxt_vec)?;
conn.set_external_auth(1);
conn.set_tag("you're it")?;
conn.set_match_any_tag(true);
let new_app_ctxt_vec = conn.get_app_context()?;
assert_eq!(
conn.get_auth_mode(),
flags::DPI_MODE_AUTH_SYSDBA | flags::DPI_MODE_AUTH_DEFAULT
);
assert_eq!(conn.get_connection_class(), "conn_class");
assert_eq!(conn.get_purity(), enums::ODPIPurity::New);
assert_eq!(conn.get_new_password(), "password");
assert_eq!(conn.get_num_app_context(), 2);
assert_eq!(new_app_ctxt_vec.len(), 2);
for (idx, ac) in new_app_ctxt_vec.iter().enumerate() {
assert_eq!(ac.get_namespace_name(), "ns");
match idx {
0 => {
assert_eq!(ac.get_name(), "name");
assert_eq!(ac.get_value(), "value");
}
1 => {
assert_eq!(ac.get_name(), "name1");
assert_eq!(ac.get_value(), "value1");
}
_ => assert!(false),
}
}
assert_eq!(conn.get_external_auth(), 1);
assert_eq!(conn.get_tag(), "you're it");
assert!(conn.get_match_any_tag());
assert_eq!(conn.get_out_tag(), "");
assert!(!conn.get_out_tag_found());
Ok(())
}
fn pcp(ctxt: &Context) -> Result<()> {
let mut pcp = ctxt.init_pool_create_params()?;
assert_eq!(pcp.get_min_sessions(), 1);
assert_eq!(pcp.get_max_sessions(), 1);
assert_eq!(pcp.get_session_increment(), 0);
assert_eq!(pcp.get_ping_interval(), 60);
assert_eq!(pcp.get_ping_timeout(), 5000);
assert!(pcp.get_homogeneous());
assert!(!pcp.get_external_auth());
assert_eq!(pcp.get_get_mode(), enums::ODPIPoolGetMode::NoWait);
assert_eq!(pcp.get_out_pool_name(), "");
pcp.set_min_sessions(10);
pcp.set_max_sessions(100);
pcp.set_session_increment(5);
pcp.set_ping_interval(-1);
pcp.set_ping_timeout(1000);
pcp.set_homogeneous(false);
pcp.set_external_auth(true);
pcp.set_get_mode(enums::ODPIPoolGetMode::ForceGet);
assert_eq!(pcp.get_min_sessions(), 10);
assert_eq!(pcp.get_max_sessions(), 100);
assert_eq!(pcp.get_session_increment(), 5);
assert_eq!(pcp.get_ping_interval(), -1);
assert_eq!(pcp.get_ping_timeout(), 1000);
assert!(!pcp.get_homogeneous());
assert!(pcp.get_external_auth());
assert_eq!(pcp.get_get_mode(), enums::ODPIPoolGetMode::ForceGet);
Ok(())
}
fn scp(ctxt: &Context) -> Result<()> {
let mut scp = ctxt.init_subscr_create_params()?;
assert_eq!(
scp.get_subscr_namespace(),
enums::ODPISubscrNamespace::DbChange
);
assert_eq!(scp.get_protocol(), enums::ODPISubscrProtocol::Callback);
assert_eq!(scp.get_qos(), flags::DPI_SUBSCR_QOS_NONE);
assert_eq!(scp.get_operations(), flags::DPI_OPCODE_ALL_OPS);
assert_eq!(scp.get_port_number(), 0);
assert_eq!(scp.get_timeout(), 0);
assert_eq!(scp.get_name(), "");
assert_eq!(scp.get_callback(), None);
assert_eq!(scp.get_recipient_name(), "");
scp.set_protocol(enums::ODPISubscrProtocol::HTTP);
scp.set_qos(flags::DPI_SUBSCR_QOS_BEST_EFFORT | flags::DPI_SUBSCR_QOS_ROWIDS);
scp.set_operations(flags::DPI_OPCODE_ALTER | flags::DPI_OPCODE_DROP);
scp.set_port_number(32_276);
scp.set_timeout(10_000);
scp.set_name("subscription")?;
scp.set_callback(Some(subscr_callback));
scp.set_recipient_name("yoda")?;
assert_eq!(scp.get_protocol(), enums::ODPISubscrProtocol::HTTP);
assert_eq!(
scp.get_qos(),
flags::DPI_SUBSCR_QOS_BEST_EFFORT | flags::DPI_SUBSCR_QOS_ROWIDS
);
assert_eq!(
scp.get_operations(),
flags::DPI_OPCODE_ALTER | flags::DPI_OPCODE_DROP
);
assert_eq!(scp.get_port_number(), 32_276);
assert_eq!(scp.get_timeout(), 10_000);
assert_eq!(scp.get_name(), "subscription");
assert_eq!(scp.get_recipient_name(), "yoda");
assert!(scp.get_callback() == Some(subscr_callback));
Ok(())
}
#[test]
fn context() {
check_with_ctxt!(no_op)
}
#[test]
fn common_create_params() {
check_with_ctxt!(ccp)
}
#[test]
fn connection_create_params() {
check_with_ctxt!(conn_cp)
}
#[test]
fn pool_create_params() {
check_with_ctxt!(pcp)
}
#[test]
fn subscription_create_params() {
check_with_ctxt!(scp)
}