github.com/hamba/avro/v2@v2.22.1-0.20240518180522-aff3955acf7d/decoder_map_test.go (about)

     1  package avro_test
     2  
     3  import (
     4  	"bytes"
     5  	"errors"
     6  	"strconv"
     7  	"testing"
     8  
     9  	"github.com/hamba/avro/v2"
    10  	"github.com/stretchr/testify/assert"
    11  	"github.com/stretchr/testify/require"
    12  )
    13  
    14  func TestDecoder_MapInvalidType(t *testing.T) {
    15  	defer ConfigTeardown()
    16  
    17  	data := []byte{0x02, 0x06, 0x66, 0x6F, 0x6F, 0x06, 0x66, 0x6F, 0x6F, 0x00}
    18  	schema := `{"type":"map", "values": "string"}`
    19  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
    20  	require.NoError(t, err)
    21  
    22  	var str string
    23  	err = dec.Decode(&str)
    24  
    25  	assert.Error(t, err)
    26  }
    27  
    28  func TestDecoder_MapMap(t *testing.T) {
    29  	defer ConfigTeardown()
    30  
    31  	data := []byte{0x02, 0x06, 0x66, 0x6F, 0x6F, 0x06, 0x66, 0x6F, 0x6F, 0x00}
    32  	schema := `{"type":"map", "values": "string"}`
    33  	dec, _ := avro.NewDecoder(schema, bytes.NewReader(data))
    34  
    35  	var got map[string]string
    36  	err := dec.Decode(&got)
    37  
    38  	require.NoError(t, err)
    39  	assert.Equal(t, map[string]string{"foo": "foo"}, got)
    40  }
    41  
    42  func TestDecoder_MapMapShortRead(t *testing.T) {
    43  	defer ConfigTeardown()
    44  
    45  	data := []byte{0x02, 0x06, 0x66, 0x6F, 0x6F, 0x06, 0x06}
    46  	schema := `{"type":"map", "values": "string"}`
    47  	dec, _ := avro.NewDecoder(schema, bytes.NewReader(data))
    48  
    49  	var got map[string]string
    50  	err := dec.Decode(&got)
    51  
    52  	assert.Error(t, err)
    53  }
    54  
    55  func TestDecoder_MapMapOfStruct(t *testing.T) {
    56  	defer ConfigTeardown()
    57  
    58  	data := []byte{0x02, 0x06, 0x66, 0x6F, 0x6F, 0x36, 0x06, 0x66, 0x6f, 0x6f, 0x0}
    59  	schema := `{"type":"map", "values": {"type": "record", "name": "test", "fields" : [{"name": "a", "type": "long"}, {"name": "b", "type": "string"}]}}`
    60  	dec, _ := avro.NewDecoder(schema, bytes.NewReader(data))
    61  
    62  	var got map[string]TestRecord
    63  	err := dec.Decode(&got)
    64  
    65  	require.NoError(t, err)
    66  	assert.Equal(t, map[string]TestRecord{"foo": {A: 27, B: "foo"}}, got)
    67  }
    68  
    69  func TestDecoder_MapMapError(t *testing.T) {
    70  	defer ConfigTeardown()
    71  
    72  	data := []byte{0xE2, 0xA2, 0xF3, 0xAD, 0xAD, 0xAD, 0xE2, 0xA2, 0xF3, 0xAD, 0xAD}
    73  	schema := `{"type":"map", "values": "string"}`
    74  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
    75  	require.NoError(t, err)
    76  
    77  	var got map[string]string
    78  	err = dec.Decode(&got)
    79  
    80  	assert.Error(t, err)
    81  }
    82  
    83  type textUnmarshallerInt int
    84  
    85  func (t *textUnmarshallerInt) UnmarshalText(text []byte) error {
    86  	i, err := strconv.Atoi(string(text))
    87  	if err != nil {
    88  		return err
    89  	}
    90  	*t = textUnmarshallerInt(i)
    91  	return nil
    92  }
    93  
    94  func TestDecoder_MapUnmarshallerMap(t *testing.T) {
    95  	defer ConfigTeardown()
    96  
    97  	data := []byte{0x1, 0xe, 0x2, 0x31, 0x8, 0x74, 0x65, 0x73, 0x74, 0x0}
    98  	schema := `{"type":"map", "values": "string"}`
    99  	dec, _ := avro.NewDecoder(schema, bytes.NewReader(data))
   100  
   101  	var got map[*textUnmarshallerInt]string
   102  	err := dec.Decode(&got)
   103  
   104  	require.NoError(t, err)
   105  	want := map[textUnmarshallerInt]string{1: "test"}
   106  	for k, v := range got {
   107  		wantVal, ok := want[*k]
   108  		assert.True(t, ok)
   109  		assert.Equal(t, wantVal, v)
   110  	}
   111  }
   112  
   113  type textUnmarshallerNope int
   114  
   115  func (t textUnmarshallerNope) UnmarshalText(text []byte) error {
   116  	i, err := strconv.Atoi(string(text))
   117  	if err != nil {
   118  		return err
   119  	}
   120  	t = textUnmarshallerNope(i)
   121  	return nil
   122  }
   123  
   124  func TestDecoder_MapUnmarshallerMapImpossible(t *testing.T) {
   125  	defer ConfigTeardown()
   126  
   127  	data := []byte{0x1, 0xe, 0x2, 0x31, 0x8, 0x74, 0x65, 0x73, 0x74, 0x0}
   128  	schema := `{"type":"map", "values": "string"}`
   129  	dec, _ := avro.NewDecoder(schema, bytes.NewReader(data))
   130  
   131  	var got map[textUnmarshallerNope]string
   132  	err := dec.Decode(&got)
   133  
   134  	require.NoError(t, err)
   135  	want := map[textUnmarshallerNope]string{0: "test"}
   136  	assert.Equal(t, want, got)
   137  }
   138  
   139  type textUnmarshallerError int
   140  
   141  func (t *textUnmarshallerError) UnmarshalText(text []byte) error {
   142  	return errors.New("test")
   143  }
   144  
   145  func TestDecoder_MapUnmarshallerKeyError(t *testing.T) {
   146  	defer ConfigTeardown()
   147  
   148  	data := []byte{0x1, 0xe, 0x2, 0x31, 0x8, 0x74, 0x65, 0x73, 0x74, 0x0}
   149  	schema := `{"type":"map", "values": "string"}`
   150  	dec, _ := avro.NewDecoder(schema, bytes.NewReader(data))
   151  
   152  	var got map[*textUnmarshallerError]string
   153  	err := dec.Decode(&got)
   154  
   155  	require.Error(t, err)
   156  }
   157  
   158  func TestDecoder_MapInvalidKeyType(t *testing.T) {
   159  	defer ConfigTeardown()
   160  
   161  	data := []byte{0x02, 0x06, 0x66, 0x6F, 0x6F, 0x06, 0x66, 0x6F, 0x6F, 0x00}
   162  	schema := `{"type":"map", "values": "string"}`
   163  	dec, _ := avro.NewDecoder(schema, bytes.NewReader(data))
   164  
   165  	var got map[int]string
   166  	err := dec.Decode(&got)
   167  
   168  	assert.Error(t, err)
   169  }