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

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