1package tfe
2
3import (
4	"context"
5	"testing"
6
7	"github.com/stretchr/testify/assert"
8	"github.com/stretchr/testify/require"
9)
10
11func TestSSHKeysList(t *testing.T) {
12	client := testClient(t)
13	ctx := context.Background()
14
15	orgTest, orgTestCleanup := createOrganization(t, client)
16	defer orgTestCleanup()
17
18	kTest1, _ := createSSHKey(t, client, orgTest)
19	kTest2, _ := createSSHKey(t, client, orgTest)
20
21	t.Run("without list options", func(t *testing.T) {
22		kl, err := client.SSHKeys.List(ctx, orgTest.Name, SSHKeyListOptions{})
23		require.NoError(t, err)
24		assert.Contains(t, kl.Items, kTest1)
25		assert.Contains(t, kl.Items, kTest2)
26
27		t.Skip("paging not supported yet in API")
28		assert.Equal(t, 1, kl.CurrentPage)
29		assert.Equal(t, 2, kl.TotalCount)
30	})
31
32	t.Run("with list options", func(t *testing.T) {
33		t.Skip("paging not supported yet in API")
34		// Request a page number which is out of range. The result should
35		// be successful, but return no results if the paging options are
36		// properly passed along.
37		kl, err := client.SSHKeys.List(ctx, orgTest.Name, SSHKeyListOptions{
38			ListOptions: ListOptions{
39				PageNumber: 999,
40				PageSize:   100,
41			},
42		})
43		require.NoError(t, err)
44		assert.Empty(t, kl.Items)
45		assert.Equal(t, 999, kl.CurrentPage)
46		assert.Equal(t, 2, kl.TotalCount)
47	})
48
49	t.Run("without a valid organization", func(t *testing.T) {
50		kl, err := client.SSHKeys.List(ctx, badIdentifier, SSHKeyListOptions{})
51		assert.Nil(t, kl)
52		assert.EqualError(t, err, "invalid value for organization")
53	})
54}
55
56func TestSSHKeysCreate(t *testing.T) {
57	client := testClient(t)
58	ctx := context.Background()
59
60	orgTest, orgTestCleanup := createOrganization(t, client)
61	defer orgTestCleanup()
62
63	t.Run("with valid options", func(t *testing.T) {
64		options := SSHKeyCreateOptions{
65			Name:  String(randomString(t)),
66			Value: String(randomString(t)),
67		}
68
69		k, err := client.SSHKeys.Create(ctx, orgTest.Name, options)
70		require.NoError(t, err)
71
72		// Get a refreshed view from the API.
73		refreshed, err := client.SSHKeys.Read(ctx, k.ID)
74		require.NoError(t, err)
75
76		for _, item := range []*SSHKey{
77			k,
78			refreshed,
79		} {
80			assert.NotEmpty(t, item.ID)
81			assert.Equal(t, *options.Name, item.Name)
82		}
83	})
84
85	t.Run("when options is missing name", func(t *testing.T) {
86		k, err := client.SSHKeys.Create(ctx, "foo", SSHKeyCreateOptions{
87			Value: String(randomString(t)),
88		})
89		assert.Nil(t, k)
90		assert.EqualError(t, err, "name is required")
91	})
92
93	t.Run("when options is missing value", func(t *testing.T) {
94		k, err := client.SSHKeys.Create(ctx, "foo", SSHKeyCreateOptions{
95			Name: String(randomString(t)),
96		})
97		assert.Nil(t, k)
98		assert.EqualError(t, err, "value is required")
99	})
100
101	t.Run("when options has an invalid organization", func(t *testing.T) {
102		k, err := client.SSHKeys.Create(ctx, badIdentifier, SSHKeyCreateOptions{
103			Name: String("foo"),
104		})
105		assert.Nil(t, k)
106		assert.EqualError(t, err, "invalid value for organization")
107	})
108}
109
110func TestSSHKeysRead(t *testing.T) {
111	client := testClient(t)
112	ctx := context.Background()
113
114	orgTest, orgTestCleanup := createOrganization(t, client)
115	defer orgTestCleanup()
116
117	kTest, _ := createSSHKey(t, client, orgTest)
118
119	t.Run("when the SSH key exists", func(t *testing.T) {
120		k, err := client.SSHKeys.Read(ctx, kTest.ID)
121		require.NoError(t, err)
122		assert.Equal(t, kTest, k)
123	})
124
125	t.Run("when the SSH key does not exist", func(t *testing.T) {
126		k, err := client.SSHKeys.Read(ctx, "nonexisting")
127		assert.Nil(t, k)
128		assert.Equal(t, err, ErrResourceNotFound)
129	})
130
131	t.Run("without a valid SSH key ID", func(t *testing.T) {
132		k, err := client.SSHKeys.Read(ctx, badIdentifier)
133		assert.Nil(t, k)
134		assert.EqualError(t, err, "invalid value for SSH key ID")
135	})
136}
137
138func TestSSHKeysUpdate(t *testing.T) {
139	client := testClient(t)
140	ctx := context.Background()
141
142	orgTest, orgTestCleanup := createOrganization(t, client)
143	defer orgTestCleanup()
144
145	t.Run("with valid options", func(t *testing.T) {
146		kBefore, kTestCleanup := createSSHKey(t, client, orgTest)
147		defer kTestCleanup()
148
149		kAfter, err := client.SSHKeys.Update(ctx, kBefore.ID, SSHKeyUpdateOptions{
150			Name:  String(randomString(t)),
151			Value: String(randomString(t)),
152		})
153		require.NoError(t, err)
154
155		assert.Equal(t, kBefore.ID, kAfter.ID)
156		assert.NotEqual(t, kBefore.Name, kAfter.Name)
157	})
158
159	t.Run("when updating the name", func(t *testing.T) {
160		kBefore, kTestCleanup := createSSHKey(t, client, orgTest)
161		defer kTestCleanup()
162
163		kAfter, err := client.SSHKeys.Update(ctx, kBefore.ID, SSHKeyUpdateOptions{
164			Name: String("updated-key-name"),
165		})
166		require.NoError(t, err)
167
168		assert.Equal(t, kBefore.ID, kAfter.ID)
169		assert.Equal(t, "updated-key-name", kAfter.Name)
170	})
171
172	t.Run("when updating the value", func(t *testing.T) {
173		kBefore, kTestCleanup := createSSHKey(t, client, orgTest)
174		defer kTestCleanup()
175
176		kAfter, err := client.SSHKeys.Update(ctx, kBefore.ID, SSHKeyUpdateOptions{
177			Value: String("updated-key-value"),
178		})
179		require.NoError(t, err)
180
181		assert.Equal(t, kBefore.ID, kAfter.ID)
182		assert.Equal(t, kBefore.Name, kAfter.Name)
183	})
184
185	t.Run("without a valid SSH key ID", func(t *testing.T) {
186		w, err := client.SSHKeys.Update(ctx, badIdentifier, SSHKeyUpdateOptions{})
187		assert.Nil(t, w)
188		assert.EqualError(t, err, "invalid value for SSH key ID")
189	})
190}
191
192func TestSSHKeysDelete(t *testing.T) {
193	client := testClient(t)
194	ctx := context.Background()
195
196	orgTest, orgTestCleanup := createOrganization(t, client)
197	defer orgTestCleanup()
198
199	kTest, _ := createSSHKey(t, client, orgTest)
200
201	t.Run("with valid options", func(t *testing.T) {
202		err := client.SSHKeys.Delete(ctx, kTest.ID)
203		require.NoError(t, err)
204
205		// Try loading the SSH key - it should fail.
206		_, err = client.SSHKeys.Read(ctx, kTest.ID)
207		assert.Equal(t, err, ErrResourceNotFound)
208	})
209
210	t.Run("when the SSH key does not exist", func(t *testing.T) {
211		err := client.SSHKeys.Delete(ctx, kTest.ID)
212		assert.Equal(t, err, ErrResourceNotFound)
213	})
214
215	t.Run("when the SSH key ID is invalid", func(t *testing.T) {
216		err := client.SSHKeys.Delete(ctx, badIdentifier)
217		assert.EqualError(t, err, "invalid value for SSH key ID")
218	})
219}
220