1package backend
2
3import (
4	"testing"
5
6	"github.com/grafana/grafana-plugin-sdk-go/backend/httpclient"
7	"github.com/stretchr/testify/assert"
8	"github.com/stretchr/testify/require"
9)
10
11func TestAppInstanceSettings(t *testing.T) {
12	t.Run("HTTPClientOptions() should translate settings as expected", func(t *testing.T) {
13		tcs := []struct {
14			instanceSettings      *AppInstanceSettings
15			expectedClientOptions httpclient.Options
16		}{
17			{
18				instanceSettings:      &AppInstanceSettings{},
19				expectedClientOptions: httpclient.Options{},
20			},
21			{
22				instanceSettings: &AppInstanceSettings{
23					JSONData: []byte("{ \"key\": \"value\" }"),
24					DecryptedSecureJSONData: map[string]string{
25						"sKey": "sValue",
26					},
27				},
28				expectedClientOptions: httpclient.Options{
29					CustomOptions: map[string]interface{}{
30						dataCustomOptionsKey: map[string]interface{}{
31							"key": "value",
32						},
33						secureDataCustomOptionsKey: map[string]string{
34							"sKey": "sValue",
35						},
36					},
37				},
38			},
39		}
40
41		for _, tc := range tcs {
42			opts, err := tc.instanceSettings.HTTPClientOptions()
43			assert.NoError(t, err)
44			if tc.expectedClientOptions.BasicAuth != nil {
45				assert.Equal(t, tc.expectedClientOptions.BasicAuth, opts.BasicAuth)
46			} else {
47				assert.Nil(t, opts.BasicAuth)
48			}
49
50			if tc.expectedClientOptions.Labels != nil {
51				assert.Equal(t, tc.expectedClientOptions.Labels, opts.Labels)
52			}
53
54			jsonData := JSONDataFromHTTPClientOptions(opts)
55			expectedJSONData := JSONDataFromHTTPClientOptions(tc.expectedClientOptions)
56			secureJSONData := SecureJSONDataFromHTTPClientOptions(opts)
57			expectedSecureJSONData := SecureJSONDataFromHTTPClientOptions(tc.expectedClientOptions)
58
59			if len(tc.expectedClientOptions.CustomOptions) > 0 {
60				assert.Equal(t, tc.expectedClientOptions.CustomOptions, opts.CustomOptions)
61				assert.Equal(t, expectedJSONData, jsonData)
62				assert.Equal(t, expectedSecureJSONData, secureJSONData)
63			} else {
64				assert.Empty(t, opts.CustomOptions)
65				assert.Empty(t, jsonData)
66				assert.Empty(t, secureJSONData)
67			}
68		}
69	})
70}
71
72func TestDataSourceInstanceSettings(t *testing.T) {
73	t.Run("HTTPClientOptions() should translate settings as expected", func(t *testing.T) {
74		tcs := []struct {
75			instanceSettings      *DataSourceInstanceSettings
76			expectedClientOptions httpclient.Options
77		}{
78			{
79				instanceSettings:      &DataSourceInstanceSettings{},
80				expectedClientOptions: httpclient.Options{},
81			},
82			{
83				instanceSettings: &DataSourceInstanceSettings{
84					Name:             "ds1",
85					UID:              "uid1",
86					User:             "user",
87					JSONData:         []byte("{}"),
88					BasicAuthEnabled: true,
89					BasicAuthUser:    "buser",
90					DecryptedSecureJSONData: map[string]string{
91						"basicAuthPassword": "bpwd",
92						"password":          "pwd",
93					},
94				},
95				expectedClientOptions: httpclient.Options{
96					BasicAuth: &httpclient.BasicAuthOptions{
97						User:     "buser",
98						Password: "bpwd",
99					},
100					Labels: map[string]string{
101						"datasource_name": "ds1",
102						"datasource_uid":  "uid1",
103					},
104					CustomOptions: map[string]interface{}{
105						dataCustomOptionsKey: map[string]interface{}{},
106						secureDataCustomOptionsKey: map[string]string{
107							"basicAuthPassword": "bpwd",
108							"password":          "pwd",
109						},
110					},
111				},
112			},
113			{
114				instanceSettings: &DataSourceInstanceSettings{
115					Name:             "ds2",
116					UID:              "uid2",
117					User:             "user",
118					JSONData:         []byte("{}"),
119					BasicAuthEnabled: false,
120					BasicAuthUser:    "buser",
121					DecryptedSecureJSONData: map[string]string{
122						"basicAuthPassword": "bpwd",
123						"password":          "pwd",
124					},
125				},
126				expectedClientOptions: httpclient.Options{
127					BasicAuth: &httpclient.BasicAuthOptions{
128						User:     "user",
129						Password: "pwd",
130					},
131					Labels: map[string]string{
132						"datasource_name": "ds2",
133						"datasource_uid":  "uid2",
134					},
135					CustomOptions: map[string]interface{}{
136						dataCustomOptionsKey: map[string]interface{}{},
137						secureDataCustomOptionsKey: map[string]string{
138							"basicAuthPassword": "bpwd",
139							"password":          "pwd",
140						},
141					},
142				},
143			},
144			{
145				instanceSettings: &DataSourceInstanceSettings{
146					JSONData: []byte("{ \"key\": \"value\" }"),
147					DecryptedSecureJSONData: map[string]string{
148						"sKey": "sValue",
149					},
150				},
151				expectedClientOptions: httpclient.Options{
152					CustomOptions: map[string]interface{}{
153						dataCustomOptionsKey: map[string]interface{}{
154							"key": "value",
155						},
156						secureDataCustomOptionsKey: map[string]string{
157							"sKey": "sValue",
158						},
159					},
160				},
161			},
162		}
163
164		for _, tc := range tcs {
165			opts, err := tc.instanceSettings.HTTPClientOptions()
166			assert.NoError(t, err)
167			if tc.expectedClientOptions.BasicAuth != nil {
168				assert.Equal(t, tc.expectedClientOptions.BasicAuth, opts.BasicAuth)
169			} else {
170				assert.Nil(t, opts.BasicAuth)
171			}
172
173			if tc.expectedClientOptions.Labels != nil {
174				assert.Equal(t, tc.expectedClientOptions.Labels, opts.Labels)
175			}
176
177			jsonData := JSONDataFromHTTPClientOptions(opts)
178			expectedJSONData := JSONDataFromHTTPClientOptions(tc.expectedClientOptions)
179			secureJSONData := SecureJSONDataFromHTTPClientOptions(opts)
180			expectedSecureJSONData := SecureJSONDataFromHTTPClientOptions(tc.expectedClientOptions)
181
182			if len(tc.expectedClientOptions.CustomOptions) > 0 {
183				assert.Equal(t, tc.expectedClientOptions.CustomOptions, opts.CustomOptions)
184				assert.Equal(t, expectedJSONData, jsonData)
185				assert.Equal(t, expectedSecureJSONData, secureJSONData)
186			} else {
187				assert.Empty(t, opts.CustomOptions)
188				assert.Empty(t, jsonData)
189				assert.Empty(t, secureJSONData)
190			}
191		}
192	})
193}
194
195func TestCustomOptions(t *testing.T) {
196	t.Run("Should be able to extract JSONData and SecureJSONData from custom options", func(t *testing.T) {
197		opts := &httpclient.Options{}
198		expectedJSONData := map[string]interface{}{
199			"key": "value",
200		}
201		expectedSecureJSONData := map[string]string{
202			"sKey": "sValue",
203		}
204		setCustomOptionsFromHTTPSettings(opts, &HTTPSettings{
205			JSONData:       expectedJSONData,
206			SecureJSONData: expectedSecureJSONData,
207		})
208
209		jsonData := JSONDataFromHTTPClientOptions(*opts)
210		secureJSONData := SecureJSONDataFromHTTPClientOptions(*opts)
211
212		require.Equal(t, expectedJSONData, jsonData)
213		require.Equal(t, expectedSecureJSONData, secureJSONData)
214	})
215
216	t.Run("Should be able to extract JSONData and SecureJSONData from custom options", func(t *testing.T) {
217		opts := &httpclient.Options{
218			CustomOptions: map[string]interface{}{},
219		}
220		incorrectJSONData := map[string]string{
221			"key": "value",
222		}
223		incorrectSecureJSONData := map[string]interface{}{
224			"sKey": "sValue",
225		}
226		opts.CustomOptions[dataCustomOptionsKey] = incorrectJSONData
227		opts.CustomOptions[secureDataCustomOptionsKey] = incorrectSecureJSONData
228
229		jsonData := JSONDataFromHTTPClientOptions(*opts)
230		secureJSONData := SecureJSONDataFromHTTPClientOptions(*opts)
231
232		require.Empty(t, jsonData)
233		require.Empty(t, secureJSONData)
234	})
235}
236