1 package credentials
2
3 import (
4 "bytes"
5 "encoding/json"
6 "fmt"
7 "strings"
8 "testing"
9 )
10
11 type memoryStore struct {
12 creds map[string]*Credentials
13 }
14
15 func newMemoryStore() *memoryStore {
16 return &memoryStore{
17 creds: make(map[string]*Credentials),
18 }
19 }
20
21 func (m *memoryStore) Add(creds *Credentials) error {
22 m.creds[creds.ServerURL] = creds
23 return nil
24 }
25
26 func (m *memoryStore) Delete(serverURL string) error {
27 delete(m.creds, serverURL)
28 return nil
29 }
30
31 func (m *memoryStore) Get(serverURL string) (string, string, error) {
32 c, ok := m.creds[serverURL]
33 if !ok {
34 return "", "", fmt.Errorf("creds not found for %s", serverURL)
35 }
36 return c.Username, c.Secret, nil
37 }
38
39 func (m *memoryStore) List() (map[string]string, error) {
40
41 return nil, nil
42 }
43
44 func TestStore(t *testing.T) {
45 const serverURL = "https://registry.example.com/v1/"
46 creds := &Credentials{
47 ServerURL: serverURL,
48 Username: "foo",
49 Secret: "bar",
50 }
51 b, err := json.Marshal(creds)
52 if err != nil {
53 t.Fatal(err)
54 }
55 in := bytes.NewReader(b)
56
57 h := newMemoryStore()
58 if err := Store(h, in); err != nil {
59 t.Fatal(err)
60 }
61
62 c, ok := h.creds[serverURL]
63 if !ok {
64 t.Fatalf("creds not found for %s\n", serverURL)
65 }
66
67 if c.Username != "foo" {
68 t.Errorf("expected username foo, got %s\n", c.Username)
69 }
70
71 if c.Secret != "bar" {
72 t.Errorf("expected username bar, got %s\n", c.Secret)
73 }
74 }
75
76 func TestStoreMissingServerURL(t *testing.T) {
77 creds := &Credentials{
78 ServerURL: "",
79 Username: "foo",
80 Secret: "bar",
81 }
82
83 b, err := json.Marshal(creds)
84 if err != nil {
85 t.Fatal(err)
86 }
87 in := bytes.NewReader(b)
88
89 h := newMemoryStore()
90
91 if err := Store(h, in); !IsCredentialsMissingServerURL(err) {
92 t.Error(err)
93 }
94 }
95
96 func TestStoreMissingUsername(t *testing.T) {
97 creds := &Credentials{
98 ServerURL: "https://registry.example.com/v1/",
99 Username: "",
100 Secret: "bar",
101 }
102
103 b, err := json.Marshal(creds)
104 if err != nil {
105 t.Fatal(err)
106 }
107 in := bytes.NewReader(b)
108
109 h := newMemoryStore()
110
111 if err := Store(h, in); !IsCredentialsMissingUsername(err) {
112 t.Error(err)
113 }
114 }
115
116 func TestGet(t *testing.T) {
117 const serverURL = "https://registry.example.com/v1/"
118 creds := &Credentials{
119 ServerURL: serverURL,
120 Username: "foo",
121 Secret: "bar",
122 }
123 b, err := json.Marshal(creds)
124 if err != nil {
125 t.Fatal(err)
126 }
127 in := bytes.NewReader(b)
128
129 h := newMemoryStore()
130 if err := Store(h, in); err != nil {
131 t.Fatal(err)
132 }
133
134 buf := strings.NewReader(serverURL)
135 w := new(bytes.Buffer)
136 if err := Get(h, buf, w); err != nil {
137 t.Fatal(err)
138 }
139
140 if w.Len() == 0 {
141 t.Fatalf("expected output in the writer, got %d", w.Len())
142 }
143
144 var c Credentials
145 if err := json.NewDecoder(w).Decode(&c); err != nil {
146 t.Fatal(err)
147 }
148
149 if c.Username != "foo" {
150 t.Errorf("expected username foo, got %s\n", c.Username)
151 }
152
153 if c.Secret != "bar" {
154 t.Errorf("expected username bar, got %s\n", c.Secret)
155 }
156 }
157
158 func TestGetMissingServerURL(t *testing.T) {
159 const serverURL = "https://registry.example.com/v1/"
160 creds := &Credentials{
161 ServerURL: serverURL,
162 Username: "foo",
163 Secret: "bar",
164 }
165 b, err := json.Marshal(creds)
166 if err != nil {
167 t.Fatal(err)
168 }
169 in := bytes.NewReader(b)
170
171 h := newMemoryStore()
172 if err := Store(h, in); err != nil {
173 t.Fatal(err)
174 }
175
176 buf := strings.NewReader("")
177 w := new(bytes.Buffer)
178
179 if err := Get(h, buf, w); !IsCredentialsMissingServerURL(err) {
180 t.Error(err)
181 }
182 }
183
184 func TestErase(t *testing.T) {
185 const serverURL = "https://registry.example.com/v1/"
186 creds := &Credentials{
187 ServerURL: serverURL,
188 Username: "foo",
189 Secret: "bar",
190 }
191 b, err := json.Marshal(creds)
192 if err != nil {
193 t.Fatal(err)
194 }
195 in := bytes.NewReader(b)
196
197 h := newMemoryStore()
198 if err := Store(h, in); err != nil {
199 t.Fatal(err)
200 }
201
202 buf := strings.NewReader(serverURL)
203 if err := Erase(h, buf); err != nil {
204 t.Fatal(err)
205 }
206
207 w := new(bytes.Buffer)
208 if err := Get(h, buf, w); err == nil {
209 t.Error("expected error getting missing creds, got empty")
210 }
211 }
212
213 func TestEraseMissingServerURL(t *testing.T) {
214 const serverURL = "https://registry.example.com/v1/"
215 creds := &Credentials{
216 ServerURL: serverURL,
217 Username: "foo",
218 Secret: "bar",
219 }
220 b, err := json.Marshal(creds)
221 if err != nil {
222 t.Fatal(err)
223 }
224 in := bytes.NewReader(b)
225
226 h := newMemoryStore()
227 if err := Store(h, in); err != nil {
228 t.Fatal(err)
229 }
230
231 buf := strings.NewReader("")
232 if err := Erase(h, buf); !IsCredentialsMissingServerURL(err) {
233 t.Error(err)
234 }
235 }
236
237 func TestList(t *testing.T) {
238
239
240 out := new(bytes.Buffer)
241 h := newMemoryStore()
242 if err := List(h, out); err != nil {
243 t.Fatal(err)
244 }
245
246 if out.Len() == 0 {
247 t.Error("expected output in the writer, got 0")
248 }
249 }
250
View as plain text