azimuth-client-go/client_test.go

package azimuth

import (
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
)

func TestNewClient(t *testing.T) {
	tests := []struct {
		name     string
		endpoint string
		expected string
	}{
		{
			name:     "default endpoint",
			endpoint: "",
			expected: DefaultEndpoint,
		},
		{
			name:     "custom endpoint",
			endpoint: "https://custom.endpoint.com/graphql",
			expected: "https://custom.endpoint.com/graphql",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			client := NewClient(tt.endpoint)
			assert.NotNil(t, client)
			assert.NotNil(t, client.gqlClient)
			assert.NotNil(t, client.cache)
			assert.Equal(t, AzimuthContract, client.contractAddress)
		})
	}
}

func TestNewClientWithOptions(t *testing.T) {
	opts := ClientOptions{
		Endpoint:        "https://test.endpoint.com",
		CacheTTL:        2 * time.Hour,
		ContractAddress: "0x1234567890123456789012345678901234567890",
		Timeout:         60 * time.Second,
	}

	client := NewClientWithOptions(opts)
	assert.NotNil(t, client)
	assert.Equal(t, opts.ContractAddress, client.contractAddress)
	assert.Equal(t, opts.CacheTTL, client.cache.ttl)
}

func TestGetShipType(t *testing.T) {
	tests := []struct {
		name     string
		point    uint32
		expected string
	}{
		{
			name:     "galaxy",
			point:    0,
			expected: "galaxy",
		},
		{
			name:     "galaxy max",
			point:    255,
			expected: "galaxy",
		},
		{
			name:     "star min",
			point:    256,
			expected: "star",
		},
		{
			name:     "star max",
			point:    65535,
			expected: "star",
		},
		{
			name:     "planet",
			point:    65536,
			expected: "planet",
		},
		{
			name:     "large planet",
			point:    1000000,
			expected: "planet",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := GetShipType(tt.point)
			assert.Equal(t, tt.expected, result)
		})
	}
}

func TestParseShipName(t *testing.T) {
	tests := []struct {
		name      string
		shipName  string
		expected  uint32
		expectErr bool
	}{
		{
			name:     "numeric without tilde",
			shipName: "256",
			expected: 256,
		},
		{
			name:     "numeric with tilde",
			shipName: "~256",
			expected: 256,
		},
		{
			name:      "invalid patp",
			shipName:  "~invalid-patp",
			expectErr: true,
		},
		{
			name:      "non-numeric",
			shipName:  "not-a-number",
			expectErr: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result, err := ParseShipName(tt.shipName)
			if tt.expectErr {
				assert.Error(t, err)
			} else {
				assert.NoError(t, err)
				assert.Equal(t, tt.expected, result)
			}
		})
	}
}

func TestParseStarID(t *testing.T) {
	tests := []struct {
		name      string
		starID    string
		expected  uint32
		expectErr bool
	}{
		{
			name:     "valid star min",
			starID:   "256",
			expected: 256,
		},
		{
			name:     "valid star max",
			starID:   "65535",
			expected: 65535,
		},
		{
			name:      "galaxy (too small)",
			starID:    "255",
			expectErr: true,
		},
		{
			name:      "planet (too large)",
			starID:    "65536",
			expectErr: true,
		},
		{
			name:      "invalid format",
			starID:    "not-a-number",
			expectErr: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result, err := ParseStarID(tt.starID)
			if tt.expectErr {
				assert.Error(t, err)
			} else {
				assert.NoError(t, err)
				assert.Equal(t, tt.expected, result)
			}
		})
	}
}

func TestKeyCache(t *testing.T) {
	cache := NewKeyCache(100 * time.Millisecond)
	
	// Test cache miss
	keys, found := cache.Get(256)
	assert.False(t, found)
	assert.Nil(t, keys)
	
	// Test cache set and hit
	testKeys := &ShipKeys{
		AuthenticationKey:  []byte("test-auth-key"),
		EncryptionKey:      []byte("test-enc-key"),
		CryptoSuiteVersion: 1,
		KeyRevisionNumber:  1,
	}
	cache.Set(256, testKeys)
	
	keys, found = cache.Get(256)
	assert.True(t, found)
	assert.Equal(t, testKeys.AuthenticationKey, keys.AuthenticationKey)
	assert.Equal(t, testKeys.EncryptionKey, keys.EncryptionKey)
	
	// Test cache expiry
	time.Sleep(150 * time.Millisecond)
	keys, found = cache.Get(256)
	assert.False(t, found)
	assert.Nil(t, keys)
}

// Note: The following tests would require a mock GraphQL server or integration test setup
// For now, they serve as documentation of the expected API behavior

func TestClient_GetAuthenticationKey_Integration(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping integration test")
	}
	
	// Test with a known active ship (this would need a real endpoint)
	// client := NewClient("")
	// ctx := context.Background()
	// authKey, err := client.GetAuthenticationKey(ctx, 0) // ~zod
	// assert.NoError(t, err)
	// assert.Len(t, authKey, 32) // 32 bytes for secp256k1 key
	
	t.Skip("Integration test requires live azimuth-watcher endpoint")
}

func TestClient_IsShipActive_Integration(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping integration test")
	}
	
	// Test with a known ship
	// client := NewClient("")
	// ctx := context.Background()
	// active, err := client.IsShipActive(ctx, 0) // ~zod
	// assert.NoError(t, err)
	// assert.True(t, active) // ~zod should be active
	
	t.Skip("Integration test requires live azimuth-watcher endpoint")
}

func TestValidateStarSponsorship_Integration(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping integration test")
	}
	
	// Test with known star-galaxy relationship
	// client := NewClient("")
	// ctx := context.Background()
	// err := ValidateStarSponsorship(ctx, 256, 0, client) // ~marzod sponsored by ~zod
	// assert.NoError(t, err)
	
	// Test with invalid sponsorship
	// err = ValidateStarSponsorship(ctx, 256, 1, client) // ~marzod NOT sponsored by ~nec
	// assert.Error(t, err)
	
	t.Skip("Integration test requires live azimuth-watcher endpoint")
}