#[macro_use]
extern crate diesel;
#[macro_use]
extern crate diesel_migrations;
use diesel::pg::PgConnection;
use diesel::prelude::*;
use testcontainers::*;
use crate::models::CustomValue;
use testcontainers::images::postgres::Postgres;
#[test]
fn should_perform_a_query_with_diesel_json() {
use schema::test_table::dsl as tt_dsl;
let docker = clients::Cli::default();
let postgres_node = establish_connection(&docker);
let conn = postgres_node.0;
let new_data = models::NewCustomValueModel {
version: 0,
data: models::CustomValue {
name: "hello".to_owned(),
},
};
let saved_data: models::CustomValueModel = diesel::insert_into(tt_dsl::test_table)
.values(&new_data)
.get_result(&conn)
.expect("Error saving new TestData");
println!("Created data with id {}", saved_data.id);
let updated_data = diesel::update(tt_dsl::test_table)
.set(tt_dsl::data.eq(CustomValue {
name: "custom new value".to_owned(),
}))
.get_result::<models::CustomValueModel>(&conn)
.expect(&format!("Unable to find TestData id {}", saved_data.id));
println!("Updated data [{}]", updated_data.data.name);
let results = tt_dsl::test_table
.limit(5)
.load::<models::CustomValueModel>(&conn)
.expect("Error loading data");
println!("Displaying {} data", results.len());
for data in &results {
println!("{}", data.id);
println!("----------\n");
println!("{}", data.version);
}
assert!(results.len() > 0);
let num_deleted = diesel::delete(tt_dsl::test_table.filter(tt_dsl::id.eq(saved_data.id)))
.execute(&conn)
.expect("Error deleting data");
assert_eq!(1, num_deleted);
}
mod schema {
table! {
test_table (id) {
id -> Int8,
version -> Int4,
data -> Jsonb,
}
}
}
mod models {
use super::schema::*;
use serde_derive::*;
#[derive(Insertable)]
#[table_name = "test_table"]
pub struct NewCustomValueModel {
pub version: i32,
pub data: CustomValue,
}
#[derive(Queryable)]
pub struct CustomValueModel {
pub id: i64,
pub version: i32,
pub data: CustomValue,
}
use c3p0_diesel_macro::DieselJson;
#[derive(Serialize, Deserialize, Debug, DieselJson)]
pub struct CustomValue {
pub name: String,
}
}
embed_migrations!("./tests/migrations/");
pub fn establish_connection(
docker: &clients::Cli,
) -> (PgConnection, Container<clients::Cli, Postgres>) {
let node = docker.run(images::postgres::Postgres::default());
let database_url = format!(
"postgres://postgres:postgres@127.0.0.1:{}/postgres",
node.get_host_port(5432).unwrap()
);
let conn = PgConnection::establish(&database_url)
.expect(&format!("Error connecting to {}", database_url));
embedded_migrations::run_with_output(&conn, &mut std::io::stdout())
.expect(&format!("Should run the migrations"));
(conn, node)
}