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

     1  package avro_test
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"math"
     7  	"math/big"
     8  	"testing"
     9  
    10  	"github.com/hamba/avro/v2"
    11  	"github.com/stretchr/testify/assert"
    12  	"github.com/stretchr/testify/require"
    13  )
    14  
    15  func TestEncoder_FixedInvalidType(t *testing.T) {
    16  	defer ConfigTeardown()
    17  
    18  	schema := `{"type":"fixed", "name": "test", "size": 6}`
    19  	buf := bytes.NewBuffer([]byte{})
    20  	enc, err := avro.NewEncoder(schema, buf)
    21  	require.NoError(t, err)
    22  
    23  	err = enc.Encode([6]int{})
    24  
    25  	assert.Error(t, err)
    26  }
    27  
    28  func TestEncoder_Fixed(t *testing.T) {
    29  	defer ConfigTeardown()
    30  
    31  	schema := `{"type":"fixed", "name": "test", "size": 6}`
    32  	buf := bytes.NewBuffer([]byte{})
    33  	enc, err := avro.NewEncoder(schema, buf)
    34  	require.NoError(t, err)
    35  
    36  	err = enc.Encode([6]byte{'f', 'o', 'o', 'f', 'o', 'o'})
    37  
    38  	require.NoError(t, err)
    39  	assert.Equal(t, []byte{0x66, 0x6F, 0x6F, 0x66, 0x6F, 0x6F}, buf.Bytes())
    40  }
    41  
    42  func TestEncoder_FixedRat_Positive(t *testing.T) {
    43  	defer ConfigTeardown()
    44  
    45  	schema := `{"type":"fixed", "name": "test", "size": 6,"logicalType":"decimal","precision":4,"scale":2}`
    46  	buf := bytes.NewBuffer([]byte{})
    47  	enc, err := avro.NewEncoder(schema, buf)
    48  	require.NoError(t, err)
    49  
    50  	err = enc.Encode(big.NewRat(1734, 5))
    51  
    52  	require.NoError(t, err)
    53  	assert.Equal(t, []byte{0x00, 0x00, 0x00, 0x00, 0x87, 0x78}, buf.Bytes())
    54  }
    55  
    56  func TestEncoder_FixedRat_Negative(t *testing.T) {
    57  	defer ConfigTeardown()
    58  
    59  	schema := `{"type":"fixed", "name": "test", "size": 6, "logicalType":"decimal","precision":4,"scale":2}`
    60  	buf := bytes.NewBuffer([]byte{})
    61  	enc, err := avro.NewEncoder(schema, buf)
    62  	require.NoError(t, err)
    63  
    64  	err = enc.Encode(big.NewRat(-1734, 5))
    65  
    66  	require.NoError(t, err)
    67  	assert.Equal(t, []byte{0xFF, 0xFF, 0xFF, 0xFF, 0x78, 0x88}, buf.Bytes())
    68  }
    69  
    70  func TestEncoder_FixedRat_Zero(t *testing.T) {
    71  	defer ConfigTeardown()
    72  
    73  	schema := `{"type":"fixed", "name": "test", "size": 6,"logicalType":"decimal","precision":4,"scale":2}`
    74  	buf := bytes.NewBuffer([]byte{})
    75  	enc, err := avro.NewEncoder(schema, buf)
    76  	require.NoError(t, err)
    77  
    78  	err = enc.Encode(big.NewRat(0, 1))
    79  
    80  	require.NoError(t, err)
    81  	assert.Equal(t, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, buf.Bytes())
    82  }
    83  
    84  func TestEncoder_FixedRatInvalidLogicalSchema(t *testing.T) {
    85  	defer ConfigTeardown()
    86  
    87  	schema := `{"type":"fixed", "name": "test", "size": 6}`
    88  	buf := bytes.NewBuffer([]byte{})
    89  	enc, err := avro.NewEncoder(schema, buf)
    90  	require.NoError(t, err)
    91  
    92  	err = enc.Encode(big.NewRat(1734, 5))
    93  
    94  	assert.Error(t, err)
    95  }
    96  
    97  func TestEncoder_FixedLogicalDuration(t *testing.T) {
    98  	defer ConfigTeardown()
    99  
   100  	schema := `{"name":"foo","type":"fixed","logicalType":"duration","size":12}`
   101  	buf := bytes.NewBuffer([]byte{})
   102  	enc, err := avro.NewEncoder(schema, buf)
   103  	require.NoError(t, err)
   104  
   105  	duration := avro.LogicalDuration{Months: 12, Days: 34, Milliseconds: 567890}
   106  	err = enc.Encode(duration)
   107  
   108  	require.NoError(t, err)
   109  	assert.Equal(t, []byte{0xc, 0x0, 0x0, 0x0, 0x22, 0x0, 0x0, 0x0, 0x52, 0xaa, 0x8, 0x0}, buf.Bytes())
   110  }
   111  
   112  func TestEncoder_FixedLogicalDurationSizeNot12(t *testing.T) {
   113  	defer ConfigTeardown()
   114  
   115  	schema := `{"name":"foo","type":"fixed","logicalType":"duration","size":11}`
   116  	buf := bytes.NewBuffer([]byte{})
   117  	enc, err := avro.NewEncoder(schema, buf)
   118  	require.NoError(t, err)
   119  
   120  	duration := avro.LogicalDuration{}
   121  	err = enc.Encode(duration)
   122  	assert.Error(t, err)
   123  	assert.Equal(t, fmt.Errorf("avro: avro.LogicalDuration is unsupported for Avro fixed, size=11"), err)
   124  }
   125  
   126  func TestEncoder_FixedUint64_Full(t *testing.T) {
   127  	defer ConfigTeardown()
   128  
   129  	schema := `{"type":"fixed", "name": "test", "size": 8}`
   130  	buf := bytes.NewBuffer([]byte{})
   131  	enc, err := avro.NewEncoder(schema, buf)
   132  	require.NoError(t, err)
   133  
   134  	err = enc.Encode(uint64(math.MaxUint64))
   135  
   136  	require.NoError(t, err)
   137  	assert.Equal(t, []byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, buf.Bytes())
   138  }
   139  
   140  func TestEncoder_FixedUint64_Small(t *testing.T) {
   141  	defer ConfigTeardown()
   142  
   143  	schema := `{"type":"fixed", "name": "test", "size": 8}`
   144  	buf := bytes.NewBuffer([]byte{})
   145  	enc, err := avro.NewEncoder(schema, buf)
   146  	require.NoError(t, err)
   147  
   148  	err = enc.Encode(uint64(256))
   149  
   150  	require.NoError(t, err)
   151  	assert.Equal(t, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00}, buf.Bytes())
   152  }