github.com/argoproj/argo-cd/v3@v3.2.1/applicationset/services/internal/http/client_test.go (about)

     1  package http
     2  
     3  import (
     4  	"bytes"
     5  	"errors"
     6  	"fmt"
     7  	"io"
     8  	"net/http"
     9  	"net/http/httptest"
    10  	"testing"
    11  
    12  	"github.com/stretchr/testify/assert"
    13  	"github.com/stretchr/testify/require"
    14  )
    15  
    16  func TestClient(t *testing.T) {
    17  	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
    18  		w.WriteHeader(http.StatusOK)
    19  		_, err := w.Write([]byte("Hello, World!"))
    20  		if err != nil {
    21  			assert.NoError(t, fmt.Errorf("Error Write %w", err))
    22  		}
    23  	}))
    24  	defer server.Close()
    25  
    26  	var clientOptionFns []ClientOptionFunc
    27  	_, err := NewClient(server.URL, clientOptionFns...)
    28  	require.NoError(t, err, "Failed to create client")
    29  }
    30  
    31  func TestClientDo(t *testing.T) {
    32  	for _, c := range []struct {
    33  		name            string
    34  		params          map[string]string
    35  		content         []byte
    36  		fakeServer      *httptest.Server
    37  		clientOptionFns []ClientOptionFunc
    38  		expected        []map[string]any
    39  		expectedCode    int
    40  		expectedError   error
    41  	}{
    42  		{
    43  			name: "Simple",
    44  			params: map[string]string{
    45  				"pkey1": "val1",
    46  				"pkey2": "val2",
    47  			},
    48  			fakeServer: httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
    49  				w.WriteHeader(http.StatusOK)
    50  				_, err := w.Write([]byte(`[{
    51  					"key1": "val1",
    52  					"key2": {
    53  						"key2_1": "val2_1",
    54  						"key2_2": {
    55  							"key2_2_1": "val2_2_1"
    56  						}
    57  					},
    58  					"key3": 123
    59  				 }]`))
    60  				if err != nil {
    61  					assert.NoError(t, fmt.Errorf("Error Write %w", err))
    62  				}
    63  			})),
    64  			clientOptionFns: nil,
    65  			expected: []map[string]any{
    66  				{
    67  					"key1": "val1",
    68  					"key2": map[string]any{
    69  						"key2_1": "val2_1",
    70  						"key2_2": map[string]any{
    71  							"key2_2_1": "val2_2_1",
    72  						},
    73  					},
    74  					"key3": float64(123),
    75  				},
    76  			},
    77  			expectedCode:  http.StatusOK,
    78  			expectedError: nil,
    79  		},
    80  		{
    81  			name: "With Token",
    82  			params: map[string]string{
    83  				"pkey1": "val1",
    84  				"pkey2": "val2",
    85  			},
    86  			fakeServer: httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    87  				authHeader := r.Header.Get("Authorization")
    88  				if authHeader != "Bearer "+string("test-token") {
    89  					w.WriteHeader(http.StatusUnauthorized)
    90  					return
    91  				}
    92  				w.WriteHeader(http.StatusOK)
    93  				_, err := w.Write([]byte(`[{
    94  					"key1": "val1",
    95  					"key2": {
    96  						"key2_1": "val2_1",
    97  						"key2_2": {
    98  							"key2_2_1": "val2_2_1"
    99  						}
   100  					},
   101  					"key3": 123
   102  				 }]`))
   103  				if err != nil {
   104  					assert.NoError(t, fmt.Errorf("Error Write %w", err))
   105  				}
   106  			})),
   107  			clientOptionFns: nil,
   108  			expected:        []map[string]any(nil),
   109  			expectedCode:    http.StatusUnauthorized,
   110  			expectedError:   errors.New("API error with status code 401: "),
   111  		},
   112  	} {
   113  		cc := c
   114  		t.Run(cc.name, func(t *testing.T) {
   115  			defer cc.fakeServer.Close()
   116  
   117  			client, err := NewClient(cc.fakeServer.URL, cc.clientOptionFns...)
   118  			require.NoError(t, err, "NewClient returned unexpected error")
   119  
   120  			req, err := client.NewRequestWithContext(t.Context(), http.MethodPost, "", cc.params)
   121  			require.NoError(t, err, "NewRequest returned unexpected error")
   122  
   123  			var data []map[string]any
   124  
   125  			resp, err := client.Do(req, &data)
   126  
   127  			if cc.expectedError != nil {
   128  				assert.EqualError(t, err, cc.expectedError.Error())
   129  			} else {
   130  				assert.Equal(t, cc.expectedCode, resp.StatusCode)
   131  				assert.Equal(t, cc.expected, data)
   132  				assert.NoError(t, err)
   133  			}
   134  		})
   135  	}
   136  }
   137  
   138  func TestCheckResponse(t *testing.T) {
   139  	resp := &http.Response{
   140  		StatusCode: http.StatusBadRequest,
   141  		Body:       io.NopCloser(bytes.NewBufferString(`{"error":"invalid_request","description":"Invalid token"}`)),
   142  	}
   143  
   144  	err := CheckResponse(resp)
   145  	require.EqualError(t, err, "API error with status code 400: invalid_request")
   146  }