Feat: Validate from Export (#4)

Author: amenocal

README.md

@@ -79,9 +79,18 @@ For GitHub Enterprise Server:
 export GHMV_SOURCE_HOSTNAME="https://github.example.com"
 ```
 
-## Export Functionality
+## Export and Validation Workflow
 
-The tool also provides an export command to capture repository data at a specific point in time, which can be useful for creating snapshots before and after migrations.
+The tool provides both export and validation capabilities that work together to enable point-in-time migration validation:
+
+1. **Export**: Capture repository data at a specific point in time
+2. **Validate-from-Export**: Validate target repositories against exported snapshots
+
+This workflow is particularly useful when:
+
+- The source repository continues to receive changes during migration
+- You need to validate against the exact state when migration occurred
+- You want to create audit trails of migration validation
 
 ### Export Usage
 
@@ -140,6 +149,65 @@ When no output file is specified, exports are automatically saved to `.exports/`
 
 Example: `.exports/mona-actions_my-repo_export_20251002_144908.json`
 
+## Validate-from-Export
+
+The `validate-from-export` command allows you to validate a target repository against a previously exported snapshot of source repository data. This is essential for validating migrations when the source repository may have changed since the migration occurred.
+
+### Validate-from-Export Usage
+
+```bash
+gh migration-validator validate-from-export \
+  --export-file ".exports/mona-actions_my-repo_export_20251002_144908.json" \
+  --target-organization "target-org" \
+  --target-repo "my-repo" \
+  --target-token "ghp_yyy"
+```
+
+### Validate-from-Export Options
+
+- `--export-file` (required): Path to the exported JSON file containing source data
+- `--target-organization` (required): Target organization name
+- `--target-repo` (required): Target repository name
+- `--target-token` (required): GitHub token with read permissions for target
+- `--target-hostname` (optional): GitHub Enterprise Server URL for target
+- `--markdown-table` (optional): Output results in markdown format
+
+### Environment Variables for Validate-from-Export
+
+```bash
+export GHMV_TARGET_ORGANIZATION="target-org"
+export GHMV_TARGET_TOKEN="ghp_yyy"
+export GHMV_TARGET_REPO="my-repo"
+export GHMV_MARKDOWN_TABLE="true"
+
+gh migration-validator validate-from-export --export-file "path/to/export.json"
+```
+
+### Complete Export and Validation Workflow
+
+1. **Export source data before migration:**
+
+   ```bash
+   gh migration-validator export \
+     --source-organization "source-org" \
+     --source-repo "my-repo" \
+     --source-token "ghp_xxx"
+   ```
+
+2. **Perform your migration** (using GitHub's migration tools)
+
+3. **Validate against the export:**
+
+   ```bash
+   gh migration-validator validate-from-export \
+     --export-file ".exports/source-org_my-repo_export_20251002_144908.json" \
+     --target-organization "target-org" \
+     --target-repo "my-repo" \
+     --target-token "ghp_yyy"
+   ```
+
+This ensures you're validating against the exact state of the source repository when the migration occurred, regardless of any subsequent changes.
+
 ## What Gets Validated
 
 The tool compares the following metrics between source and target repositories:
@@ -185,4 +253,4 @@ Contributions are welcome! Please see [CONTRIBUTING.md](.github/contributing.md)
 
 ## License
 
-[MIT](./LICENSE) © [Mona-Actions](https://github.com/mona-actions)
+[MIT](./LICENSE) © [Mona-Actions](https://github.com/mona-actions)

cmd/validate_from_export.go

@@ -0,0 +1,140 @@
+/*
+Copyright © 2025 NAME HERE <EMAIL ADDRESS>
+*/
+package cmd
+
+import (
+	"fmt"
+	"mona-actions/gh-migration-validator/internal/export"
+	"mona-actions/gh-migration-validator/internal/validator"
+	"os"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// validateFromExportCmd represents the validate-from-export command
+var validateFromExportCmd = &cobra.Command{
+	Use:   "validate-from-export",
+	Short: "Validate target repository against exported source data",
+	Long: `Validate a target repository against previously exported source repository data.
+
+This command allows you to validate a migration by comparing the target repository 
+against a point-in-time snapshot of the source repository that was previously 
+exported using the 'export' command.
+
+This is useful for:
+- Validating migrations against an active repository that may have changed since migration
+- Comparing target repositories to source state at migration time
+- Ensuring migration integrity when source data may have changed
+
+The validation compares the same metrics as the standard validate command:
+- Issues count
+- Pull requests count (open, closed, merged)
+- Tags count  
+- Releases count
+- Commits count
+- Latest commit hash`,
+	Run: func(cmd *cobra.Command, args []string) {
+		// Get parameters from flags
+		exportFile := cmd.Flag("export-file").Value.String()
+		targetOrganization := cmd.Flag("target-organization").Value.String()
+		targetToken := cmd.Flag("target-token").Value.String()
+		targetHostname := cmd.Flag("target-hostname").Value.String()
+		targetRepo := cmd.Flag("target-repo").Value.String()
+		markdownTable, err := cmd.Flags().GetBool("markdown-table")
+		if err != nil {
+			fmt.Printf("Failed to parse 'markdown-table' flag: %v\n", err)
+			os.Exit(1)
+		}
+
+		// Only set ENV variables if flag values are provided (not empty)
+		if targetToken != "" {
+			os.Setenv("GHMV_TARGET_TOKEN", targetToken)
+		}
+		if targetHostname != "" {
+			os.Setenv("GHMV_TARGET_HOSTNAME", targetHostname)
+		}
+		if markdownTable {
+			os.Setenv("GHMV_MARKDOWN_TABLE", "true")
+		}
+
+		// Bind ENV variables in Viper (for optional parameters that can use env vars)
+		viper.BindEnv("TARGET_TOKEN")
+		viper.BindEnv("TARGET_HOSTNAME")
+		viper.BindEnv("TARGET_PRIVATE_KEY")
+		viper.BindEnv("TARGET_APP_ID")
+		viper.BindEnv("TARGET_INSTALLATION_ID")
+		viper.BindEnv("MARKDOWN_TABLE")
+
+		// Validate required parameters (using flag values directly for required flags)
+		if err := checkExportValidationVars(exportFile); err != nil {
+			fmt.Printf("Export validation configuration failed: %v\n", err)
+			os.Exit(1)
+		}
+
+		// Load export data from file
+		exportData, err := export.LoadExportData(exportFile)
+		if err != nil {
+			fmt.Printf("Failed to load export file: %v\n", err)
+			os.Exit(1)
+		}
+
+		// Initialize API for target
+		initializeAPI()
+
+		// Create validator and perform validation
+		migrationValidator := validator.New(ghAPI)
+
+		// Set source data from export instead of fetching from API
+		migrationValidator.SetSourceDataFromExport(&exportData.Repository)
+
+		// Perform validation against target (now returns results directly)
+		results, err := migrationValidator.ValidateFromExport(targetOrganization, targetRepo)
+		if err != nil {
+			fmt.Printf("Validation failed: %v\n", err)
+			os.Exit(1)
+		}
+
+		// Display results using existing method
+		migrationValidator.PrintValidationResults(results)
+	},
+}
+
+func init() {
+	// Add validate-from-export command to root
+	rootCmd.AddCommand(validateFromExportCmd)
+
+	// Define flags specific to validate-from-export command
+	validateFromExportCmd.Flags().StringP("export-file", "e", "", "Path to the exported JSON file to use as source data")
+	validateFromExportCmd.MarkFlagRequired("export-file")
+
+	validateFromExportCmd.Flags().StringP("target-organization", "t", "", "Target Organization to validate against")
+	validateFromExportCmd.MarkFlagRequired("target-organization")
+
+	validateFromExportCmd.Flags().StringP("target-token", "b", "", "Target Organization GitHub token. Scopes: read:org, read:user, user:email")
+
+	validateFromExportCmd.Flags().StringP("target-hostname", "v", "", "GitHub Enterprise target hostname url (optional) Ex. https://github.example.com")
+
+	validateFromExportCmd.Flags().String("target-repo", "", "Target repository name to validate (just the repo name, not owner/repo)")
+	validateFromExportCmd.MarkFlagRequired("target-repo")
+
+	validateFromExportCmd.Flags().BoolP("markdown-table", "m", false, "Output results in markdown table format")
+}
+
+// checkExportValidationVars validates the configuration for validate-from-export command
+func checkExportValidationVars(exportFile string) error {
+
+	// Check if export file exists
+	if _, err := os.Stat(exportFile); os.IsNotExist(err) {
+		return fmt.Errorf("export file does not exist: %s", exportFile)
+	}
+
+	// Check for target token (can come from flag or environment variable)
+	targetToken := viper.GetString("TARGET_TOKEN")
+	if targetToken == "" {
+		return fmt.Errorf("target token is required. Set it via --target-token flag or GHMV_TARGET_TOKEN environment variable")
+	}
+
+	return nil
+}

internal/export/export.go

@@ -162,3 +162,50 @@ func exportToCSV(data ExportData, filename string) error {
 
 	return nil
 }
+
+// LoadExportData loads and validates export data from a JSON file
+func LoadExportData(filename string) (*ExportData, error) {
+	// Check if file exists
+	if _, err := os.Stat(filename); os.IsNotExist(err) {
+		return nil, fmt.Errorf("export file does not exist: %s", filename)
+	}
+
+	// Read file content
+	content, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read export file: %w", err)
+	}
+
+	// Parse JSON
+	var exportData ExportData
+	if err := json.Unmarshal(content, &exportData); err != nil {
+		return nil, fmt.Errorf("failed to parse export JSON: %w", err)
+	}
+
+	// Validate required fields
+	if err := validateExportData(&exportData); err != nil {
+		return nil, fmt.Errorf("invalid export data: %w", err)
+	}
+
+	return &exportData, nil
+}
+
+// validateExportData ensures the export data has all required fields
+func validateExportData(data *ExportData) error {
+	if data.ExportTimestamp.IsZero() {
+		return fmt.Errorf("export timestamp is missing or invalid")
+	}
+
+	if data.Repository.Owner == "" {
+		return fmt.Errorf("repository owner is missing")
+	}
+
+	if data.Repository.Name == "" {
+		return fmt.Errorf("repository name is missing")
+	}
+
+	// Note: We don't validate PRs for nil here since we handle that gracefully in the export functions
+	// This allows for flexibility in case the export format evolves
+
+	return nil
+}

internal/export/export_test.go

@@ -71,19 +71,7 @@ func TestExportToJSON(t *testing.T) {
 	filename := filepath.Join(tmpDir, "test.json")
 
 	// Create test data
-	exportData := ExportData{
-		ExportTimestamp: time.Date(2025, 10, 2, 14, 30, 0, 0, time.UTC),
-		Repository: validator.RepositoryData{
-			Owner:           "test-owner",
-			Name:            "test-repo",
-			Issues:          10,
-			PRs:             &api.PRCounts{Open: 1, Closed: 2, Merged: 3, Total: 6},
-			Tags:            5,
-			Releases:        2,
-			CommitCount:     100,
-			LatestCommitSHA: "abcd1234",
-		},
-	}
+	exportData := createTestExportData()
 
 	// Test the function
 	err := exportToJSON(exportData, filename)
@@ -106,6 +94,12 @@ func TestExportToJSON(t *testing.T) {
 	if parsed.Repository.Owner != exportData.Repository.Owner {
 		t.Errorf("Expected owner %s, got %s", exportData.Repository.Owner, parsed.Repository.Owner)
 	}
+	if parsed.Repository.Name != exportData.Repository.Name {
+		t.Errorf("Expected name %s, got %s", exportData.Repository.Name, parsed.Repository.Name)
+	}
+	if parsed.Repository.Issues != exportData.Repository.Issues {
+		t.Errorf("Expected %d issues, got %d", exportData.Repository.Issues, parsed.Repository.Issues)
+	}
 }
 
 func TestExportToCSV(t *testing.T) {
@@ -114,19 +108,7 @@ func TestExportToCSV(t *testing.T) {
 	filename := filepath.Join(tmpDir, "test.csv")
 
 	// Create test data
-	exportData := ExportData{
-		ExportTimestamp: time.Date(2025, 10, 2, 14, 30, 0, 0, time.UTC),
-		Repository: validator.RepositoryData{
-			Owner:           "test-owner",
-			Name:            "test-repo",
-			Issues:          10,
-			PRs:             &api.PRCounts{Open: 1, Closed: 2, Merged: 3, Total: 6},
-			Tags:            5,
-			Releases:        2,
-			CommitCount:     100,
-			LatestCommitSHA: "abcd1234",
-		},
-	}
+	exportData := createTestExportData()
 
 	// Test the function
 	err := exportToCSV(exportData, filename)
@@ -160,8 +142,8 @@ func TestExportToCSV(t *testing.T) {
 	if dataRow[2] != "test-repo" {
 		t.Errorf("Expected repo test-repo, got %s", dataRow[2])
 	}
-	if dataRow[3] != "10" {
-		t.Errorf("Expected 10 issues, got %s", dataRow[3])
+	if dataRow[3] != "42" {
+		t.Errorf("Expected 42 issues, got %s", dataRow[3])
 	}
 }