Merge pull request #2 from continuedev/nate/fix-tests

Nate/fix tests

Author: sestinj

.github/workflows/test.yml

@@ -20,6 +20,10 @@ jobs:
           go-version: "1.24.2"
           check-latest: true
 
+      # Run this first to fail fast if tests fail
+      - name: Run Go tests
+        run: go test ./... -v
+
       - name: Setup Node.js
         uses: actions/setup-node@v3
         with:
@@ -29,9 +33,6 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
-      - name: Run Go tests
-        run: go test ./...
-
       - name: Build binaries
         run: node build.js
 

.gitignore

@@ -4,6 +4,7 @@ rules-cli
 .rules
 /rules
 test-rule.yaml
+e.sh
 
 .github/instructions
 .sourcegraph

cmd/root_test.go

@@ -0,0 +1,114 @@
+package cmd
+
+import (
+	"bytes"
+	"os"
+	"strings"
+	"testing"
+	
+	"github.com/spf13/cobra"
+)
+
+func TestRootCommand(t *testing.T) {
+	// Test that the root command executes without error
+	old := os.Args
+	defer func() { os.Args = old }()
+	
+	// Test help command
+	os.Args = []string{"rules", "--help"}
+	
+	// Capture output
+	var buf bytes.Buffer
+	rootCmd.SetOut(&buf)
+	rootCmd.SetErr(&buf)
+	
+	err := rootCmd.Execute()
+	if err != nil {
+		t.Fatalf("Root command with --help failed: %v", err)
+	}
+	
+	output := buf.String()
+	if !strings.Contains(output, "command-line tool to create, manage, and convert rule sets") {
+		t.Error("Help output should contain description")
+	}
+}
+
+func TestVersionFlag(t *testing.T) {
+	// Set version for testing
+	originalVersion := Version
+	Version = "test-version"
+	defer func() { Version = originalVersion }()
+	
+	// Test by directly setting the version flag and checking behavior
+	oldVersion := version
+	version = true
+	defer func() { version = oldVersion }()
+	
+	// Test that when version flag is true, the command behaves correctly
+	if !version {
+		t.Error("Version flag should be set to true for testing")
+	}
+	
+	// Test that Version variable is set correctly
+	if Version != "test-version" {
+		t.Errorf("Version should be 'test-version', got '%s'", Version)
+	}
+}
+
+func TestVersionFlagBehavior(t *testing.T) {
+	// Test version flag behavior by parsing command line
+	originalVersion := Version
+	Version = "test-version-behavior"
+	defer func() { Version = originalVersion }()
+	
+	// Create a new command instance to avoid state issues
+	testCmd := &cobra.Command{
+		Use: "rules",
+		Run: func(cmd *cobra.Command, args []string) {
+			if version {
+				// This mimics the actual behavior in root.go
+				return
+			}
+		},
+	}
+	
+	testCmd.Flags().BoolVarP(&version, "version", "v", false, "Display version information")
+	
+	// Test parsing the version flag
+	err := testCmd.ParseFlags([]string{"-v"})
+	if err != nil {
+		t.Fatalf("Failed to parse version flag: %v", err)
+	}
+	
+	// The version variable should now be true
+	if !version {
+		t.Error("Version flag should be true after parsing -v")
+	}
+}
+
+func TestRootCommandUsage(t *testing.T) {
+	// Test that the root command has the correct usage string
+	if rootCmd.Use != "rules" {
+		t.Errorf("Expected Use to be 'rules', got %s", rootCmd.Use)
+	}
+	
+	if rootCmd.Short == "" {
+		t.Error("Short description should not be empty")
+	}
+	
+	if rootCmd.Long == "" {
+		t.Error("Long description should not be empty")
+	}
+}
+
+func TestInitializeCommand(t *testing.T) {
+	// Test that the command initializes without panicking
+	defer func() {
+		if r := recover(); r != nil {
+			t.Errorf("Command initialization panicked: %v", r)
+		}
+	}()
+	
+	// This should not panic
+	_ = rootCmd
+}

internal/auth/workos.go

@@ -125,7 +125,7 @@ func GetAuthUrlForTokenPage() string {
 	params.Add("response_type", "code")
 	params.Add("client_id", viper.GetString("workos_client_id"))
 
-	redirectPath := "tokens/callback?clientName=rules"
+	redirectPath := "tokens/callback/rules"
 	params.Add("redirect_uri", fmt.Sprintf("%s%s", viper.GetString("app_url"), redirectPath))
 
 	params.Add("state", uuid.New().String())

internal/config/config_test.go

@@ -0,0 +1,88 @@
+package config
+
+import (
+	"os"
+	"testing"
+)
+
+func TestInitialize(t *testing.T) {
+	// Test basic initialization
+	cfg, err := Initialize()
+	if err != nil {
+		t.Fatalf("Initialize() failed: %v", err)
+	}
+
+	if cfg == nil {
+		t.Fatal("Initialize() returned nil config")
+	}
+
+	// Test default values
+	if cfg.RegistryURL == "" {
+		t.Error("RegistryURL should not be empty")
+	}
+	
+	if cfg.DefaultFormat == "" {
+		t.Error("DefaultFormat should not be empty")
+	}
+
+	// Test that default values are set correctly
+	expectedRegistryURL := "https://api.continue.dev"
+	if cfg.RegistryURL != expectedRegistryURL {
+		t.Errorf("Expected RegistryURL to be %s, got %s", expectedRegistryURL, cfg.RegistryURL)
+	}
+
+	expectedDefaultFormat := "default"
+	if cfg.DefaultFormat != expectedDefaultFormat {
+		t.Errorf("Expected DefaultFormat to be %s, got %s", expectedDefaultFormat, cfg.DefaultFormat)
+	}
+}
+
+func TestLoadConfig(t *testing.T) {
+	// Test LoadConfig function
+	cfg, err := LoadConfig()
+	if err != nil {
+		t.Fatalf("LoadConfig() failed: %v", err)
+	}
+
+	if cfg == nil {
+		t.Fatal("LoadConfig() returned nil config")
+	}
+}
+
+func TestInitializeWithEnvironmentVariables(t *testing.T) {
+	// Set environment variables
+	os.Setenv("RULES_REGISTRY_URL", "https://test.example.com")
+	os.Setenv("RULES_DEFAULT_FORMAT", "test-format")
+	os.Setenv("RULES_USERNAME", "testuser")
+	os.Setenv("RULES_EMAIL", "test@example.com")
+
+	defer func() {
+		// Clean up environment variables
+		os.Unsetenv("RULES_REGISTRY_URL")
+		os.Unsetenv("RULES_DEFAULT_FORMAT")
+		os.Unsetenv("RULES_USERNAME")
+		os.Unsetenv("RULES_EMAIL")
+	}()
+
+	cfg, err := Initialize()
+	if err != nil {
+		t.Fatalf("Initialize() with env vars failed: %v", err)
+	}
+
+	// Test that environment variables override defaults
+	if cfg.RegistryURL != "https://test.example.com" {
+		t.Errorf("Expected RegistryURL to be overridden by env var, got %s", cfg.RegistryURL)
+	}
+
+	if cfg.DefaultFormat != "test-format" {
+		t.Errorf("Expected DefaultFormat to be overridden by env var, got %s", cfg.DefaultFormat)
+	}
+
+	if cfg.Username != "testuser" {
+		t.Errorf("Expected Username to be set by env var, got %s", cfg.Username)
+	}
+
+	if cfg.Email != "test@example.com" {
+		t.Errorf("Expected Email to be set by env var, got %s", cfg.Email)
+	}
+}

main_test.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"testing"
+	
+	"rules-cli/cmd"
+)
+
+func TestVersionSetting(t *testing.T) {
+	// Test that the version is passed to the cmd package
+	originalVersion := Version
+	originalCmdVersion := cmd.Version
+	
+	defer func() {
+		Version = originalVersion
+		cmd.Version = originalCmdVersion
+	}()
+	
+	Version = "test-main-version"
+	cmd.Version = Version
+	
+	if cmd.Version != "test-main-version" {
+		t.Errorf("Expected cmd.Version to be 'test-main-version', got %s", cmd.Version)
+	}
+}
+
+func TestMainFunction(t *testing.T) {
+	// Test that main function exists and doesn't panic when version is set
+	defer func() {
+		if r := recover(); r != nil {
+			t.Errorf("main() related functions panicked: %v", r)
+		}
+	}()
+	
+	// Test that Version variable exists and can be set
+	originalVersion := Version
+	Version = "test"
+	if Version != "test" {
+		t.Error("Version variable should be settable")
+	}
+	Version = originalVersion
+}

tests/golden/login/login.golden

@@ -1,7 +1,7 @@
 Starting login process...
 
 Starting authentication with Continue...
-Opening browser to sign in at: https://api.workos.com/user_management/authorize?client_id=client_01J0FW6XN8N2XJAECF7NE0Y65J&provider=authkit&redirect_uri=https%3A%2F%2Fhub.continue.dev%2Ftokens%2Fcallback&response_type=code&state=<STATE_PLACEHOLDER>
+Opening browser to sign in at: https://api.workos.com/user_management/authorize?client_id=client_01J0FW6XN8N2XJAECF7NE0Y65J&provider=authkit&redirect_uri=https%3A%2F%2Fhub.continue.dev%2Ftokens%2Fcallback%2Frules&response_type=code&state=<STATE_PLACEHOLDER>
 
 After signing in, you'll receive a token.
 Paste your sign-in token here: Login failed: <ERROR_PLACEHOLDER>

tests/golden/v/version.golden

@@ -1 +1 @@
-rules version dev
+rules version <VERSION_PLACEHOLDER>