github.com/opentelekomcloud/gophertelekomcloud@v0.9.3/internal/build/request_body_test.go (about)

     1  package build
     2  
     3  import (
     4  	"encoding/json"
     5  	"testing"
     6  
     7  	"github.com/opentelekomcloud/gophertelekomcloud/openstack/common/pointerto"
     8  	"github.com/stretchr/testify/require"
     9  )
    10  
    11  type testStruct struct {
    12  	Data string `json:"data"`
    13  }
    14  
    15  type testStructWPtr struct {
    16  	Data *string `json:"data"`
    17  }
    18  
    19  func TestRequestBody_MarshalJSON(t *testing.T) {
    20  	t.Parallel()
    21  
    22  	cases := map[string]struct {
    23  		body     Body
    24  		expected string
    25  	}{
    26  		"int_slice": {
    27  			Body{
    28  				Wrapped: []int{1, 2, 3},
    29  			},
    30  			"[1, 2, 3]",
    31  		},
    32  		"int_slice_wrapped": {
    33  			Body{
    34  				RootTag: "items",
    35  				Wrapped: []int{1, 2, 3},
    36  			},
    37  			`{"items": [1, 2, 3]}`,
    38  		},
    39  		"struct": {
    40  			Body{
    41  				RootTag: "",
    42  				Wrapped: &testStruct{Data: "123"},
    43  			},
    44  			`{"data": "123"}`,
    45  		},
    46  		"struct_wrapped": {
    47  			Body{
    48  				RootTag: "root",
    49  				Wrapped: &testStruct{Data: "123"},
    50  			},
    51  			`{"root": {"data": "123"}}`,
    52  		},
    53  		"struct_w_pointer_field": {
    54  			Body{
    55  				RootTag: "",
    56  				Wrapped: testStructWPtr{Data: pointerto.String("123")},
    57  			},
    58  			`{"data": "123"}`,
    59  		},
    60  		"struct_w_pointer_field_wrapped": {
    61  			Body{
    62  				RootTag: "root",
    63  				Wrapped: testStructWPtr{Data: pointerto.String("123")},
    64  			},
    65  			`{"root": {"data": "123"}}`,
    66  		},
    67  	}
    68  
    69  	for name, data := range cases {
    70  		data := data
    71  
    72  		t.Run(name, func(t *testing.T) {
    73  			t.Parallel()
    74  
    75  			actual, err := json.Marshal(data.body)
    76  			require.NoError(t, err)
    77  
    78  			require.JSONEq(t, data.expected, string(actual))
    79  		})
    80  	}
    81  }
    82  
    83  func TestRequestBody_String(t *testing.T) {
    84  	t.Parallel()
    85  
    86  	cases := map[string]struct {
    87  		requestBody Body
    88  		expected    string
    89  	}{
    90  		"simple": {
    91  			Body{Wrapped: "data"},
    92  			`"data"`,
    93  		},
    94  		"with_parent": {
    95  			Body{Wrapped: "data", RootTag: "root"},
    96  			`{
    97    "root": "data"
    98  }`,
    99  		},
   100  	}
   101  
   102  	for name, data := range cases {
   103  		data := data
   104  
   105  		t.Run(name, func(t *testing.T) {
   106  			t.Parallel()
   107  
   108  			require.Equal(t, data.expected, data.requestBody.String())
   109  		})
   110  	}
   111  }
   112  
   113  func TestRequestBody_String_Err(t *testing.T) {
   114  	t.Parallel()
   115  
   116  	body := Body{Wrapped: complex(float64(1), float64(2))}
   117  	require.Equal(t, "!err: json: unsupported type: complex128", body.String())
   118  }
   119  
   120  func TestBuildRequestBody(t *testing.T) {
   121  	t.Parallel()
   122  
   123  	t.Run("ok", func(t *testing.T) {
   124  		source := testStruct{"data"}
   125  
   126  		expected := &Body{
   127  			Wrapped: source,
   128  		}
   129  
   130  		actual, err := RequestBody(source, "")
   131  		require.NoError(t, err)
   132  		require.EqualValues(t, expected, actual)
   133  	})
   134  
   135  	t.Run("validation_fail", func(t *testing.T) {
   136  		source := testStructRequired{}
   137  
   138  		_, err := RequestBody(source, "")
   139  		require.EqualError(t, err, "error building request body: missing input for argument [Field]")
   140  	})
   141  
   142  	t.Run("nil_body", func(t *testing.T) {
   143  		_, err := RequestBody(nil, "")
   144  		require.EqualError(t, err, "error building request body: nil options provided")
   145  	})
   146  }