sql_query_builder 2.6.2

mod full_api {
  use pretty_assertions::assert_eq;
  use sql_query_builder as sql;

  #[test]
  fn sql_standard_with_all_methods() {
    let query = sql::Delete::new()
      // required
      .delete_from("orders")
      // at least one
      .where_clause("login = $1")
      .where_and("product_id = $2")
      .where_or("login = 'bar'")
      .as_string();

    let expected_query = "\
      DELETE FROM orders \
      WHERE login = $1 \
      AND product_id = $2 \
      OR login = 'bar'\
    ";

    assert_eq!(expected_query, query);
  }

  #[cfg(feature = "postgresql")]
  #[test]
  fn postgres_with_all_methods() {
    let deactivated_users = sql::Select::new()
      .select("id")
      .from("users")
      .where_clause("ative = false");

    let query = sql::Delete::new()
      // required
      .delete_from("orders")
      // at least one is required
      .where_clause("login = $1")
      .where_and("product_id = $2")
      .where_or("login = 'bar'")
      // optional
      .returning("id")
      .with("deactivated_users", deactivated_users)
      .as_string();

    let expected_query = "\
      WITH deactivated_users AS (SELECT id FROM users WHERE ative = false) \
      DELETE FROM orders \
      WHERE login = $1 \
      AND product_id = $2 \
      OR login = 'bar' \
      RETURNING id\
    ";

    assert_eq!(expected_query, query);
  }

  #[cfg(feature = "sqlite")]
  #[test]
  fn sqlite_with_all_methods() {
    let deactivated_users = sql::Select::new()
      .select("id")
      .from("users")
      .where_clause("ative = false");

    let query = sql::Delete::new()
      // required
      .delete_from("orders")
      // at least one is required
      .where_clause("login = $1")
      .where_and("product_id = $2")
      .where_or("login = 'bar'")
      // optional
      .returning("id")
      .with("deactivated_users", deactivated_users)
      .as_string();

    let expected_query = "\
      WITH deactivated_users AS (SELECT id FROM users WHERE ative = false) \
      DELETE FROM orders \
      WHERE login = $1 \
      AND product_id = $2 \
      OR login = 'bar' \
      RETURNING id\
    ";

    assert_eq!(expected_query, query);
  }

  #[cfg(feature = "mysql")]
  #[test]
  fn mysql_with_all_methods() {
    let deactivated_users = sql::Select::new()
      .select("id")
      .from("users")
      .where_clause("ative = false");

    let query = sql::Delete::new()
      // one of is required
      .delete_from("orders")
      // methods below as a group
      .delete("low_priority")
      .from("address")
      // at least one is required
      .where_clause("login = $1")
      .where_and("product_id = $2")
      .where_or("login = 'bar'")
      // optional
      .cross_join("addresses")
      .inner_join("addresses on addresses.user_login = users.login")
      .left_join("addresses on addresses.user_login = users.login")
      .limit("123")
      .order_by("created_at asc")
      .partition("p1")
      .right_join("addresses on addresses.user_login = users.login")
      .with("deactivated_users", deactivated_users)
      .as_string();

    let expected_query = "\
      WITH deactivated_users AS (SELECT id FROM users WHERE ative = false) \
      DELETE low_priority FROM orders, address \
      CROSS JOIN addresses \
      INNER JOIN addresses on addresses.user_login = users.login \
      LEFT JOIN addresses on addresses.user_login = users.login \
      RIGHT JOIN addresses on addresses.user_login = users.login \
      PARTITION (p1) \
      WHERE login = $1 \
      AND product_id = $2 \
      OR login = 'bar' \
      ORDER BY created_at asc \
      LIMIT 123\
    ";

    assert_eq!(expected_query, query);
  }
}

mod builder_features {
  use pretty_assertions::assert_eq;
  use sql_query_builder as sql;

  #[test]
  fn delete_builder_should_be_displayable() {
    let delete = sql::Delete::new().delete_from("users").where_clause("login = 'foo'");

    println!("{}", delete);

    let query = delete.as_string();
    let expected_query = "DELETE FROM users WHERE login = 'foo'";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn delete_builder_should_be_debuggable() {
    let delete = sql::Delete::new()
      .delete_from("users")
      .where_clause("name = 'Foo'")
      .where_clause("login = 'foo'");

    println!("{:?}", delete);

    let expected_query = "DELETE FROM users WHERE name = 'Foo' AND login = 'foo'";
    let query = delete.as_string();

    assert_eq!(expected_query, query);
  }

  #[test]
  fn delete_builder_should_be_cloneable() {
    let delete_foo = sql::Delete::new()
      .raw("/* test raw */")
      .delete_from("users")
      .raw_before(sql::DeleteClause::Where, "/* test raw_before */")
      .where_clause("login = 'foo'")
      .raw_after(sql::DeleteClause::Where, "/* test raw_after */");

    let delete_foo_bar = delete_foo.clone().where_clause("name = 'Bar'");

    let query_foo = delete_foo.as_string();
    let query_foo_bar = delete_foo_bar.as_string();

    let expected_query_foo = "\
      /* test raw */ \
      DELETE FROM users \
      /* test raw_before */ \
      WHERE login = 'foo' \
      /* test raw_after */\
    ";
    let expected_query_foo_bar = "\
      /* test raw */ \
      DELETE FROM users \
      /* test raw_before */ \
      WHERE login = 'foo' AND name = 'Bar' \
      /* test raw_after */\
    ";

    assert_eq!(query_foo, expected_query_foo);
    assert_eq!(query_foo_bar, expected_query_foo_bar);
  }

  #[test]
  fn delete_builder_should_be_able_to_conditionally_add_clauses() {
    let mut delete = sql::Delete::new().delete_from("users").where_clause("name = 'Bar'");

    if true {
      delete = delete.where_clause("login = 'bar'");
    }

    let query = delete.as_string();
    let expected_query = "DELETE FROM users WHERE name = 'Bar' AND login = 'bar'";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn delete_builder_should_be_composable() {
    fn delete(delete: sql::Delete) -> sql::Delete {
      delete.delete_from("users")
    }

    fn conditions(delete: sql::Delete) -> sql::Delete {
      delete
        .where_clause("id = $1")
        .where_clause("active = true")
        .where_clause("created_at::date = current_date")
    }

    fn as_string(delete: sql::Delete) -> String {
      delete.as_string()
    }

    let query = Some(sql::Delete::new())
      .map(delete)
      .map(conditions)
      .map(as_string)
      .unwrap();

    let expected_query = "\
      DELETE FROM users \
      WHERE \
        id = $1 \
        AND active = true \
        AND created_at::date = current_date\
    ";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn all_standard_clauses_concatenated_in_order() {
    let query = sql::Delete::new()
      .delete_from("users")
      .where_clause("users.login = $1")
      .as_string();

    let expected_query = "\
      DELETE FROM users \
      WHERE users.login = $1\
    ";

    assert_eq!(expected_query, query);
  }

  /** This test can fail only at compile time
   * [More context](https://github.com/belchior/sql_query_builder/pull/53)
   */
  #[test]
  fn delete_builder_should_impl_send_and_sync() {
    fn assert_impl_sync_send(_builder: impl Sync + Send) {}
    assert_impl_sync_send(sql::Delete::new());
  }
}

mod builder_methods {
  use pretty_assertions::assert_eq;
  use sql_query_builder as sql;

  #[test]
  fn method_as_string_should_convert_the_current_state_into_string() {
    let query = sql::Delete::new().as_string();
    let expected_query = "";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_debug_should_print_at_console_in_a_human_readable_format() {
    let query = sql::Delete::new().delete_from("users").debug().as_string();
    let expected_query = "DELETE FROM users";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_new_should_initialize_as_empty_string() {
    let query = sql::Delete::new().as_string();
    let expected_query = "";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_print_should_print_in_one_line_the_current_state_of_builder() {
    let query = sql::Delete::new().delete_from("users").print().as_string();
    let expected_query = "DELETE FROM users";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_raw_should_add_raw_sql() {
    let query = sql::Delete::new().raw("delete from addresses").as_string();
    let expected_query = "delete from addresses";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_raw_should_accumulate_values_on_consecutive_calls() {
    let query = sql::Delete::new()
      .raw("delete from addresses")
      .raw("where city = 'Foo'")
      .as_string();
    let expected_query = "delete from addresses where city = 'Foo'";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_raw_should_not_accumulate_values_when_expression_is_empty() {
    let query = sql::Delete::new()
      .raw("")
      .raw("delete from addresses")
      .raw("")
      .as_string();
    let expected_query = "delete from addresses";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_raw_should_be_the_first_to_be_concatenated() {
    let query = sql::Delete::new()
      .raw("delete from addresses")
      .where_clause("country = 'Bar'")
      .as_string();
    let expected_query = "delete from addresses WHERE country = 'Bar'";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_raw_should_trim_space_of_the_argument() {
    let query = sql::Delete::new().raw("  delete from users  ").as_string();
    let expected_query = "delete from users";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_raw_should_not_accumulate_arguments_with_the_same_content() {
    let query = sql::Delete::new()
      .raw("delete from users")
      .raw("delete from users")
      .as_string();
    let expected_query = "delete from users";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_raw_after_should_trim_space_of_the_argument() {
    let query = sql::Delete::new()
      .delete_from("users")
      .raw_after(sql::DeleteClause::DeleteFrom, "  where name = 'Bar'  ")
      .as_string();
    let expected_query = "DELETE FROM users where name = 'Bar'";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_raw_before_should_trim_space_of_the_argument() {
    let query = sql::Delete::new()
      .raw_before(sql::DeleteClause::Where, "  where name = 'Bar'  ")
      .as_string();
    let expected_query = "where name = 'Bar'";

    assert_eq!(expected_query, query);
  }
}

mod delete_from_method {
  use pretty_assertions::assert_eq;
  use sql_query_builder as sql;

  #[test]
  fn method_delete_should_add_a_delete_clause() {
    let query = sql::Delete::new().delete_from("users").as_string();
    let expected_query = "DELETE FROM users";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_delete_should_override_value_on_consecutive_calls() {
    let query = sql::Delete::new()
      .delete_from("users")
      .delete_from("orders")
      .as_string();
    let expected_query = "DELETE FROM orders";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_delete_should_trim_space_of_the_argument() {
    let query = sql::Delete::new().delete_from("  orders  ").as_string();
    let expected_query = "DELETE FROM orders";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_raw_before_should_add_raw_sql_before_delete_clause() {
    let query = sql::Delete::new()
      .raw_before(sql::DeleteClause::DeleteFrom, "/* delete users */")
      .delete_from("users")
      .as_string();
    let expected_query = "/* delete users */ DELETE FROM users";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_raw_after_should_add_raw_sql_after_delete_clause() {
    let query = sql::Delete::new()
      .delete_from("users")
      .raw_after(sql::DeleteClause::DeleteFrom, "where login = 'foo'")
      .as_string();
    let expected_query = "DELETE FROM users where login = 'foo'";

    assert_eq!(expected_query, query);
  }
}

#[cfg(feature = "mysql")]
mod delete_method {
  use pretty_assertions::assert_eq;
  use sql_query_builder as sql;

  #[test]
  fn method_delete_should_add_the_delete_clause() {
    let query = sql::Delete::new().delete("users").as_string();
    let expected_query = "DELETE users";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_delete_should_accumulate_values_on_consecutive_calls() {
    let query = sql::Delete::new().delete("users").delete("employees").as_string();
    let expected_query = "DELETE users, employees";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_delete_should_not_accumulate_values_when_table_name_is_empty() {
    let query = sql::Delete::new().delete("").delete("users").delete("").as_string();
    let expected_query = "DELETE users";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_delete_should_trim_space_of_the_argument() {
    let query = sql::Delete::new().delete("  users  ").as_string();
    let expected_query = "DELETE users";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_delete_should_not_accumulate_arguments_with_the_same_content() {
    let query = sql::Delete::new().delete("employees").delete("employees").as_string();
    let expected_query = "DELETE employees";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_raw_before_should_add_raw_sql_before_delete_clause() {
    let query = sql::Delete::new()
      .raw_before(sql::DeleteClause::Delete, "/* uncommon parameter */")
      .delete("orders")
      .as_string();
    let expected_query = "/* uncommon parameter */ DELETE orders";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn method_raw_after_should_add_raw_sql_after_delete_clause() {
    let query = sql::Delete::new()
      .delete("LOW_PRIORITY")
      .raw_after(sql::DeleteClause::Delete, "FROM users")
      .as_string();
    let expected_query = "DELETE LOW_PRIORITY FROM users";

    assert_eq!(expected_query, query);
  }
}

#[cfg(feature = "mysql")]
mod relation_between_delete_and_from {
  use pretty_assertions::assert_eq;
  use sql_query_builder as sql;

  #[test]
  fn when_delete_from_method_was_called_with_delete_method_the_values_of_delete_method_should_be_preserved() {
    let query = sql::Delete::new().delete("quick").delete_from("users").as_string();
    let expected_query = "DELETE quick FROM users";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn when_delete_from_method_was_called_with_from_method_the_values_both_methods_should_be_preserved() {
    // the value of delete_from should be concatenated first
    let query = sql::Delete::new().from("t1").delete_from("t2").from("t3").as_string();
    let expected_query = "DELETE FROM t2, t1, t3";

    assert_eq!(expected_query, query);
  }

  #[test]
  fn when_delete_from_method_was_called_with_delete_and_from_method_the_values_of_all_methods_should_be_preserved() {
    // the value of delete_from should be concatenated first
    let query = sql::Delete::new()
      .delete("low_priority")
      .from("t1")
      .delete_from("t2")
      .from("t3")
      .as_string();
    let expected_query = "DELETE low_priority FROM t2, t1, t3";

    assert_eq!(expected_query, query);
  }
}