Add tests for type bytes

config/type_bytes.go

 )
 
 type TypeBytes struct {
-	value uint
+	value units.Base2Bytes
 }
 
 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)
 	}
 		return fmt.Errorf("%d should be positive number", value)
 	}
 
-	c.value = uint(value)
+	c.value = value
 
 	return nil
 }
 }
 
 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 {
 		return defaultValue
 	}
 
-	return c.value
+	return uint(c.value)
 }

config/type_bytes_test.go

+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{})
+}

mtglib/network/proxy_dialer_internal_test.go

 package network
 
 import (
-	"fmt"
 	"net/url"
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
 
 
 	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)
 		})
 	}
 }
 
 	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)
 		})
 	}
 }
 
 	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)
 		})
 	}
 }

mtglib/secret_test.go

 	"testing"
 
 	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
 
 		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)
 		})
 	}
 }
 		suite.T().Run(param, func(t *testing.T) {
 			_, err := mtglib.ParseSecret(param)
 
-			suite.Error(err)
+			assert.Error(t, err)
 		})
 	}
 }