1/*
2Copyright 2018 The Doctl Authors All rights reserved.
3Licensed under the Apache License, Version 2.0 (the "License");
4you may not use this file except in compliance with the License.
5You may obtain a copy of the License at
6    http://www.apache.org/licenses/LICENSE-2.0
7Unless required by applicable law or agreed to in writing, software
8distributed under the License is distributed on an "AS IS" BASIS,
9WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10See the License for the specific language governing permissions and
11limitations under the License.
12*/
13
14package commands
15
16import (
17	"testing"
18	"time"
19
20	"github.com/digitalocean/doctl"
21	"github.com/digitalocean/doctl/do"
22	"github.com/digitalocean/godo"
23	"github.com/stretchr/testify/assert"
24)
25
26var (
27	cdnID     = "00000000-0000-4000-8000-000000000000"
28	cdnOrigin = "my-spaces.nyc3.digitaloceanspaces.com"
29
30	testCDN = do.CDN{
31		CDN: &godo.CDN{
32			ID:        cdnID,
33			Origin:    cdnOrigin,
34			Endpoint:  "my-spaces.nyc3.cdn.digitaloceanspaces.com",
35			TTL:       3600,
36			CreatedAt: time.Now(),
37		},
38	}
39
40	testCDNWithCustomDomain = do.CDN{
41		CDN: &godo.CDN{
42			ID:            cdnID,
43			Origin:        cdnOrigin,
44			Endpoint:      "my-spaces.nyc3.cdn.digitaloceanspaces.com",
45			TTL:           3600,
46			CustomDomain:  "assets.myacmecorp.com",
47			CertificateID: "00000000-0000-4000-8000-000000000000",
48			CreatedAt:     time.Now(),
49		},
50	}
51
52	updatedCDN = do.CDN{
53		CDN: &godo.CDN{
54			ID:        cdnID,
55			Origin:    cdnOrigin,
56			Endpoint:  "my-spaces.nyc3.cdn.digitaloceanspaces.com",
57			TTL:       60,
58			CreatedAt: time.Now(),
59		},
60	}
61
62	updatedCDNWithCustomDomain = do.CDN{
63		CDN: &godo.CDN{
64			ID:            cdnID,
65			Origin:        cdnOrigin,
66			Endpoint:      "my-spaces.nyc3.cdn.digitaloceanspaces.com",
67			TTL:           3600,
68			CustomDomain:  "assets.myacmecorp.com",
69			CertificateID: "00000000-0000-4000-8000-000000000000",
70			CreatedAt:     time.Now(),
71		},
72	}
73
74	testCDNList = []do.CDN{
75		testCDN,
76	}
77)
78
79func TestCDNCommand(t *testing.T) {
80	cmd := CDN()
81	assert.NotNil(t, cmd)
82	assertCommandNames(t, cmd, "create", "delete", "get", "list", "update", "flush")
83}
84
85func TestCDNsGet(t *testing.T) {
86	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
87		tm.cdns.EXPECT().Get(cdnID).Return(&testCDN, nil)
88
89		config.Args = append(config.Args, cdnID)
90
91		err := RunCDNGet(config)
92		assert.NoError(t, err)
93	})
94}
95
96func TestCDNsGet_RequiredArguments(t *testing.T) {
97	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
98		err := RunCDNGet(config)
99		assert.Error(t, err)
100	})
101}
102
103func TestCDNsList(t *testing.T) {
104	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
105		tm.cdns.EXPECT().List().Return(testCDNList, nil)
106
107		err := RunCDNList(config)
108		assert.NoError(t, err)
109	})
110}
111
112func TestCDNsCreate(t *testing.T) {
113	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
114		cdncr := &godo.CDNCreateRequest{
115			Origin: cdnOrigin,
116			TTL:    3600,
117		}
118		tm.cdns.EXPECT().Create(cdncr).Return(&testCDN, nil)
119
120		config.Args = append(config.Args, cdnOrigin)
121		config.Doit.Set(config.NS, doctl.ArgCDNTTL, 3600)
122
123		err := RunCDNCreate(config)
124		assert.NoError(t, err)
125	})
126}
127
128func TestCDNsCreateCustomDomain(t *testing.T) {
129	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
130		cdncr := &godo.CDNCreateRequest{
131			Origin:        cdnOrigin,
132			TTL:           3600,
133			CustomDomain:  testCDNWithCustomDomain.CustomDomain,
134			CertificateID: testCDNWithCustomDomain.CertificateID,
135		}
136		tm.cdns.EXPECT().Create(cdncr).Return(&testCDNWithCustomDomain, nil)
137
138		config.Args = append(config.Args, cdnOrigin)
139		config.Doit.Set(config.NS, doctl.ArgCDNTTL, 3600)
140		config.Doit.Set(config.NS, doctl.ArgCDNDomain, testCDNWithCustomDomain.CustomDomain)
141		config.Doit.Set(config.NS, doctl.ArgCDNCertificateID, testCDNWithCustomDomain.CertificateID)
142
143		err := RunCDNCreate(config)
144		assert.NoError(t, err)
145	})
146}
147
148func TestCDNsCreateCustomDomain_NoCertIDFail(t *testing.T) {
149	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
150		config.Args = append(config.Args, cdnOrigin)
151		config.Doit.Set(config.NS, doctl.ArgCDNTTL, 3600)
152		config.Doit.Set(config.NS, doctl.ArgCDNDomain, updatedCDNWithCustomDomain.CustomDomain)
153
154		err := RunCDNCreate(config)
155		assert.Error(t, err)
156	})
157}
158
159func TestCDNsCreate_RequiredArguments(t *testing.T) {
160	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
161		err := RunCDNCreate(config)
162		assert.Error(t, err)
163	})
164}
165
166func TestCDNsCreate_ZeroFail(t *testing.T) {
167	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
168		config.Args = append(config.Args, cdnOrigin)
169		config.Doit.Set(config.NS, doctl.ArgCDNTTL, 0)
170
171		err := RunCDNCreate(config)
172		assert.Error(t, err)
173	})
174}
175
176func TestCDNsUpdateTTL(t *testing.T) {
177	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
178		cdnur := &godo.CDNUpdateTTLRequest{
179			TTL: 60,
180		}
181		tm.cdns.EXPECT().UpdateTTL(cdnID, cdnur).Return(&updatedCDN, nil)
182
183		config.Args = append(config.Args, cdnID)
184		config.Doit.Set(config.NS, doctl.ArgCDNTTL, 60)
185
186		err := RunCDNUpdate(config)
187		assert.NoError(t, err)
188	})
189}
190
191func TestCDNsUpdateTTL_ZeroFail(t *testing.T) {
192	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
193		config.Args = append(config.Args, cdnID)
194		config.Doit.Set(config.NS, doctl.ArgCDNTTL, 0)
195
196		err := RunCDNUpdate(config)
197		assert.Error(t, err)
198	})
199}
200
201func TestCDNsUpdateCustomDomain(t *testing.T) {
202	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
203		cdnur := &godo.CDNUpdateCustomDomainRequest{
204			CustomDomain:  updatedCDNWithCustomDomain.CustomDomain,
205			CertificateID: updatedCDNWithCustomDomain.CertificateID,
206		}
207		tm.cdns.EXPECT().UpdateCustomDomain(cdnID, cdnur).Return(&updatedCDNWithCustomDomain, nil)
208
209		config.Args = append(config.Args, cdnID)
210		config.Doit.Set(config.NS, doctl.ArgCDNDomain, updatedCDNWithCustomDomain.CustomDomain)
211		config.Doit.Set(config.NS, doctl.ArgCDNCertificateID, updatedCDNWithCustomDomain.CertificateID)
212
213		err := RunCDNUpdate(config)
214		assert.NoError(t, err)
215	})
216}
217
218func TestCDNsUpdateCustomDomain_NoCertIDFail(t *testing.T) {
219	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
220		config.Args = append(config.Args, cdnID)
221		config.Doit.Set(config.NS, doctl.ArgCDNDomain, updatedCDNWithCustomDomain.CustomDomain)
222
223		err := RunCDNUpdate(config)
224		assert.Error(t, err)
225	})
226}
227
228func TestCDNsUpdateRemoveCustomDomain(t *testing.T) {
229	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
230		cdnur := &godo.CDNUpdateCustomDomainRequest{
231			CustomDomain: "",
232		}
233		tm.cdns.EXPECT().UpdateCustomDomain(cdnID, cdnur).Return(&testCDN, nil)
234
235		config.Args = append(config.Args, cdnID)
236		config.Doit.Set(config.NS, doctl.ArgCDNDomain, "")
237
238		err := RunCDNUpdate(config)
239		assert.NoError(t, err)
240	})
241}
242
243func TestCDNsUpdate_NothingToUpdateFail(t *testing.T) {
244	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
245		config.Args = append(config.Args, cdnID)
246		err := RunCDNUpdate(config)
247		assert.Error(t, err)
248	})
249}
250
251func TestCDNsDelete(t *testing.T) {
252	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
253		tm.cdns.EXPECT().Delete(cdnID).Return(nil)
254
255		config.Args = append(config.Args, cdnID)
256		config.Doit.Set(config.NS, doctl.ArgForce, true)
257
258		err := RunCDNDelete(config)
259		assert.NoError(t, err)
260	})
261}
262
263func TestCDNsDelete_RequiredArguments(t *testing.T) {
264	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
265		err := RunCDNDelete(config)
266		assert.Error(t, err)
267	})
268}
269
270func TestCDNsFlushCache(t *testing.T) {
271	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
272		flushReq := &godo.CDNFlushCacheRequest{Files: []string{"*"}}
273		tm.cdns.EXPECT().FlushCache(cdnID, flushReq).Return(nil)
274
275		config.Args = append(config.Args, cdnID)
276		config.Doit.Set(config.NS, doctl.ArgCDNFiles, []string{"*"})
277
278		err := RunCDNFlushCache(config)
279		assert.NoError(t, err)
280	})
281}
282
283func TestCDNsFlushCache_RequiredArguments(t *testing.T) {
284	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
285		err := RunCDNFlushCache(config)
286		assert.Error(t, err)
287	})
288}
289