Cloudstack MCP

🚀 Diff Package

The diff package offers tools for generating, comparing, and visualizing differences between expected and actual values. Designed for testing scenarios, it can also be used in any context requiring difference visualization.

✨ Features

• Utilize go-cmp for generic type comparison.
• Support string comparison based on the unified diff format.
• Provide detailed character-level text comparison.
• Offer rich color and whitespace visualization output.
• Handle various Go types, including structs, maps, and basic types.
• Implement complex type comparison through reflection.

🔧 Technical Details

The package is organized into the following modules:

1. Core Diff Logic (diff.go): Main interfaces and specific type difference generation.
2. Unified Diff (udiff.go): Implementation of unified diff parsing and formatting.
3. Output Enhancement (enrich.go): Enhance the color and format of difference output.
4. Type and Value Formatting (convoluted.go): Responsible for the formatted comparison of Go types and values.
5. Testing Tools (testing.go): Implement functions suitable for testing scenarios.

💻 Usage Examples

Basic Usage

package main

import (
    "fmt"
    "github.com/walteh/cloudstack-mcp/pkg/diff"
)

func main() {
    expected := "Hello, World!"
    actual := "Hello, Universe!"

    // Generate the difference between two strings
    result := diff.TypedDiff(expected, actual)

    // Print the difference result
    fmt.Println(result)
}

Advanced Usage

Usage in Testing

package mypackage_test

import (
    "testing"
    "github.com/walteh/cloudstack-mcp/pkg/diff"
)

func TestSomething(t *testing.T) {
    expected := map[string]int{"a": 1, "b": 2}
    actual := map[string]int{"a": 1, "b": 3}

    // Compare values and fail the test if they don't match
    diff.RequireEqual(t, expected, actual)
}

Comparison of Complex Types

package mypackage_test

import (
    "reflect"
    "testing"
    "github.com/walteh/cloudstack-mcp/pkg/diff"
)

type MyStruct struct {
    Name string
    Age  int
    private string
}

func TestStructComparison(t *testing.T) {
    s1 := MyStruct{Name: "Alice", Age: 30, private: "secret"}
    s2 := MyStruct{Name: "Alice", Age: 31, private: "secret"}

    // Compare structs containing unexported fields
    diff.RequireEqual(t, s1, s2, diff.WithUnexportedType[MyStruct]())
}

Character-Level Difference Comparison

package main

import (
    "fmt"
    "github.com/walteh/cloudstack-mcp/pkg/diff"
)

func main() {
    str1 := "Hello"
    str2 := "World"

    // Compare the character differences between two strings
    diff.Show(str1, str2)
}

📚 Documentation

Extension Points

The package allows users to customize behavior by implementing the following interfaces or adding options:

• Implement the diff.Comparator interface to customize comparison logic.
• Use the diff.WithOptions method to configure specific difference generation parameters.

Best Practices

1. Choose the appropriate comparison method:
   • Use TypedDiff for simple values.
   • Use RequireEqual for complex structs and combine options to handle unexported fields.
2. When dealing with unexported fields:

   // Explicitly compare private fields using the WithUnexportedType option
   diff.RequireEqual(t, a, b, diff.WithUnexportedType[type](...))
   

3. When customizing comparison logic:

   type MyComparator struct{}
   
   func (MyComparator) Compare(a, b interface{}) string {
       // Custom comparison implementation
   }
   
   // Register a custom comparator
   diff.Register(diff.KeyType(reflect.TypeOf(a)), &MyComparator{})
   

Compatibility with Older Versions

Although new methods are recommended, the package still supports the following old functions for backward compatibility:

• diff.Show()
• diff.DiffString()

These old functions are gradually being deprecated. It is recommended to use the latest interfaces in new projects.