Break the tests up into a more logical structure

Due to limitations of the language, I still cannot have the tests live
in another crate (unfortunate, as it means this is actually impossible
to use in any context...)

However, we can force a lot of the code changes (mostly namespacing in
`macros`) by moving the tests out of `lib.rs`.

The two blockers for usage in another crate are the impls for
`SelectableColumn` created by the `joinable_inner!` macro (this
constitutes a blanket impl for a non-crate-local type). I can define a
generic implementation in the library once either
rust-lang/rfcs#1268, or specialization lands.

The second blocker is the impl for `Queriable` that is generated by
`belongs_to!`, as `(A, B)` is not considered crate-local, even if both
`A` and `B` are crate local. I can define a generic impl for this one,
but only once specialization lands. (I'm not sure that I want to in this
case, but it looks like I might not have a choice?)

In fact, in the second one, I'm almost certain that I'd rather not have
to define a generic type, as I will probably want to define a separate
implementation depending on whether the relationship is one-to-many,
one-to-one, and optional one-to-one.

It also kinda sucks that these restrictions exist at all when the
definition comes from a macro in the library's crate. However I
understand that for coherence reasons, where the macro is defined makes
absolutely no difference.

Author: sgrif

src/lib.rs

@@ -16,7 +16,7 @@ macro_rules! table {
             $($column_name:ident -> $Type:ty,)+
         }
     ) => {
-        mod $name {
+        pub mod $name {
             use $crate::{QuerySource, Table, Column};
             use $crate::types::*;
             pub use self::columns::*;
@@ -98,9 +98,9 @@ macro_rules! queriable {
             $($field_name:ident -> $Type:ty,)+
         }
     ) => {
-        impl<ST> Queriable<ST> for $Struct where
-            ST: NativeSqlType,
-            ($($Type),+): types::FromSqlRow<ST>,
+        impl<ST> $crate::Queriable<ST> for $Struct where
+            ST: $crate::types::NativeSqlType,
+            ($($Type),+): $crate::types::FromSqlRow<ST>,
         {
             type Row = ($($Type),+);
 
@@ -150,43 +150,49 @@ macro_rules! insertable {
 
 macro_rules! joinable {
     ($child:ident -> $parent:ident ($source:ident = $target:ident)) => {
-        use query_source::{SelectableColumn, InnerJoinSource};
-
         joinable_inner!($child -> $parent ($source = $target));
         joinable_inner!($parent -> $child ($target = $source));
     }
 }
 
 macro_rules! joinable_inner {
     ($child:ident -> $parent:ident ($source:ident = $target:ident)) => {
-        impl JoinTo<$parent::table> for $child::table {
+        impl $crate::JoinTo<$parent::table> for $child::table {
             fn join_sql(&self) -> String {
+                use $crate::Column;
                 format!("{} = {}", $child::$source.qualified_name(), $parent::$target.qualified_name())
             }
         }
 
-        impl<C> SelectableColumn<$parent::table, InnerJoinSource<$child::table, $parent::table>> for C where
-            C: Column<$parent::table>,
+        impl<C> $crate::query_source::SelectableColumn<
+            $parent::table,
+            $crate::query_source::InnerJoinSource<$child::table, $parent::table>
+        > for C where
+            C: $crate::Column<$parent::table>,
         {}
 
-        impl<C> SelectableColumn<$child::table, InnerJoinSource<$child::table, $parent::table>> for C where
-            C: Column<$child::table>,
+        impl<C> $crate::query_source::SelectableColumn<
+            $child::table,
+            $crate::query_source::InnerJoinSource<$child::table, $parent::table>
+        > for C where
+            C: $crate::Column<$child::table>,
         {}
     }
 }
 
 macro_rules! belongs_to {
     ($parent:ty, $parent_table:ident, $child:ty, $child_table:ident) => {
-        impl Queriable<($child_table::SqlType, $parent_table::SqlType)> for ($child, $parent) {
+        impl $crate::Queriable<($child_table::SqlType, $parent_table::SqlType)>
+        for ($child, $parent) {
             type Row = (
-                <$child as Queriable<$child_table::SqlType>>::Row,
-                <$parent as Queriable<$parent_table::SqlType>>::Row,
+                <$child as $crate::Queriable<$child_table::SqlType>>::Row,
+                <$parent as $crate::Queriable<$parent_table::SqlType>>::Row,
             );
 
             fn build(row: Self::Row) -> Self {
                 (
-                    <$child as Queriable<$child_table::SqlType>>::build(row.0),
-                    <$parent as Queriable<$parent_table::SqlType>>::build(row.1),
+                    <$child as $crate::Queriable<$child_table::SqlType>>::build(row.0),
+                    <$parent as $crate::Queriable<$parent_table::SqlType>>::build(row.1),
                 )
             }
         }

src/macros.rs

@@ -0,0 +1,44 @@
+use super::schema::*;
+
+#[test]
+fn find() {
+    use tests::schema::users::table as users;
+
+    let connection = connection();
+    setup_users_table(&connection);
+
+    connection.execute("INSERT INTO users (name) VALUES ('Sean'), ('Tess')")
+        .unwrap();
+
+    assert_eq!(Ok(Some(User::new(1, "Sean"))), connection.find(&users, &1));
+    assert_eq!(Ok(Some(User::new(2, "Tess"))), connection.find(&users, &2));
+    assert_eq!(Ok(None::<User>), connection.find(&users, &3));
+    // This should fail type checking, and we should add a test to ensure
+    // it continues to fail to compile.
+    // connection.find(&users, &"1").unwrap();
+}
+
+table! {
+    users_with_name_pk (name) {
+        name -> VarChar,
+    }
+}
+
+#[test]
+fn find_with_non_serial_pk() {
+    use self::users_with_name_pk::table as users;
+
+    let connection = connection();
+    connection.execute("CREATE TABLE users_with_name_pk (name VARCHAR PRIMARY KEY)")
+        .unwrap();
+    connection.execute("INSERT INTO users_with_name_pk (name) VALUES ('Sean'), ('Tess')")
+        .unwrap();
+
+    assert_eq!(Ok(Some("Sean".to_string())), connection.find(&users, &"Sean"));
+    assert_eq!(Ok(Some("Tess".to_string())), connection.find(&users, &"Tess".to_string()));
+    assert_eq!(Ok(None::<String>), connection.find(&users, &"Wibble"));
+    // This should fail type checking, and we should add a test to ensure
+    // it continues to fail to compile.
+    // connection.find(&users, &1).unwrap();
+}
+

src/tests/find.rs

@@ -0,0 +1,83 @@
+use super::schema::*;
+
+#[test]
+fn insert_records() {
+    use tests::schema::users::table as users;
+    let connection = connection();
+    setup_users_table(&connection);
+
+    let new_users = vec![
+        NewUser::new("Sean", Some("Black")),
+        NewUser::new("Tess", None),
+    ];
+    let inserted_users: Vec<_> = connection.insert(&users, new_users).unwrap().collect();
+
+    let expected_users = vec![
+        User { id: 1, name: "Sean".to_string(), hair_color: Some("Black".to_string()) },
+        User { id: 2, name: "Tess".to_string(), hair_color: None },
+    ];
+    let actual_users: Vec<_> = connection.query_all(&users).unwrap().collect();
+
+    assert_eq!(expected_users, actual_users);
+    assert_eq!(expected_users, inserted_users);
+}
+
+#[test]
+fn insert_with_defaults() {
+    use tests::schema::users::table as users;
+    let connection = connection();
+    connection.execute("CREATE TABLE users (
+        id SERIAL PRIMARY KEY,
+        name VARCHAR NOT NULL,
+        hair_color VARCHAR NOT NULL DEFAULT 'Green'
+    )").unwrap();
+    let new_users = vec![
+        NewUser::new("Sean", Some("Black")),
+        NewUser::new("Tess", None),
+    ];
+    let inserted_users: Vec<_> = connection.insert(&users, new_users).unwrap().collect();
+
+    let expected_users = vec![
+        User { id: 1, name: "Sean".to_string(), hair_color: Some("Black".to_string()) },
+        User { id: 2, name: "Tess".to_string(), hair_color: Some("Green".to_string()) },
+    ];
+    let actual_users: Vec<_> = connection.query_all(&users).unwrap().collect();
+
+    assert_eq!(expected_users, actual_users);
+    assert_eq!(expected_users, inserted_users);
+}
+
+#[test]
+fn insert_with_defaults_not_provided() {
+    use tests::schema::users::table as users;
+    let connection = connection();
+    connection.execute("CREATE TABLE users (
+        id SERIAL PRIMARY KEY,
+        name VARCHAR NOT NULL,
+        hair_color VARCHAR NOT NULL DEFAULT 'Green'
+    )").unwrap();
+    let new_users = vec![
+        BaldUser { name: "Sean".to_string() },
+        BaldUser { name: "Tess".to_string() },
+    ];
+    let inserted_users: Vec<_> = connection.insert(&users, new_users).unwrap().collect();
+
+    let expected_users = vec![
+        User { id: 1, name: "Sean".to_string(), hair_color: Some("Green".to_string()) },
+        User { id: 2, name: "Tess".to_string(), hair_color: Some("Green".to_string()) },
+    ];
+    let actual_users: Vec<_> = connection.query_all(&users).unwrap().collect();
+
+    assert_eq!(expected_users, actual_users);
+    assert_eq!(expected_users, inserted_users);
+}
+
+struct BaldUser {
+    name: String,
+}
+
+insertable! {
+    BaldUser -> users {
+        name -> String,
+    }
+}

src/tests/insert.rs

@@ -0,0 +1,99 @@
+use super::schema::*;
+use {Table, QuerySource};
+
+#[test]
+fn belongs_to() {
+    let connection = connection();
+    setup_users_table(&connection);
+    setup_posts_table(&connection);
+
+    connection.execute("INSERT INTO users (name) VALUES ('Sean'), ('Tess')")
+        .unwrap();
+    connection.execute("INSERT INTO posts (user_id, title) VALUES
+        (1, 'Hello'),
+        (2, 'World')
+    ").unwrap();
+
+    let sean = User::new(1, "Sean");
+    let tess = User::new(2, "Tess");
+    let seans_post = Post { id: 1, user_id: 1, title: "Hello".to_string() };
+    let tess_post = Post { id: 2, user_id: 2, title: "World".to_string() };
+
+    let expected_data = vec![(seans_post, sean), (tess_post, tess)];
+    let source = posts::table.inner_join(users::table);
+    let actual_data: Vec<_> = connection.query_all(&source).unwrap().collect();
+
+    assert_eq!(expected_data, actual_data);
+}
+
+#[test]
+fn select_single_from_join() {
+    let connection = connection();
+    setup_users_table(&connection);
+    setup_posts_table(&connection);
+
+    connection.execute("INSERT INTO users (name) VALUES ('Sean'), ('Tess')")
+        .unwrap();
+    connection.execute("INSERT INTO posts (user_id, title) VALUES
+        (1, 'Hello'),
+        (2, 'World')
+    ").unwrap();
+
+    let source = posts::table.inner_join(users::table);
+    let select_name = source.select(users::name);
+    let select_title = source.select(posts::title);
+
+    let expected_names = vec!["Sean".to_string(), "Tess".to_string()];
+    let actual_names: Vec<String> = connection.query_all(&select_name).unwrap().collect();
+
+    assert_eq!(expected_names, actual_names);
+
+    let expected_titles = vec!["Hello".to_string(), "World".to_string()];
+    let actual_titles: Vec<String> = connection.query_all(&select_title).unwrap().collect();
+
+    assert_eq!(expected_titles, actual_titles);
+}
+
+#[test]
+fn select_multiple_from_join() {
+    let connection = connection();
+    setup_users_table(&connection);
+    setup_posts_table(&connection);
+
+    connection.execute("INSERT INTO users (name) VALUES ('Sean'), ('Tess')")
+        .unwrap();
+    connection.execute("INSERT INTO posts (user_id, title) VALUES
+        (1, 'Hello'),
+        (2, 'World')
+    ").unwrap();
+
+    let source = posts::table.inner_join(users::table)
+        .select((users::name, posts::title));
+
+    let expected_data = vec![
+        ("Sean".to_string(), "Hello".to_string()),
+        ("Tess".to_string(), "World".to_string()),
+    ];
+    let actual_data: Vec<_> = connection.query_all(&source).unwrap().collect();
+
+    assert_eq!(expected_data, actual_data);
+}
+
+#[test]
+fn select_only_one_side_of_join() {
+    let connection = connection();
+    setup_users_table(&connection);
+    setup_posts_table(&connection);
+
+    connection.execute("INSERT INTO users (name) VALUES ('Sean'), ('Tess')")
+        .unwrap();
+    connection.execute("INSERT INTO posts (user_id, title) VALUES (2, 'Hello')")
+        .unwrap();
+
+    let source = users::table.inner_join(posts::table).select(users::star);
+
+    let expected_data = vec![User::new(2, "Tess")];
+    let actual_data: Vec<_> = connection.query_all(&source).unwrap().collect();
+
+    assert_eq!(expected_data, actual_data);
+}

src/tests/joins.rs

@@ -0,0 +1,5 @@
+mod find;
+mod insert;
+mod joins;
+mod schema;
+mod select;