Function TestEncodeObjectWithKeys

encode_object_test.go:573–732

(t *testing.T)

func (n *NilObject) IsNil() bool                    { return true }

func TestEncodeObjectWithKeys(t *testing.T) {
	t.Run(
		"should not encode any key",
		func(t *testing.T) {
			var b strings.Builder
			var enc = NewEncoder(&b)
			var o = &ObjectWithKeys{}
			var err = enc.EncodeObjectKeys(o, []string{})
			assert.Nil(t, err)
			assert.Equal(t, `{}`, b.String())
		},
	)
	t.Run(
		"should encode some keys",
		func(t *testing.T) {
			var b strings.Builder
			var enc = NewEncoder(&b)
			var o = &ObjectWithKeys{Str: "hello", Int: 420}
			var err = enc.EncodeObjectKeys(o, []string{"string", "int"})
			assert.Nil(t, err)
			assert.Equal(
				t,
				`{"string":"hello","string":"hello","string":"hello","int":420,"int":420,"int":420}`,
				b.String(),
			)
		},
	)
	t.Run("write-error", func(t *testing.T) {
		w := TestWriterError("")
		enc := NewEncoder(w)
		o := &ObjectWithKeys{Str: "hello", Int: 420}
		err := enc.EncodeObjectKeys(o, []string{"string", "int"})
		assert.NotNil(t, err, "Error should not be nil")
		assert.Equal(t, "Test Error", err.Error(), "err.Error() should be 'Test Error'")
	})
	t.Run("pool-error", func(t *testing.T) {
		v := &TestEncoding{}
		enc := BorrowEncoder(nil)
		enc.isPooled = 1
		defer func() {
			err := recover()
			assert.NotNil(t, err, "err shouldnt be nil")
			assert.IsType(t, InvalidUsagePooledEncoderError(""), err, "err should be of type InvalidUsagePooledEncoderError")
			assert.Equal(t, "Invalid usage of pooled encoder", err.(InvalidUsagePooledEncoderError).Error(), "err should be of type InvalidUsagePooledDecoderError")
		}()
		_ = enc.EncodeObjectKeys(v, []string{})
		assert.True(t, false, "should not be called as it should have panicked")
	})
	t.Run("interface-key-error", func(t *testing.T) {
		builder := &strings.Builder{}
		enc := NewEncoder(builder)
		err := enc.EncodeObjectKeys(&testObjectWithUnknownType{struct{}{}}, []string{})
		assert.NotNil(t, err, "Error should not be nil")
		assert.Equal(t, "Invalid type struct {} provided to Marshal", err.Error(), "err.Error() should be 'Invalid type struct {} provided to Marshal'")
	})
	t.Run("encode-object-with-keys", func(t *testing.T) {
		b := &strings.Builder{}
		enc := NewEncoder(b)