ipfs-sdk/auth_test.go at develop · LumeWeb/ipfs-sdk · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
package ipfs

import (
	"context"
	"net/http"
	"os"
	"reflect"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/golang-jwt/jwt/v5"
)

// getTestSecret returns a JWT signing secret from environment or falls back to test value
func getTestSecret() string {
	if secret := os.Getenv("JWT_TEST_SECRET"); secret != "" {
		return secret
	}
	return "test-jwt-signing-secret-for-testing"
}

// Test that Provider interface is implemented
func TestAuthProviderInterface(t *testing.T) {
	provider := NewJWTProvider("test-token")

	// Check that the type implements the interface
	providerType := reflect.TypeOf((*AuthProvider)(nil)).Elem()
	providerValue := reflect.ValueOf(provider).Interface()

	_ = providerType
	_ = providerValue
	// JWTProvider should implement AuthProvider interface
	assert.NotNil(t, provider)
}

func TestNewJWTProvider(t *testing.T) {
	provider := NewJWTProvider("test-token")

	assert.NotNil(t, provider)
	assert.Equal(t, "test-token", provider.Token())
}

func TestJWTProviderAddHeaders(t *testing.T) {
	provider := NewJWTProvider("test-token")

	req := &http.Request{}
	req.Header = make(http.Header)
	err := provider.AddHeaders(context.Background(), req)

	assert.NoError(t, err)
	assert.Equal(t, "Bearer test-token", req.Header.Get("Authorization"))
}

func TestJWTProviderAddHeadersNoToken(t *testing.T) {
	provider := NewJWTProvider("")

	req := &http.Request{}
	req.Header = make(http.Header)
	err := provider.AddHeaders(context.Background(), req)

	assert.NoError(t, err)
	assert.Equal(t, "", req.Header.Get("Authorization"))
}

func TestJWTProviderSetToken(t *testing.T) {
	provider := NewJWTProvider("initial-token")

	provider.SetToken("new-token")
	assert.Equal(t, "new-token", provider.Token())
}

func TestJWTProviderClaimsValidToken(t *testing.T) {
	// Create a test token with claims
	expTime := int64(253402300799) // Year 9999
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
		"sub":  "user123",
		"exp":  expTime,
	})
	signedToken, _ := token.SignedString([]byte(getTestSecret()))

	provider := NewJWTProvider(signedToken)

	claims, err := provider.Claims()

	assert.NoError(t, err)
	assert.Equal(t, "user123", claims["sub"])
}

func TestJWTProviderClaimsNoToken(t *testing.T) {
	provider := NewJWTProvider("")

	claims, err := provider.Claims()

	// When there's no token, both might be nil
	assert.Nil(t, claims)
	// err might be nil or an error, so don't assert on it
	_ = err
}

func TestJWTProviderValid(t *testing.T) {
	// Create a valid token
	expTime := int64(253402300799) // Year 9999
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
		"sub": "user123",
		"exp": expTime,
	})
	signedToken, _ := token.SignedString([]byte(getTestSecret()))

	provider := NewJWTProvider(signedToken)

	assert.True(t, provider.Valid())
}

func TestJWTProviderExpiredToken(t *testing.T) {
	// Create an expired token
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
		"sub": "user123",
		"exp": 1, // Unix timestamp of 1 (very old)
	})
	signedToken, _ := token.SignedString([]byte(getTestSecret()))

	provider := NewJWTProvider(signedToken)

	assert.False(t, provider.Valid())
}

func TestJWTProviderValidNoToken(t *testing.T) {
	provider := NewJWTProvider("")

	assert.False(t, provider.Valid())
}