test(postgrest): add comprehensive unit tests

Add 19 unit tests covering:
- Default configuration values
- Image name and tag
- Port constant
- All builder methods (postgres_connection, db_schemas, db_anon_role,
  jwt_secret, jwt_role_claim_key, openapi_mode, max_rows, pre_request,
  log_level, tag, env)
- Builder method chaining
- Image trait methods (expose_ports, ready_conditions)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: j7nw4r

src/postgrest.rs

@@ -221,10 +221,7 @@ impl Default for PostgREST {
         env_vars.insert("PGRST_DB_ANON_ROLE".to_string(), "anon".to_string());
 
         // Server configuration
-        env_vars.insert(
-            "PGRST_SERVER_PORT".to_string(),
-            POSTGREST_PORT.to_string(),
-        );
+        env_vars.insert("PGRST_SERVER_PORT".to_string(), POSTGREST_PORT.to_string());
         env_vars.insert("PGRST_SERVER_HOST".to_string(), "0.0.0.0".to_string());
 
         Self {
@@ -270,12 +267,13 @@ impl Image for PostgREST {
 #[cfg(feature = "postgrest")]
 mod tests {
     use super::*;
+    use testcontainers_modules::testcontainers::Image;
 
     #[test]
-    fn test_postgrest_default() {
+    fn test_default_configuration() {
         let postgrest = PostgREST::default();
-        assert_eq!(postgrest.name(), NAME);
-        assert_eq!(postgrest.tag(), TAG);
+
+        // Verify essential env vars are set
         assert_eq!(
             postgrest.env_vars.get("PGRST_DB_SCHEMAS"),
             Some(&"public".to_string())
@@ -294,8 +292,184 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_name_returns_correct_image() {
+        let postgrest = PostgREST::default();
+        assert_eq!(postgrest.name(), "postgrest/postgrest");
+    }
+
+    #[test]
+    fn test_tag_returns_correct_version() {
+        let postgrest = PostgREST::default();
+        assert_eq!(postgrest.tag(), "v12.2.3");
+    }
+
     #[test]
     fn test_postgrest_port_constant() {
         assert_eq!(POSTGREST_PORT, 3000);
     }
+
+    #[test]
+    fn test_with_postgres_connection() {
+        let postgrest =
+            PostgREST::default().with_postgres_connection("postgres://user:pass@localhost:5432/db");
+        assert_eq!(
+            postgrest.env_vars.get("PGRST_DB_URI"),
+            Some(&"postgres://user:pass@localhost:5432/db".to_string())
+        );
+    }
+
+    #[test]
+    fn test_with_db_schemas() {
+        let postgrest = PostgREST::default().with_db_schemas("public,api,private");
+        assert_eq!(
+            postgrest.env_vars.get("PGRST_DB_SCHEMAS"),
+            Some(&"public,api,private".to_string())
+        );
+    }
+
+    #[test]
+    fn test_with_db_anon_role() {
+        let postgrest = PostgREST::default().with_db_anon_role("web_anon");
+        assert_eq!(
+            postgrest.env_vars.get("PGRST_DB_ANON_ROLE"),
+            Some(&"web_anon".to_string())
+        );
+    }
+
+    #[test]
+    fn test_with_jwt_secret() {
+        let postgrest = PostgREST::default().with_jwt_secret("my-super-secret-jwt-key");
+        assert_eq!(
+            postgrest.env_vars.get("PGRST_JWT_SECRET"),
+            Some(&"my-super-secret-jwt-key".to_string())
+        );
+    }
+
+    #[test]
+    fn test_with_jwt_role_claim_key() {
+        let postgrest = PostgREST::default().with_jwt_role_claim_key(".app_metadata.role");
+        assert_eq!(
+            postgrest.env_vars.get("PGRST_JWT_ROLE_CLAIM_KEY"),
+            Some(&".app_metadata.role".to_string())
+        );
+    }
+
+    #[test]
+    fn test_with_openapi_mode() {
+        let postgrest = PostgREST::default().with_openapi_mode("follow-privileges");
+        assert_eq!(
+            postgrest.env_vars.get("PGRST_OPENAPI_MODE"),
+            Some(&"follow-privileges".to_string())
+        );
+    }
+
+    #[test]
+    fn test_with_max_rows() {
+        let postgrest = PostgREST::default().with_max_rows(1000);
+        assert_eq!(
+            postgrest.env_vars.get("PGRST_DB_MAX_ROWS"),
+            Some(&"1000".to_string())
+        );
+    }
+
+    #[test]
+    fn test_with_pre_request() {
+        let postgrest = PostgREST::default().with_pre_request("auth.check_request");
+        assert_eq!(
+            postgrest.env_vars.get("PGRST_DB_PRE_REQUEST"),
+            Some(&"auth.check_request".to_string())
+        );
+    }
+
+    #[test]
+    fn test_with_log_level() {
+        let postgrest = PostgREST::default().with_log_level("warn");
+        assert_eq!(
+            postgrest.env_vars.get("PGRST_LOG_LEVEL"),
+            Some(&"warn".to_string())
+        );
+    }
+
+    #[test]
+    fn test_with_tag_overrides_default() {
+        let postgrest = PostgREST::default().with_tag("v11.0.0");
+        assert_eq!(postgrest.tag(), "v11.0.0");
+    }
+
+    #[test]
+    fn test_with_env_adds_custom_variable() {
+        let postgrest = PostgREST::default()
+            .with_env("CUSTOM_VAR", "custom_value")
+            .with_env("ANOTHER_VAR", "another_value");
+
+        assert_eq!(
+            postgrest.env_vars.get("CUSTOM_VAR"),
+            Some(&"custom_value".to_string())
+        );
+        assert_eq!(
+            postgrest.env_vars.get("ANOTHER_VAR"),
+            Some(&"another_value".to_string())
+        );
+    }
+
+    #[test]
+    fn test_builder_method_chaining() {
+        let postgrest = PostgREST::default()
+            .with_postgres_connection("postgres://user:pass@localhost:5432/db")
+            .with_db_schemas("api")
+            .with_db_anon_role("web_anon")
+            .with_jwt_secret("secret")
+            .with_max_rows(500)
+            .with_log_level("info")
+            .with_tag("v11.0.0");
+
+        assert_eq!(
+            postgrest.env_vars.get("PGRST_DB_URI"),
+            Some(&"postgres://user:pass@localhost:5432/db".to_string())
+        );
+        assert_eq!(
+            postgrest.env_vars.get("PGRST_DB_SCHEMAS"),
+            Some(&"api".to_string())
+        );
+        assert_eq!(
+            postgrest.env_vars.get("PGRST_DB_ANON_ROLE"),
+            Some(&"web_anon".to_string())
+        );
+        assert_eq!(
+            postgrest.env_vars.get("PGRST_JWT_SECRET"),
+            Some(&"secret".to_string())
+        );
+        assert_eq!(
+            postgrest.env_vars.get("PGRST_DB_MAX_ROWS"),
+            Some(&"500".to_string())
+        );
+        assert_eq!(
+            postgrest.env_vars.get("PGRST_LOG_LEVEL"),
+            Some(&"info".to_string())
+        );
+        assert_eq!(postgrest.tag(), "v11.0.0");
+    }
+
+    #[test]
+    fn test_new_creates_default_instance() {
+        let postgrest = PostgREST::new();
+        assert_eq!(postgrest.name(), NAME);
+        assert_eq!(postgrest.tag(), TAG);
+    }
+
+    #[test]
+    fn test_expose_ports() {
+        let postgrest = PostgREST::default();
+        let ports = postgrest.expose_ports();
+        assert_eq!(ports.len(), 1);
+        assert_eq!(ports[0], ContainerPort::Tcp(3000));
+    }
+
+    #[test]
+    fn test_ready_conditions() {
+        let postgrest = PostgREST::default();
+        let conditions = postgrest.ready_conditions();
+        assert_eq!(conditions.len(), 1);
+    }
 }