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