SetResult replaces nested struct with a map inside a map

[maticmeznar]

In the provided sample code, after a successful HTTP request, result["data"] changes type from getIP to map[string]interface{}. I don't know if this is feature or a bug, but it is unexpected and annoying to use. This does not happen if the outer map is replaced with a struct.

package main

import (
	"encoding/json"
	"log"
	"net/http"
	"net/netip"

	"github.com/davecgh/go-spew/spew"
	"github.com/go-resty/resty/v2"
)

type getIP struct {
	Address string `json:"address"`
	Version int    `json:"version"`
}

const serveAddr = ":48916"

func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Add("Content-Type", "application/json")
		addr := netip.MustParseAddrPort(r.RemoteAddr).Addr().String()
		result := map[string]any{
			"data": getIP{
				Address: addr,
				Version: 4,
			},
		}

		enc := json.NewEncoder(w)
		if err := enc.Encode(result); err != nil {
			log.Fatalln(err)
		}
	})

	go func() {
		if err := http.ListenAndServe(serveAddr, nil); err != http.ErrServerClosed {
			log.Fatalf("Error starting server: %v\n", err)
		}
	}()

	result := map[string]any{
		"data": getIP{},
	}

	spew.Dump(result)

	r := resty.New().R().SetResult(&result)

	httpResp, err := r.Get("http://localhost" + serveAddr)
	if err != nil {
		log.Fatalf("unable to contact service: %v\n", err)
	}

	if httpResp.IsError() {
		log.Fatalf("error contacting service: %s\n", httpResp.Status())
	}

	spew.Dump(result)
}

[kecci]

Hi @maticmeznar

I trace the result is depends on the JSONUnmarshaler.

The resty client are set the default of JSONUnmarshaler using "encoding/json".

To unmarshal JSON into an interface value, Unmarshal stores one of these in the interface value:

...
map[string]interface{}, for JSON objects
...

Refer to the official documentation on Unmarshal() for more information.

Reproduce

To make this clarify we tried to reproduce.

1. Reproduce without the json unmarshal.

...
r := resty.New().SetJSONUnmarshaler(func(data []byte, v interface{}) error {
		return nil
	}).R().SetResult(&result)
...

Dump result without json unmarshal:

(map[string]interface {}) (len=1) {
 (string) (len=4) "data": (main.getIP) {
  Address: (string) "",
  Version: (int) 0
 }
}
(map[string]interface {}) (len=1) {
 (string) (len=4) "data": (main.getIP) {
  Address: (string) "",
  Version: (int) 0
 }
}

2. Reproduce with the json unmarshal.

...
r := resty.New().SetJSONUnmarshaler(func(data []byte, v interface{}) error {
		return json.Unmarshal(data, &v)
	}).R().SetResult(&result)
...

Dump result with json unmarshal:

(map[string]interface {}) (len=1) {
 (string) (len=4) "data": (main.getIP) {
  Address: (string) "",
  Version: (int) 0
 }
}
(map[string]interface {}) (len=1) {
 (string) (len=4) "data": (map[string]interface {}) (len=2) {
  (string) (len=7) "address": (string) (len=3) "::1",
  (string) (len=7) "version": (float64) 4
 }

Conclusion

The result is depends on JSONUnmarshaler.
For now, you could set to more suitable unmarshaler (if you have).

However, I think your concerns could be input for other unmarshaler options. Both from internal and external packages.

Could we consider this ? @jeevatkm

[jeevatkm]

@maticmeznar Thanks for reaching out.
I don't know if this expected result could be achieved the way it is. You could try to define a custom type for the outer map.

@kecci Thanks for responding to the comment. Could you explain what to consider? I'm unable to understand.