1package remote
2
3import (
4 "testing"
5
6 "github.com/stretchr/testify/assert"
7 "github.com/stretchr/testify/require"
8)
9
10func TestResolve_FlagNameLookup(t *testing.T) {
11 t.Setenv("XDG_CONFIG_HOME", t.TempDir())
12 t.Setenv("GORDON_REMOTE", "")
13 t.Setenv("GORDON_TOKEN", "")
14 t.Setenv("GORDON_INSECURE", "")
15
16 config := &ClientConfig{
17 Remotes: map[string]RemoteEntry{
18 "prod": {URL: "https://gordon.example.com", Token: "tok123"},
19 },
20 }
21 require.NoError(t, SaveRemotes("", config))
22
23 resolved, ok := Resolve("prod", "", false)
24 require.True(t, ok)
25 assert.Equal(t, "prod", resolved.Name)
26 assert.Equal(t, "https://gordon.example.com", resolved.URL)
27 assert.Equal(t, "tok123", resolved.Token)
28 assert.False(t, resolved.InsecureTLS)
29}
30
31func TestResolve_FlagURLPassthrough(t *testing.T) {
32 t.Setenv("XDG_CONFIG_HOME", t.TempDir())
33 t.Setenv("GORDON_REMOTE", "")
34 t.Setenv("GORDON_TOKEN", "")
35
36 resolved, ok := Resolve("https://one-off.example.com", "mytoken", false)
37 require.True(t, ok)
38 assert.Equal(t, "", resolved.Name)
39 assert.Equal(t, "https://one-off.example.com", resolved.URL)
40 assert.Equal(t, "mytoken", resolved.Token)
41}
42
43func TestResolve_ActiveRemoteFallback(t *testing.T) {
44 t.Setenv("XDG_CONFIG_HOME", t.TempDir())
45 t.Setenv("GORDON_REMOTE", "")
46 t.Setenv("GORDON_TOKEN", "")
47
48 config := &ClientConfig{
49 Active: "staging",
50 Remotes: map[string]RemoteEntry{
51 "staging": {URL: "https://staging.example.com", Token: "stok"},
52 },
53 }
54 require.NoError(t, SaveRemotes("", config))
55
56 resolved, ok := Resolve("", "", false)
57 require.True(t, ok)
58 assert.Equal(t, "staging", resolved.Name)
59 assert.Equal(t, "https://staging.example.com", resolved.URL)
60 assert.Equal(t, "stok", resolved.Token)
61}
62
63func TestResolve_NoRemote_LocalMode(t *testing.T) {
64 t.Setenv("XDG_CONFIG_HOME", t.TempDir())
65 t.Setenv("GORDON_REMOTE", "")
66 t.Setenv("GORDON_TOKEN", "")
67
68 resolved, ok := Resolve("", "", false)
69 assert.False(t, ok)
70 assert.Nil(t, resolved)
71}
72
73func TestResolve_EnvRemoteName(t *testing.T) {
74 t.Setenv("XDG_CONFIG_HOME", t.TempDir())
75 t.Setenv("GORDON_REMOTE", "prod")
76 t.Setenv("GORDON_TOKEN", "")
77
78 config := &ClientConfig{
79 Remotes: map[string]RemoteEntry{
80 "prod": {URL: "https://gordon.example.com", Token: "tok"},
81 },
82 }
83 require.NoError(t, SaveRemotes("", config))
84
85 resolved, ok := Resolve("", "", false)
86 require.True(t, ok)
87 assert.Equal(t, "prod", resolved.Name)
88 assert.Equal(t, "https://gordon.example.com", resolved.URL)
89}
90
91func TestResolve_EnvRemoteURL(t *testing.T) {
92 t.Setenv("XDG_CONFIG_HOME", t.TempDir())
93 t.Setenv("GORDON_REMOTE", "https://env.example.com")
94 t.Setenv("GORDON_TOKEN", "envtok")
95
96 resolved, ok := Resolve("", "", false)
97 require.True(t, ok)
98 assert.Equal(t, "", resolved.Name)
99 assert.Equal(t, "https://env.example.com", resolved.URL)
100 assert.Equal(t, "envtok", resolved.Token)
101}
102
103func TestResolve_FlagTokenOverridesStored(t *testing.T) {
104 t.Setenv("XDG_CONFIG_HOME", t.TempDir())
105 t.Setenv("GORDON_REMOTE", "")
106 t.Setenv("GORDON_TOKEN", "")
107
108 config := &ClientConfig{
109 Active: "prod",
110 Remotes: map[string]RemoteEntry{
111 "prod": {URL: "https://gordon.example.com", Token: "stored"},
112 },
113 }
114 require.NoError(t, SaveRemotes("", config))
115
116 resolved, ok := Resolve("", "override", false)
117 require.True(t, ok)
118 assert.Equal(t, "override", resolved.Token)
119}
120
121func TestResolve_EnvTokenOverridesStored(t *testing.T) {
122 t.Setenv("XDG_CONFIG_HOME", t.TempDir())
123 t.Setenv("GORDON_REMOTE", "")
124 t.Setenv("GORDON_TOKEN", "envtoken")
125
126 config := &ClientConfig{
127 Active: "prod",
128 Remotes: map[string]RemoteEntry{
129 "prod": {URL: "https://gordon.example.com", Token: "stored"},
130 },
131 }
132 require.NoError(t, SaveRemotes("", config))
133
134 resolved, ok := Resolve("", "", false)
135 require.True(t, ok)
136 assert.Equal(t, "envtoken", resolved.Token)
137}
138
139func TestResolve_InsecureTLSFlag(t *testing.T) {
140 t.Setenv("XDG_CONFIG_HOME", t.TempDir())
141 t.Setenv("GORDON_REMOTE", "")
142 t.Setenv("GORDON_TOKEN", "")
143 t.Setenv("GORDON_INSECURE", "")
144
145 config := &ClientConfig{
146 Active: "prod",
147 Remotes: map[string]RemoteEntry{
148 "prod": {URL: "https://gordon.example.com"},
149 },
150 }
151 require.NoError(t, SaveRemotes("", config))
152
153 resolved, ok := Resolve("", "", true)
154 require.True(t, ok)
155 assert.True(t, resolved.InsecureTLS)
156}
157
158func TestResolve_InsecureTLSFromEntry(t *testing.T) {
159 t.Setenv("XDG_CONFIG_HOME", t.TempDir())
160 t.Setenv("GORDON_REMOTE", "")
161 t.Setenv("GORDON_TOKEN", "")
162 t.Setenv("GORDON_INSECURE", "")
163
164 config := &ClientConfig{
165 Active: "prod",
166 Remotes: map[string]RemoteEntry{
167 "prod": {URL: "https://gordon.example.com", InsecureTLS: true},
168 },
169 }
170 require.NoError(t, SaveRemotes("", config))
171
172 resolved, ok := Resolve("", "", false)
173 require.True(t, ok)
174 assert.True(t, resolved.InsecureTLS)
175}
176
177func TestResolve_TokenEnvVar(t *testing.T) {
178 t.Setenv("XDG_CONFIG_HOME", t.TempDir())
179 t.Setenv("GORDON_REMOTE", "")
180 t.Setenv("GORDON_TOKEN", "")
181 t.Setenv("MY_TOKEN", "fromenv")
182
183 config := &ClientConfig{
184 Active: "prod",
185 Remotes: map[string]RemoteEntry{
186 "prod": {URL: "https://gordon.example.com", TokenEnv: "MY_TOKEN"},
187 },
188 }
189 require.NoError(t, SaveRemotes("", config))
190
191 resolved, ok := Resolve("", "", false)
192 require.True(t, ok)
193 assert.Equal(t, "fromenv", resolved.Token)
194}
195
196func TestResolve_UnknownNameReturnsNotFound(t *testing.T) {
197 t.Setenv("XDG_CONFIG_HOME", t.TempDir())
198 t.Setenv("GORDON_REMOTE", "")
199 t.Setenv("GORDON_TOKEN", "")
200
201 resolved, ok := Resolve("nonexistent", "", false)
202 assert.False(t, ok)
203 assert.Nil(t, resolved)
204}