From bc4b14c83d70b8af0050cb20a3e209d255a6e97c Mon Sep 17 00:00:00 2001 From: 9seconds Date: Thu, 11 Mar 2021 16:33:29 +0300 Subject: [PATCH] Add tests for type bytes --- config/type_bytes.go | 13 ++- config/type_bytes_test.go | 114 +++++++++++++++++++ mtglib/network/proxy_dialer_internal_test.go | 14 +-- mtglib/secret_test.go | 16 +-- 4 files changed, 137 insertions(+), 20 deletions(-) create mode 100644 config/type_bytes_test.go diff --git a/config/type_bytes.go b/config/type_bytes.go index 49d0b06..deed46e 100644 --- a/config/type_bytes.go +++ b/config/type_bytes.go @@ -8,7 +8,7 @@ import ( ) type TypeBytes struct { - value uint + value units.Base2Bytes } func (c *TypeBytes) UnmarshalText(data []byte) error { @@ -16,7 +16,10 @@ func (c *TypeBytes) UnmarshalText(data []byte) error { return nil } - value, err := units.ParseStrictBytes(strings.ToUpper(string(data))) + normalizedData := strings.ToUpper(string(data)) + normalizedData = strings.ReplaceAll(normalizedData, "IB", "iB") + + value, err := units.ParseBase2Bytes(normalizedData) if err != nil { return fmt.Errorf("incorrect bytes value: %w", err) } @@ -25,7 +28,7 @@ func (c *TypeBytes) UnmarshalText(data []byte) error { return fmt.Errorf("%d should be positive number", value) } - c.value = uint(value) + c.value = value return nil } @@ -35,7 +38,7 @@ func (c TypeBytes) MarshalText() ([]byte, error) { } func (c TypeBytes) String() string { - return units.ToString(int64(c.value), 1024, "ib", "b") + return strings.ToLower(c.value.String()) } func (c TypeBytes) Value(defaultValue uint) uint { @@ -43,5 +46,5 @@ func (c TypeBytes) Value(defaultValue uint) uint { return defaultValue } - return c.value + return uint(c.value) } diff --git a/config/type_bytes_test.go b/config/type_bytes_test.go new file mode 100644 index 0000000..15428fb --- /dev/null +++ b/config/type_bytes_test.go @@ -0,0 +1,114 @@ +package config_test + +import ( + "encoding/json" + "testing" + + "github.com/9seconds/mtg/v2/config" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" +) + +type typeBytesTestStruct struct { + Value config.TypeBytes `json:"value"` +} + +type TypeBytesTestSuite struct { + suite.Suite +} + +func (suite *TypeBytesTestSuite) TestUnmarshalFail() { + testData := []string{ + "1m", + "1", + "-1kb", + "-1kib", + "-1QB", + } + + for _, v := range testData { + data, err := json.Marshal(map[string]string{ + "value": v, + }) + suite.NoError(err) + + suite.T().Run(v, func(t *testing.T) { + assert.Error(t, json.Unmarshal(data, &typeBytesTestStruct{})) + }) + } +} + +func (suite *TypeBytesTestSuite) TestUnmarshalOk() { + testData := map[string]uint{ + "1b": 1, + "1kb": 1024, + "1kib": 1024, + "2mb": 2 * 1024 * 1024, + "2mib": 2 * 1024 * 1024, + } + + for k, v := range testData { + value := v + + data, err := json.Marshal(map[string]string{ + "value": k, + }) + suite.NoError(err) + + suite.T().Run(k, func(t *testing.T) { + testStruct := &typeBytesTestStruct{} + + assert.NoError(t, json.Unmarshal(data, testStruct)) + assert.Equal(t, int(value), int(testStruct.Value.Value(0))) + }) + } +} + +func (suite *TypeBytesTestSuite) TestMarshalOk() { + testData := []string{ + "1b", + "1kib", + "2mib", + } + + for _, v := range testData { + name := v + + data, err := json.Marshal(map[string]string{ + "value": name, + }) + suite.NoError(err) + + suite.T().Run(name, func(t *testing.T) { + testStruct := &typeBytesTestStruct{} + + assert.NoError(t, json.Unmarshal(data, testStruct)) + assert.Equal(t, name, testStruct.Value.String()) + + marshalled, err := testStruct.Value.MarshalText() + assert.NoError(t, err) + assert.Equal(t, string(marshalled), name) + }) + } +} + +func (suite *TypeBytesTestSuite) TestValue() { + testStruct := &typeBytesTestStruct{} + + suite.EqualValues(0, testStruct.Value.Value(0)) + suite.EqualValues(1, testStruct.Value.Value(1)) + + data, err := json.Marshal(map[string]string{ + "value": "1kb", + }) + suite.NoError(err) + suite.NoError(json.Unmarshal(data, testStruct)) + + suite.EqualValues(1024, testStruct.Value.Value(0)) + suite.EqualValues(1024, testStruct.Value.Value(1)) +} + +func TestTypeBytes(t *testing.T) { + t.Parallel() + suite.Run(t, &TypeBytesTestSuite{}) +} diff --git a/mtglib/network/proxy_dialer_internal_test.go b/mtglib/network/proxy_dialer_internal_test.go index 1183908..1c4f4cc 100644 --- a/mtglib/network/proxy_dialer_internal_test.go +++ b/mtglib/network/proxy_dialer_internal_test.go @@ -1,11 +1,11 @@ package network import ( - "fmt" "net/url" "testing" "time" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/suite" ) @@ -49,13 +49,13 @@ func (suite *ProxyDialerTestSuite) TestOpenThreshold() { for _, v := range params { param := v - suite.T().Run(fmt.Sprintf("param=%s", v), func(t *testing.T) { + suite.T().Run(v, func(t *testing.T) { query.Set("open_threshold", param) suite.u.RawQuery = query.Encode() d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer) - suite.EqualValues(ProxyDialerOpenThreshold, d.openThreshold) + assert.EqualValues(t, ProxyDialerOpenThreshold, d.openThreshold) }) } } @@ -66,13 +66,13 @@ func (suite *ProxyDialerTestSuite) TestHalfOpenTimeout() { for _, v := range params { param := v - suite.T().Run(fmt.Sprintf("param=%s", v), func(t *testing.T) { + suite.T().Run(v, func(t *testing.T) { query.Set("half_open_timeout", param) suite.u.RawQuery = query.Encode() d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer) - suite.EqualValues(ProxyDialerHalfOpenTimeout, d.halfOpenTimeout) + assert.EqualValues(t, ProxyDialerHalfOpenTimeout, d.halfOpenTimeout) }) } } @@ -83,13 +83,13 @@ func (suite *ProxyDialerTestSuite) TestResetFailuresTimeout() { for _, v := range params { param := v - suite.T().Run(fmt.Sprintf("param=%s", v), func(t *testing.T) { + suite.T().Run(v, func(t *testing.T) { query.Set("reset_failures_timeout", param) suite.u.RawQuery = query.Encode() d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer) - suite.EqualValues(ProxyDialerHalfOpenTimeout, d.halfOpenTimeout) + assert.EqualValues(t, ProxyDialerHalfOpenTimeout, d.halfOpenTimeout) }) } } diff --git a/mtglib/secret_test.go b/mtglib/secret_test.go index 568abf8..2019d7e 100644 --- a/mtglib/secret_test.go +++ b/mtglib/secret_test.go @@ -6,6 +6,7 @@ import ( "testing" "github.com/9seconds/mtg/v2/mtglib" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/suite" ) @@ -32,16 +33,15 @@ func (suite *SecretTestSuite) TestParseSecret() { suite.T().Run(name, func(t *testing.T) { parsed, err := mtglib.ParseSecret(param) - suite.NoError(err) - suite.Equal(s.Key, parsed.Key) - suite.Equal(s.Host, parsed.Host) + assert.NoError(t, err) + assert.Equal(t, s.Key, parsed.Key) + assert.Equal(t, s.Host, parsed.Host) newSecret := mtglib.Secret{} - suite.NoError(newSecret.UnmarshalText([]byte(param))) - - suite.Equal(s.Key, newSecret.Key) - suite.Equal(s.Host, newSecret.Host) + assert.NoError(t, newSecret.UnmarshalText([]byte(param))) + assert.Equal(t, s.Key, newSecret.Key) + assert.Equal(t, s.Host, newSecret.Host) }) } } @@ -88,7 +88,7 @@ func (suite *SecretTestSuite) TestIncorrectSecret() { suite.T().Run(param, func(t *testing.T) { _, err := mtglib.ParseSecret(param) - suite.Error(err) + assert.Error(t, err) }) } }