github.com/GuanceCloud/cliutils@v1.1.21/pipeline/ptinput/funcs/fn_http_request_test.go (about)

     1  package funcs
     2  
     3  import (
     4  	"encoding/json"
     5  	"errors"
     6  	"fmt"
     7  	"io"
     8  	"net/http"
     9  	"net/http/httptest"
    10  	"testing"
    11  	"time"
    12  
    13  	"github.com/GuanceCloud/cliutils/pipeline/ptinput"
    14  	"github.com/GuanceCloud/cliutils/point"
    15  	"github.com/stretchr/testify/assert"
    16  )
    17  
    18  func TestBuildBody(t *testing.T) {
    19  	cases := []struct {
    20  		val    any
    21  		result string
    22  	}{
    23  		{
    24  			val:    float64(123.1),
    25  			result: "123.1",
    26  		},
    27  		{
    28  			val:    int64(123),
    29  			result: "123",
    30  		},
    31  		{
    32  			val:    true,
    33  			result: "true",
    34  		},
    35  		{
    36  			val:    false,
    37  			result: "false",
    38  		},
    39  		{
    40  			val:    "abc",
    41  			result: "abc",
    42  		},
    43  		{
    44  			val:    []any{1, 2, 3},
    45  			result: "[1,2,3]",
    46  		},
    47  		{
    48  			val:    map[string]any{"a": 1, "b": 2},
    49  			result: `{"a":1,"b":2}`,
    50  		},
    51  		{
    52  			val:    nil,
    53  			result: "",
    54  		},
    55  	}
    56  
    57  	for i, c := range cases {
    58  		t.Run(fmt.Sprintf("index_%d", i), func(t *testing.T) {
    59  			var buf []byte
    60  			if b := buildBody(c.val); b != nil {
    61  				var err error
    62  				buf, err = io.ReadAll(b)
    63  				if err != nil && !errors.Is(err, io.EOF) {
    64  					t.Error(err)
    65  				}
    66  			}
    67  			assert.Equal(t, c.result, string(buf))
    68  		})
    69  	}
    70  }
    71  
    72  func TestHTTPRequest(t *testing.T) {
    73  	server := HTTPServer()
    74  	defer server.Close()
    75  
    76  	url := `"` + server.URL + "/testResp" + `"`
    77  	fmt.Println(url)
    78  
    79  	cases := []struct {
    80  		name, pl, in string
    81  		expected     interface{}
    82  		fail         bool
    83  		outkey       string
    84  	}{
    85  		{
    86  			name: "test_post",
    87  			pl: fmt.Sprintf(`
    88  			resp = http_request("POST", %s, {"extraHeader": "1", 
    89  			"extraHeader": "1"}, {"a": "1"})
    90  			add_key(abc, resp["body"])	
    91  			`, url),
    92  			in:       `[]`,
    93  			outkey:   "abc",
    94  			expected: `{"a":"1"}`,
    95  		},
    96  		{
    97  			name: "test_put",
    98  			pl: fmt.Sprintf(`
    99  			resp = http_request("put", %s, {"extraHeader": "1", 
   100  			"extraHeader": "1"}, {"a": "1"})
   101  			add_key(abc, resp["body"])	
   102  			`, url),
   103  			in:       `[]`,
   104  			outkey:   "abc",
   105  			expected: `{"a":"1"}`,
   106  		},
   107  	}
   108  
   109  	for idx, tc := range cases {
   110  		t.Run(tc.name, func(t *testing.T) {
   111  			runner, err := NewTestingRunner(tc.pl)
   112  			if err != nil {
   113  				if tc.fail {
   114  					t.Logf("[%d]expect error: %s", idx, err)
   115  				} else {
   116  					t.Errorf("[%d] failed: %s", idx, err)
   117  				}
   118  				return
   119  			}
   120  			pt := ptinput.NewPlPoint(
   121  				point.Logging, "test", nil, map[string]any{"message": tc.in}, time.Now())
   122  			errR := runScript(runner, pt)
   123  
   124  			if errR != nil {
   125  				t.Fatal(errR.Error())
   126  			}
   127  
   128  			v, _, _ := pt.Get(tc.outkey)
   129  			// tu.Equals(t, nil, err)
   130  			assert.Equal(t, tc.expected, v)
   131  
   132  			t.Logf("[%d] PASS", idx)
   133  		})
   134  	}
   135  }
   136  
   137  func HTTPServer() *httptest.Server {
   138  	server := httptest.NewServer(http.HandlerFunc(
   139  		func(w http.ResponseWriter, r *http.Request) {
   140  			headers := r.Header
   141  
   142  			var respData []byte
   143  			var err error
   144  			if headers.Get("extraHeader1") != "" && headers.Get("extraHeader2") != "" {
   145  				responseData := map[string]string{"a": "hello world"}
   146  				respData, err = json.Marshal(responseData)
   147  				if err != nil {
   148  					http.Error(w, "Internal Server Error", http.StatusInternalServerError)
   149  				}
   150  			} else {
   151  				switch r.Method {
   152  				case http.MethodGet:
   153  					responseData := map[string]string{"a": "hello"}
   154  					respData, err = json.Marshal(responseData)
   155  					if err != nil {
   156  						http.Error(w, "Internal Server Error", http.StatusInternalServerError)
   157  					}
   158  				default:
   159  					d, _ := io.ReadAll(r.Body)
   160  					respData = d
   161  				}
   162  			}
   163  
   164  			w.Write(respData)
   165  			w.WriteHeader(http.StatusOK)
   166  		},
   167  	))
   168  	return server
   169  }