refactor: extract domain model

3 files changed, 180 insertions, 4 deletions

diff --git a/src/bin/generate_migration.rs b/src/bin/generate_migration.rs
new file mode 100644
index 0000000..c72db66
--- /dev/null
+++ b/src/bin/generate_migration.rs
@@ -0,0 +1,22 @@
+use std::env;
+use sts::migration_discovery::{generate_migration_filename, generate_migration_timestamp};
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+
+    if args.len() < 2 {
+        eprintln!("Usage: cargo run --bin generate_migration <migration_name>");
+        eprintln!("Example: cargo run --bin generate_migration add_users_table");
+        return;
+    }
+
+    let migration_name = &args[1];
+    let filename = generate_migration_filename(migration_name);
+    let timestamp = generate_migration_timestamp();
+
+    println!("Generated migration filename: {}", filename);
+    println!("Timestamp: {}", timestamp);
+    println!("");
+    println!("To create the migration file:");
+    println!("touch migrations/{}", filename);
+}
diff --git a/src/bin/migrate.rs b/src/bin/migrate.rs
index 9a0bab9..fbf5183 100644
--- a/src/bin/migrate.rs
+++ b/src/bin/migrate.rs
@@ -13,7 +13,7 @@ fn main() -> Result<()> {
 
     let config = Config::from_env();
     let conn = Connection::open(&config.database_path)?;
-    let runner = MigrationRunner::new(&conn);
+    let runner = MigrationRunner::new(&conn)?;
 
     match args[1].as_str() {
         "up" => {
@@ -29,7 +29,7 @@ fn main() -> Result<()> {
                 eprintln!("Usage: cargo run --bin migrate rollback <version>");
                 return Ok(());
             }
-            let version: i32 = args[2]
+            let version: i64 = args[2]
                 .parse()
                 .map_err(|_| anyhow::anyhow!("Invalid version number: {}", args[2]))?;
             runner.rollback_to_version(version)?;
@@ -50,7 +50,7 @@ fn print_usage() {
     println!("Usage:");
     println!("  cargo run --bin migrate up       # Run pending migrations");
     println!("  cargo run --bin migrate status   # Show migration status");
-    println!("  cargo run --bin migrate rollback <version> # Rollback to version");
+    println!("  cargo run --bin migrate rollback <timestamp> # Rollback to timestamp");
     println!("");
     println!("Environment Variables:");
     println!("  DATABASE_PATH   Path to SQLite database (default: oauth.db)");
@@ -58,5 +58,5 @@ fn print_usage() {
     println!("Examples:");
     println!("  cargo run --bin migrate up");
     println!("  cargo run --bin migrate status");
-    println!("  cargo run --bin migrate rollback 0");
+    println!("  cargo run --bin migrate rollback 20231201120000");
 }
diff --git a/src/bin/test.rs b/src/bin/test.rs
new file mode 100644
index 0000000..d2704c4
--- /dev/null
+++ b/src/bin/test.rs
@@ -0,0 +1,154 @@
+use std::env;
+use std::process::{Command, exit};
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+
+    if args.len() < 2 {
+        print_usage();
+        return;
+    }
+
+    match args[1].as_str() {
+        "unit" => {
+            println!("Running unit tests...");
+            run_command(&["cargo", "test", "--lib"]);
+        }
+        "integration" => {
+            println!("Running integration tests...");
+            run_command_allow_failure(&["bundle", "exec", "rspec"]);
+        }
+        "all" => {
+            println!("Running all tests...");
+            println!("===================");
+            println!();
+
+            println!("1. Running Rust unit tests...");
+            run_command(&["cargo", "test"]);
+            println!();
+
+            println!("2. Running Ruby integration tests...");
+            run_command_allow_failure(&["bundle", "exec", "rspec"]);
+        }
+        "watch" => {
+            println!("Running tests in watch mode...");
+            if args.len() > 2 && args[2] == "integration" {
+                run_command(&["bundle", "exec", "guard"]);
+            } else {
+                run_command(&["cargo", "watch", "-x", "test"]);
+            }
+        }
+        "coverage" => {
+            println!("Running tests with coverage...");
+            run_command(&["cargo", "tarpaulin", "--out", "Html"]);
+        }
+        "check" => {
+            println!("Running cargo check...");
+            run_command(&["cargo", "check"]);
+        }
+        "lint" => {
+            println!("Running linting...");
+            run_command(&["cargo", "clippy", "--", "-D", "warnings"]);
+        }
+        "fmt" => {
+            println!("Running code formatting...");
+            run_command(&["cargo", "fmt"]);
+        }
+        "clean" => {
+            println!("Cleaning test artifacts...");
+            run_command(&["cargo", "clean"]);
+            run_command(&["rm", "-f", "oauth.db"]);
+            run_command(&["rm", "-f", "test.db"]);
+        }
+        "server" => {
+            println!("Starting test server...");
+            run_command(&["cargo", "run", "--bin", "sts"]);
+        }
+        "migrate" => {
+            println!("Running migrations for tests...");
+            run_command(&["cargo", "run", "--bin", "migrate", "up"]);
+        }
+        "reset" => {
+            println!("Resetting test environment...");
+            run_command(&["rm", "-f", "oauth.db"]);
+            run_command(&["cargo", "run", "--bin", "migrate", "up"]);
+        }
+        _ => {
+            eprintln!("Error: Unknown command '{}'", args[1]);
+            print_usage();
+            exit(1);
+        }
+    }
+}
+
+fn run_command(cmd: &[&str]) {
+    let mut command = Command::new(cmd[0]);
+    if cmd.len() > 1 {
+        command.args(&cmd[1..]);
+    }
+
+    let status = command.status().unwrap_or_else(|err| {
+        eprintln!("Failed to execute command '{:?}': {}", cmd, err);
+        exit(1);
+    });
+
+    if !status.success() {
+        eprintln!(
+            "Command '{:?}' failed with exit code: {:?}",
+            cmd,
+            status.code()
+        );
+        exit(1);
+    }
+}
+
+fn run_command_allow_failure(cmd: &[&str]) {
+    let mut command = Command::new(cmd[0]);
+    if cmd.len() > 1 {
+        command.args(&cmd[1..]);
+    }
+
+    let status = command.status().unwrap_or_else(|err| {
+        eprintln!("Failed to execute command '{:?}': {}", cmd, err);
+        exit(1);
+    });
+
+    if !status.success() {
+        eprintln!(
+            "Command '{:?}' completed with exit code: {:?}",
+            cmd,
+            status.code()
+        );
+        // Don't exit, just report the failure
+    }
+}
+
+fn print_usage() {
+    println!("OAuth2 STS Test Runner");
+    println!("=====================");
+    println!();
+    println!("Usage:");
+    println!("  cargo run --bin test <command>");
+    println!();
+    println!("Commands:");
+    println!("  unit         Run Rust unit tests only");
+    println!("  integration  Run Ruby integration tests only");
+    println!("  all          Run all tests (unit + integration)");
+    println!("  watch        Run tests in watch mode");
+    println!("  watch integration  Run integration tests in watch mode");
+    println!("  coverage     Run tests with coverage report");
+    println!("  check        Run cargo check");
+    println!("  lint         Run clippy linting");
+    println!("  fmt          Run code formatting");
+    println!("  clean        Clean test artifacts and databases");
+    println!("  server       Start test server");
+    println!("  migrate      Run database migrations");
+    println!("  reset        Reset test environment (clean DB + migrate)");
+    println!();
+    println!("Examples:");
+    println!("  cargo run --bin test unit");
+    println!("  cargo run --bin test all");
+    println!("  cargo run --bin test watch");
+    println!("  cargo run --bin test coverage");
+    println!("  cargo run --bin test reset");
+}