1package vps
2
3import (
4	"fmt"
5	"github.com/stretchr/testify/assert"
6	"github.com/stretchr/testify/require"
7	"github.com/transip/gotransip/v6"
8	"net/url"
9	"testing"
10	"time"
11)
12
13func TestBigStorageRepository_GetBigStorages(t *testing.T) {
14	const apiResponse = `{ "bigStorages": [ { "name": "example-bigstorage", "description": "Big storage description", "diskSize": 2147483648, "offsiteBackups": true, "vpsName": "example-vps", "status": "active", "isLocked": false, "availabilityZone": "ams0", "serial": "e7e12b3c7c6602973ac7" } ] } `
15	server := mockServer{t: t, expectedURL: "/big-storages", expectedMethod: "GET", statusCode: 200, response: apiResponse}
16	client, tearDown := server.getClient()
17	defer tearDown()
18	repo := BigStorageRepository{Client: *client}
19
20	all, err := repo.GetAll()
21	require.NoError(t, err)
22	require.Equal(t, 1, len(all))
23
24	assert.Equal(t, "example-bigstorage", all[0].Name)
25	assert.Equal(t, "Big storage description", all[0].Description)
26	assert.EqualValues(t, 2147483648, all[0].DiskSize)
27	assert.Equal(t, true, all[0].OffsiteBackups)
28	assert.Equal(t, "example-vps", all[0].VpsName)
29	assert.EqualValues(t, "active", all[0].Status)
30	assert.Equal(t, false, all[0].IsLocked)
31	assert.Equal(t, "ams0", all[0].AvailabilityZone)
32	assert.Equal(t, "e7e12b3c7c6602973ac7", all[0].Serial)
33}
34
35func TestBigStorageRepository_GetSelection(t *testing.T) {
36	const apiResponse = `{ "bigStorages": [ { "name": "example-bigstorage", "description": "Big storage description", "diskSize": 2147483648, "offsiteBackups": true, "vpsName": "example-vps", "status": "active", "isLocked": false, "availabilityZone": "ams0", "serial": "e7e12b3c7c6602973ac7"} ] } `
37	server := mockServer{t: t, expectedURL: "/big-storages?page=1&pageSize=25", expectedMethod: "GET", statusCode: 200, response: apiResponse}
38	client, tearDown := server.getClient()
39	defer tearDown()
40	repo := BigStorageRepository{Client: *client}
41
42	all, err := repo.GetSelection(1, 25)
43	require.NoError(t, err)
44	require.Equal(t, 1, len(all))
45
46	assert.Equal(t, "example-bigstorage", all[0].Name)
47	assert.Equal(t, "Big storage description", all[0].Description)
48	assert.EqualValues(t, 2147483648, all[0].DiskSize)
49	assert.Equal(t, true, all[0].OffsiteBackups)
50	assert.Equal(t, "example-vps", all[0].VpsName)
51	assert.EqualValues(t, "active", all[0].Status)
52	assert.Equal(t, false, all[0].IsLocked)
53	assert.Equal(t, "ams0", all[0].AvailabilityZone)
54	assert.Equal(t, "e7e12b3c7c6602973ac7", all[0].Serial)
55}
56
57func TestBigStorageRepository_GetBigStorageByName(t *testing.T) {
58	const apiResponse = `{ "bigStorage": { "name": "example-bigstorage", "description": "Big storage description", "diskSize": 2147483648, "offsiteBackups": true, "vpsName": "example-vps", "status": "active", "isLocked": false, "availabilityZone": "ams0", "serial": "e7e12b3c7c6602973ac7" } } `
59	server := mockServer{t: t, expectedURL: "/big-storages/example-bigstorage", expectedMethod: "GET", statusCode: 200, response: apiResponse}
60	client, tearDown := server.getClient()
61	defer tearDown()
62	repo := BigStorageRepository{Client: *client}
63
64	bigstorage, err := repo.GetByName("example-bigstorage")
65	require.NoError(t, err)
66	assert.Equal(t, "example-bigstorage", bigstorage.Name)
67	assert.Equal(t, "Big storage description", bigstorage.Description)
68	assert.EqualValues(t, 2147483648, bigstorage.DiskSize)
69	assert.Equal(t, true, bigstorage.OffsiteBackups)
70	assert.Equal(t, "example-vps", bigstorage.VpsName)
71	assert.EqualValues(t, "active", bigstorage.Status)
72	assert.Equal(t, false, bigstorage.IsLocked)
73	assert.Equal(t, "ams0", bigstorage.AvailabilityZone)
74	assert.Equal(t, "e7e12b3c7c6602973ac7", bigstorage.Serial)
75}
76
77func TestBigStorageRepository_OrderBigStorage(t *testing.T) {
78	const expectedRequest = `{"size":8,"offsiteBackups":true,"availabilityZone":"ams0","vpsName":"example-vps","description":"test-description"}`
79	server := mockServer{t: t, expectedURL: "/big-storages", expectedMethod: "POST", statusCode: 201, expectedRequest: expectedRequest}
80	client, tearDown := server.getClient()
81	defer tearDown()
82	repo := BigStorageRepository{Client: *client}
83
84	order := BigStorageOrder{Size: 8, OffsiteBackups: true, AvailabilityZone: "ams0", VpsName: "example-vps", Description: "test-description"}
85	err := repo.Order(order)
86
87	require.NoError(t, err)
88}
89
90func TestBigStorageRepository_UpgradeBigStorage(t *testing.T) {
91	const expectedRequest = `{"bigStorageName":"example-bigstorage","size":8,"offsiteBackups":true}`
92	server := mockServer{t: t, expectedURL: "/big-storages", expectedMethod: "POST", statusCode: 201, expectedRequest: expectedRequest}
93	client, tearDown := server.getClient()
94	defer tearDown()
95	repo := BigStorageRepository{Client: *client}
96
97	err := repo.Upgrade("example-bigstorage", 8, true)
98
99	require.NoError(t, err)
100}
101
102func TestBigStorageRepository_UpdateBigStorage(t *testing.T) {
103	const expectedRequest = `{"bigStorage":{"name":"example-bigstorage","description":"Big storage description","diskSize":2147483648,"offsiteBackups":true,"vpsName":"example-vps","status":"active","serial":"e7e12b3c7c6602973ac7","isLocked":false,"availabilityZone":"ams0"}}`
104	server := mockServer{t: t, expectedURL: "/big-storages/example-bigstorage", expectedMethod: "PUT", statusCode: 204, expectedRequest: expectedRequest}
105	client, tearDown := server.getClient()
106	defer tearDown()
107	repo := BigStorageRepository{Client: *client}
108
109	bigStorage := BigStorage{
110		Name:             "example-bigstorage",
111		Description:      "Big storage description",
112		DiskSize:         2147483648,
113		OffsiteBackups:   true,
114		VpsName:          "example-vps",
115		Status:           BigStorageStatusActive,
116		IsLocked:         false,
117		AvailabilityZone: "ams0",
118		Serial:           "e7e12b3c7c6602973ac7",
119	}
120	err := repo.Update(bigStorage)
121
122	require.NoError(t, err)
123}
124
125func TestBigStorageRepository_DetachVpsFromBigStorage(t *testing.T) {
126	const expectedRequest = `{"bigStorage":{"name":"example-bigstorage","description":"Big storage description","diskSize":2147483648,"offsiteBackups":true,"vpsName":"example-vps","status":"active","serial":"e7e12b3c7c6602973ac7","isLocked":false,"availabilityZone":"ams0"}}`
127	server := mockServer{t: t, expectedURL: "/big-storages/example-bigstorage", expectedMethod: "PUT", statusCode: 204, expectedRequest: expectedRequest}
128	client, tearDown := server.getClient()
129	defer tearDown()
130	repo := BigStorageRepository{Client: *client}
131
132	bigStorage := BigStorage{
133		Name:             "example-bigstorage",
134		Description:      "Big storage description",
135		DiskSize:         2147483648,
136		OffsiteBackups:   true,
137		Status:           "active",
138		IsLocked:         false,
139		AvailabilityZone: "ams0",
140		Serial:           "e7e12b3c7c6602973ac7",
141	}
142	err := repo.AttachToVps("example-vps", bigStorage)
143	require.NoError(t, err)
144}
145
146func TestBigStorageRepository_AttachVpsToBigStorage(t *testing.T) {
147	const expectedRequest = `{"bigStorage":{"name":"example-bigstorage","description":"Big storage description","diskSize":2147483648,"offsiteBackups":true,"vpsName":"","status":"active","serial":"e7e12b3c7c6602973ac7","isLocked":false,"availabilityZone":"ams0"}}`
148	server := mockServer{t: t, expectedURL: "/big-storages/example-bigstorage", expectedMethod: "PUT", statusCode: 204, expectedRequest: expectedRequest}
149	client, tearDown := server.getClient()
150	defer tearDown()
151	repo := BigStorageRepository{Client: *client}
152
153	bigStorage := BigStorage{
154		Name:             "example-bigstorage",
155		Description:      "Big storage description",
156		DiskSize:         2147483648,
157		OffsiteBackups:   true,
158		VpsName:          "example-vps",
159		Status:           "active",
160		IsLocked:         false,
161		AvailabilityZone: "ams0",
162		Serial:           "e7e12b3c7c6602973ac7",
163	}
164	err := repo.DetachFromVps(bigStorage)
165	require.NoError(t, err)
166}
167
168func TestBigStorageRepository_CancelBigStorage(t *testing.T) {
169	const expectedRequest = `{"endTime":"end"}`
170	server := mockServer{t: t, expectedURL: "/big-storages/example-bigstorage", expectedMethod: "DELETE", statusCode: 204, expectedRequest: expectedRequest}
171	client, tearDown := server.getClient()
172	defer tearDown()
173	repo := BigStorageRepository{Client: *client}
174
175	err := repo.Cancel("example-bigstorage", gotransip.CancellationTimeEnd)
176	require.NoError(t, err)
177}
178
179func TestBigStorageRepository_GetBigStorageBackups(t *testing.T) {
180	const apiResponse = `{ "backups": [ { "id": 1583, "status": "active", "diskSize": 4294967296, "dateTimeCreate": "2019-12-31 09:13:55", "availabilityZone": "ams0" } ] }`
181	server := mockServer{t: t, expectedURL: "/big-storages/example-bigstorage/backups", expectedMethod: "GET", statusCode: 200, response: apiResponse}
182	client, tearDown := server.getClient()
183	defer tearDown()
184	repo := BigStorageRepository{Client: *client}
185
186	all, err := repo.GetBackups("example-bigstorage")
187	require.NoError(t, err)
188	require.Equal(t, 1, len(all))
189
190	assert.EqualValues(t, 1583, all[0].ID)
191	assert.EqualValues(t, "active", all[0].Status)
192	assert.EqualValues(t, 4294967296, all[0].DiskSize)
193	assert.Equal(t, "2019-12-31 09:13:55", all[0].DateTimeCreate.Format("2006-01-02 15:04:05"))
194	assert.Equal(t, "ams0", all[0].AvailabilityZone)
195}
196
197func TestBigStorageRepository_RevertBigStorageBackup(t *testing.T) {
198	const expectedRequest = `{"action":"revert"}`
199	server := mockServer{t: t, expectedURL: "/big-storages/example-bigstorage/backups/123", expectedMethod: "PATCH", statusCode: 204, expectedRequest: expectedRequest}
200	client, tearDown := server.getClient()
201	defer tearDown()
202	repo := BigStorageRepository{Client: *client}
203
204	err := repo.RevertBackup("example-bigstorage", 123)
205	require.NoError(t, err)
206}
207
208func TestBigStorageRepository_GetBigStorageUsage(t *testing.T) {
209	const apiResponse = `{ "usage": [ { "iopsRead": 0.27, "iopsWrite": 0.13, "date": 1574783109 } ] }`
210
211	parameters := url.Values{
212		"dateTimeStart": []string{"1500538995"},
213		"dateTimeEnd":   []string{"1500542619"},
214	}
215
216	expectedURL := "/big-storages/example-bigstorage/usage?" + parameters.Encode()
217	server := mockServer{t: t, expectedURL: expectedURL, expectedMethod: "GET", statusCode: 200, response: apiResponse}
218	client, tearDown := server.getClient()
219	defer tearDown()
220	repo := BigStorageRepository{Client: *client}
221
222	usageData, err := repo.GetUsage("example-bigstorage", UsagePeriod{TimeStart: 1500538995, TimeEnd: 1500542619})
223	require.NoError(t, err)
224
225	require.Equal(t, 1, len(usageData))
226	assert.EqualValues(t, 0.27, usageData[0].IopsRead)
227	assert.EqualValues(t, 0.13, usageData[0].IopsWrite)
228	assert.EqualValues(t, 1574783109, usageData[0].Date)
229}
230
231func TestBigStorageRepository_GetBigStorageUsageLast24Hours(t *testing.T) {
232	const apiResponse = `{ "usage": [ { "iopsRead": 0.27, "iopsWrite": 0.13, "date": 1574783109 } ] }`
233
234	parameters := url.Values{
235		"dateTimeStart": []string{fmt.Sprintf("%d", time.Now().Add(-24*time.Hour).Unix())},
236		"dateTimeEnd":   []string{fmt.Sprintf("%d", time.Now().Unix())},
237	}
238
239	expectedURL := "/big-storages/example-bigstorage/usage?" + parameters.Encode()
240	server := mockServer{t: t, expectedURL: expectedURL, expectedMethod: "GET", statusCode: 200, response: apiResponse}
241	client, tearDown := server.getClient()
242	defer tearDown()
243	repo := BigStorageRepository{Client: *client}
244
245	usageData, err := repo.GetUsageLast24Hours("example-bigstorage")
246	require.NoError(t, err)
247
248	require.Equal(t, 1, len(usageData))
249	assert.EqualValues(t, 0.27, usageData[0].IopsRead)
250	assert.EqualValues(t, 0.13, usageData[0].IopsWrite)
251	assert.EqualValues(t, 1574783109, usageData[0].Date)
252}
253