ScuroNeko/mtg
1
0
Fork 0
mirror of https://github.com/ScuroNeko/mtg.git synced 2026-08-31 18:24:02 +03:00
Code Issues Packages Projects Releases Wiki Activity

Move config2 into config

Browse Source
This commit is contained in:
9seconds
2021-07-29 16:21:22 +03:00
parent ec4f0656fb
commit 87ed1d1aa7
61 changed files with 696 additions and 2955 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/config/config.go
+16 -92
View File
@@ -6,27 +6,26 @@ import (
"fmt"
"github.com/9seconds/mtg/v2/mtglib"
"github.com/pelletier/go-toml"
)
type Config struct {
Debug bool `json:"debug"`
Secret mtglib.Secret `json:"secret"`
BindTo TypeHostPort `json:"bindTo"`
TCPBuffer TypeBytes `json:"tcpBuffer"`
PreferIP TypePreferIP `json:"preferIp"`
DomainFrontingPort TypePort `json:"domainFrontingPort"`
TolerateTimeSkewness TypeDuration `json:"tolerateTimeSkewness"`
Concurrency uint `json:"concurrency"`
Debug TypeBool `json:"debug"`
Secret mtglib.Secret `json:"secret"`
BindTo TypeHostPort `json:"bindTo"`
TCPBuffer TypeBytes `json:"tcpBuffer"`
PreferIP TypePreferIP `json:"preferIp"`
DomainFrontingPort TypePort `json:"domainFrontingPort"`
TolerateTimeSkewness TypeDuration `json:"tolerateTimeSkewness"`
Concurrency TypeConcurrency `json:"concurrency"`
Defense struct {
AntiReplay struct {
Enabled bool `json:"enabled"`
Enabled TypeBool `json:"enabled"`
MaxSize TypeBytes `json:"maxSize"`
ErrorRate TypeErrorRate `json:"errorRate"`
} `json:"antiReplay"`
Blocklist struct {
Enabled bool `json:"enabled"`
DownloadConcurrency uint `json:"downloadConcurrency"`
Enabled TypeBool `json:"enabled"`
DownloadConcurrency TypeConcurrency `json:"downloadConcurrency"`
URLs []TypeBlocklistURI `json:"urls"`
UpdateEach TypeDuration `json:"updateEach"`
} `json:"blocklist"`
@@ -37,18 +36,18 @@ type Config struct {
HTTP TypeDuration `json:"http"`
Idle TypeDuration `json:"idle"`
} `json:"timeout"`
DOHIP TypeIP `json:"dohIp"`
Proxies []TypeURL `json:"proxies"`
DOHIP TypeIP `json:"dohIp"`
Proxies []TypeProxyURL `json:"proxies"`
} `json:"network"`
Stats struct {
StatsD struct {
Enabled bool `json:"enabled"`
Enabled TypeBool `json:"enabled"`
Address TypeHostPort `json:"address"`
MetricPrefix TypeMetricPrefix `json:"metricPrefix"`
TagFormat TypeStatsdTagFormat `json:"tagFormat"`
} `json:"statsd"`
Prometheus struct {
Enabled bool `json:"enabled"`
Enabled TypeBool `json:"enabled"`
BindTo TypeHostPort `json:"bindTo"`
HTTPPath TypeHTTPPath `json:"httpPath"`
MetricPrefix TypeMetricPrefix `json:"metricPrefix"`
@@ -61,7 +60,7 @@ func (c *Config) Validate() error {
return fmt.Errorf("invalid secret %s", c.Secret.String())
}
if len(c.BindTo.HostValue(nil)) == 0 || c.BindTo.PortValue(0) == 0 {
if c.BindTo.Get("") == "" {
return fmt.Errorf("incorrect bind-to parameter %s", c.BindTo.String())
}
@@ -80,78 +79,3 @@ func (c *Config) String() string {
return buf.String()
}
type configRaw struct {
Debug bool `toml:"debug" json:"debug,omitempty"`
Secret string `toml:"secret" json:"secret"`
BindTo string `toml:"bind-to" json:"bindTo"`
TCPBuffer string `toml:"tcp-buffer" json:"tcpBuffer,omitempty"`
PreferIP string `toml:"prefer-ip" json:"preferIp,omitempty"`
DomainFrontingPort uint `toml:"domain-fronting-port" json:"domainFrontingPort,omitempty"`
TolerateTimeSkewness string `toml:"tolerate-time-skewness" json:"tolerateTimeSkewness,omitempty"`
Concurrency uint `toml:"concurrency" json:"concurrency,omitempty"`
Defense struct {
AntiReplay struct {
Enabled bool `toml:"enabled" json:"enabled,omitempty"`
MaxSize string `toml:"max-size" json:"maxSize,omitempty"`
ErrorRate float64 `toml:"error-rate" json:"errorRate,omitempty"`
} `toml:"anti-replay" json:"antiReplay,omitempty"`
Blocklist struct {
Enabled bool `toml:"enabled" json:"enabled,omitempty"`
DownloadConcurrency uint `toml:"download-concurrency" json:"downloadConcurrency,omitempty"`
URLs []string `toml:"urls" json:"urls,omitempty"`
UpdateEach string `toml:"update-each" json:"updateEach,omitempty"`
} `toml:"blocklist" json:"blocklist,omitempty"`
} `toml:"defense" json:"defense,omitempty"`
Network struct {
Timeout struct {
TCP string `toml:"tcp" json:"tcp,omitempty"`
HTTP string `toml:"http" json:"http,omitempty"`
Idle string `toml:"idle" json:"idle,omitempty"`
} `toml:"timeout" json:"timeout,omitempty"`
DOHIP string `toml:"doh-ip" json:"dohIp,omitempty"`
Proxies []string `toml:"proxies" json:"proxies,omitempty"`
} `toml:"network" json:"network,omitempty"`
Stats struct {
StatsD struct {
Enabled bool `toml:"enabled" json:"enabled,omitempty"`
Address string `toml:"address" json:"address,omitempty"`
MetricPrefix string `toml:"metric-prefix" json:"metricPrefix,omitempty"`
TagFormat string `toml:"tag-format" json:"tagFormat,omitempty"`
} `toml:"statsd" json:"statsd,omitempty"`
Prometheus struct {
Enabled bool `toml:"enabled" json:"enabled,omitempty"`
BindTo string `toml:"bind-to" json:"bindTo,omitempty"`
HTTPPath string `toml:"http-path" json:"httpPath,omitempty"`
MetricPrefix string `toml:"metric-prefix" json:"metricPrefix,omitempty"`
} `toml:"prometheus" json:"prometheus,omitempty"`
} `toml:"stats" json:"stats,omitempty"`
}
func Parse(rawData []byte) (*Config, error) {
rawConf := &configRaw{}
jsonBuf := &bytes.Buffer{}
conf := &Config{}
jsonEncoder := json.NewEncoder(jsonBuf)
jsonEncoder.SetEscapeHTML(false)
jsonEncoder.SetIndent("", "")
if err := toml.Unmarshal(rawData, rawConf); err != nil {
return nil, fmt.Errorf("cannot parse toml config: %w", err)
}
if err := jsonEncoder.Encode(rawConf); err != nil {
panic(err)
}
if err := json.NewDecoder(jsonBuf).Decode(conf); err != nil {
return nil, fmt.Errorf("cannot parse a config: %w", err)
}
if err := conf.Validate(); err != nil {
return nil, fmt.Errorf("cannot validate config: %w", err)
}
return conf, nil
}
internal/config/config_test.go
+1 -1
View File
@@ -10,7 +10,7 @@ import (
)
type ConfigTestSuite struct {
suite.Suite
suite.Suite
}
func (suite *ConfigTestSuite) ReadConfig(filename string) []byte {
internal/config/parse.go
+80
View File
@@ -0,0 +1,80 @@
package config
import (
"bytes"
"encoding/json"
"fmt"
"github.com/pelletier/go-toml"
)
type tomlConfig struct {
Debug bool `toml:"debug" json:"debug,omitempty"`
Secret string `toml:"secret" json:"secret"`
BindTo string `toml:"bind-to" json:"bindTo"`
TCPBuffer string `toml:"tcp-buffer" json:"tcpBuffer,omitempty"`
PreferIP string `toml:"prefer-ip" json:"preferIp,omitempty"`
DomainFrontingPort uint `toml:"domain-fronting-port" json:"domainFrontingPort,omitempty"`
TolerateTimeSkewness string `toml:"tolerate-time-skewness" json:"tolerateTimeSkewness,omitempty"`
Concurrency uint `toml:"concurrency" json:"concurrency,omitempty"`
Defense struct {
AntiReplay struct {
Enabled bool `toml:"enabled" json:"enabled,omitempty"`
MaxSize string `toml:"max-size" json:"maxSize,omitempty"`
ErrorRate float64 `toml:"error-rate" json:"errorRate,omitempty"`
} `toml:"anti-replay" json:"antiReplay,omitempty"`
Blocklist struct {
Enabled bool `toml:"enabled" json:"enabled,omitempty"`
DownloadConcurrency uint `toml:"download-concurrency" json:"downloadConcurrency,omitempty"`
URLs []string `toml:"urls" json:"urls,omitempty"`
UpdateEach string `toml:"update-each" json:"updateEach,omitempty"`
} `toml:"blocklist" json:"blocklist,omitempty"`
} `toml:"defense" json:"defense,omitempty"`
Network struct {
Timeout struct {
TCP string `toml:"tcp" json:"tcp,omitempty"`
HTTP string `toml:"http" json:"http,omitempty"`
Idle string `toml:"idle" json:"idle,omitempty"`
} `toml:"timeout" json:"timeout,omitempty"`
DOHIP string `toml:"doh-ip" json:"dohIp,omitempty"`
Proxies []string `toml:"proxies" json:"proxies,omitempty"`
} `toml:"network" json:"network,omitempty"`
Stats struct {
StatsD struct {
Enabled bool `toml:"enabled" json:"enabled,omitempty"`
Address string `toml:"address" json:"address,omitempty"`
MetricPrefix string `toml:"metric-prefix" json:"metricPrefix,omitempty"`
TagFormat string `toml:"tag-format" json:"tagFormat,omitempty"`
} `toml:"statsd" json:"statsd,omitempty"`
Prometheus struct {
Enabled bool `toml:"enabled" json:"enabled,omitempty"`
BindTo string `toml:"bind-to" json:"bindTo,omitempty"`
HTTPPath string `toml:"http-path" json:"httpPath,omitempty"`
MetricPrefix string `toml:"metric-prefix" json:"metricPrefix,omitempty"`
} `toml:"prometheus" json:"prometheus,omitempty"`
} `toml:"stats" json:"stats,omitempty"`
}
func Parse(rawData []byte) (*Config, error) {
tomlConf := &tomlConfig{}
jsonBuf := &bytes.Buffer{}
conf := &Config{}
jsonEncoder := json.NewEncoder(jsonBuf)
jsonEncoder.SetEscapeHTML(false)
jsonEncoder.SetIndent("", "")
if err := toml.Unmarshal(rawData, tomlConf); err != nil {
return nil, fmt.Errorf("cannot parse toml config: %w", err)
}
if err := jsonEncoder.Encode(tomlConf); err != nil {
panic(err)
}
if err := json.NewDecoder(jsonBuf).Decode(conf); err != nil {
return nil, fmt.Errorf("cannot parse a config: %w", err)
}
return conf, nil
}
internal/config/type_blocklist_uri.go
+40 -31
View File
@@ -8,61 +8,70 @@ import (
)
type TypeBlocklistURI struct {
value string
Value string
}
func (c *TypeBlocklistURI) UnmarshalText(data []byte) error {
if len(data) == 0 {
return nil
}
func (t *TypeBlocklistURI) Set(value string) error {
if stat, err := os.Stat(value); err == nil || os.IsExist(err) {
switch {
case stat.IsDir():
return fmt.Errorf("value is correct filepath but directory")
case stat.Mode().Perm() & 0o400 == 0:
return fmt.Errorf("value is correct filepath but not readable")
}
text := string(data)
if filepath.IsAbs(text) {
if _, err := os.Stat(text); os.IsNotExist(err) {
return fmt.Errorf("filepath %s does not exist", text)
value, err = filepath.Abs(value)
if err != nil {
return fmt.Errorf(
"value is correct filepath but cannot resolve absolute (%s): %w",
value, err)
}
c.value = text
t.Value = value
return nil
}
parsedURL, err := url.Parse(text)
parsedURL, err := url.Parse(value)
if err != nil {
return fmt.Errorf("incorrect url: %w", err)
return fmt.Errorf("incorrect url (%s): %w", value, err)
}
switch parsedURL.Scheme {
case "http", "https": // nolint: goconst
case "http", "https":
default:
return fmt.Errorf("unknown schema %s", parsedURL.Scheme)
return fmt.Errorf("unknown schema %s (%s)", parsedURL.Scheme, value)
}
if parsedURL.Host == "" {
return fmt.Errorf("incorrect url %s", text)
return fmt.Errorf("incorrect url %s", value)
}
c.value = parsedURL.String()
t.Value = parsedURL.String()
return nil
}
func (c TypeBlocklistURI) MarshalText() ([]byte, error) {
return []byte(c.value), nil
}
func (c TypeBlocklistURI) String() string {
return c.value
}
func (c TypeBlocklistURI) IsRemote() bool {
return !filepath.IsAbs(c.value)
}
func (c TypeBlocklistURI) Value(defaultValue string) string {
if c.value == "" {
func (t TypeBlocklistURI) Get(defaultValue string) string {
if t.Value == "" {
return defaultValue
}
return c.value
return t.Value
}
func (t TypeBlocklistURI) IsRemote() bool {
return !filepath.IsAbs(t.Value)
}
func (t *TypeBlocklistURI) UnmarshalText(data []byte) error {
return t.Set(string(data))
}
func (t TypeBlocklistURI) MarshalText() ([]byte, error) {
return []byte(t.String()), nil
}
func (t TypeBlocklistURI) String() string {
return t.Value
}
internal/config/type_blocklist_uri_test.go
+42 -106
View File
@@ -1,12 +1,10 @@
package config_test
import (
"crypto/rand"
"encoding/base64"
"encoding/json"
"os"
"path/filepath"
"strconv"
"strings"
"testing"
"github.com/9seconds/mtg/v2/internal/config"
@@ -20,42 +18,28 @@ type typeBlocklistURITestStruct struct {
type TypeBlocklistURITestSuite struct {
suite.Suite
directory string
absDirectory string
}
func (suite *TypeBlocklistURITestSuite) TestUnmarshalNil() {
typ := &config.TypeBlocklistURI{}
suite.NoError(typ.UnmarshalText(nil))
suite.Empty(typ.String())
}
func (suite *TypeBlocklistURITestSuite) SetupSuite() {
dir, _ := os.Getwd()
absDir, _ := filepath.Abs(dir)
func (suite *TypeBlocklistURITestSuite) TestUnknownSchema() {
typ := &config.TypeBlocklistURI{}
suite.Error(typ.UnmarshalText([]byte("gopher://lalala")))
}
func (suite *TypeBlocklistURITestSuite) TestEmptyHost() {
typ := &config.TypeBlocklistURI{}
suite.Error(typ.UnmarshalText([]byte("https:///path")))
}
func (suite *TypeBlocklistURITestSuite) TestIncorrectURL() {
typ := &config.TypeBlocklistURI{}
suite.Error(typ.UnmarshalText([]byte("h:/--")))
suite.directory = dir
suite.absDirectory = absDir
}
func (suite *TypeBlocklistURITestSuite) TestUnmarshalFail() {
rnd := make([]byte, 48)
rand.Read(rnd) // nolint: errcheck
unknownPath := base64.StdEncoding.EncodeToString(rnd)
testData := []string{
"1",
unknownPath,
"/" + unknownPath,
"http:/",
"gopher://lalalal",
"gopher://lalala",
"https:///paths",
"h:/=",
filepath.Join(suite.directory, "___"),
filepath.Join(suite.absDirectory, "___"),
suite.directory,
suite.absDirectory,
}
for _, v := range testData {
@@ -71,13 +55,12 @@ func (suite *TypeBlocklistURITestSuite) TestUnmarshalFail() {
}
func (suite *TypeBlocklistURITestSuite) TestUnmarshalOk() {
dir, _ := os.Getwd()
dir, _ = filepath.Abs(dir)
testData := []string{
"http://lalala",
filepath.Join(dir, "config.go"),
"https://lalala",
"https://lalala/path",
filepath.Join(suite.directory, "config.go"),
filepath.Join(suite.absDirectory, "config.go"),
}
for _, v := range testData {
@@ -92,77 +75,9 @@ func (suite *TypeBlocklistURITestSuite) TestUnmarshalOk() {
testStruct := &typeBlocklistURITestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.EqualValues(t, value, testStruct.Value.Value(""))
})
}
}
assert.EqualValues(t, value, testStruct.Value.Get(""))
func (suite *TypeBlocklistURITestSuite) TestMarshalOk() {
dir, _ := os.Getwd()
dir, _ = filepath.Abs(dir)
testData := []string{
"http://lalalal",
filepath.Join(dir, "config.go"),
}
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 := &typeBlocklistURITestStruct{}
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, name, string(marshalled))
})
}
}
func (suite *TypeBlocklistURITestSuite) TestValue() {
testStruct := &typeBlocklistURITestStruct{}
suite.Equal("http://lalala", testStruct.Value.Value("http://lalala"))
data, err := json.Marshal(map[string]string{
"value": "http://blablabla",
})
suite.NoError(err)
suite.NoError(json.Unmarshal(data, testStruct))
suite.Equal("http://blablabla", testStruct.Value.Value(""))
}
func (suite *TypeBlocklistURITestSuite) TestIsRemote() {
dir, _ := os.Getwd()
dir, _ = filepath.Abs(dir)
testData := map[bool]string{
true: "http://lalalal",
false: filepath.Join(dir, "config.go"),
}
for k, v := range testData {
ok := k
data, err := json.Marshal(map[string]string{
"value": v,
})
suite.NoError(err)
suite.T().Run(strconv.FormatBool(ok), func(t *testing.T) {
testStruct := &typeBlocklistURITestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
if ok {
if strings.HasPrefix(value, "http") {
assert.True(t, testStruct.Value.IsRemote())
} else {
assert.False(t, testStruct.Value.IsRemote())
@@ -171,6 +86,27 @@ func (suite *TypeBlocklistURITestSuite) TestIsRemote() {
}
}
func (suite *TypeBlocklistURITestSuite) TestMarshalOk() {
testStruct := &typeBlocklistURITestStruct{
Value: config.TypeBlocklistURI{
Value: "http://some.url/with/path",
},
}
data, err := json.Marshal(testStruct)
suite.NoError(err)
suite.JSONEq(`{"value": "http://some.url/with/path"}`, string(data))
}
func (suite *TypeBlocklistURITestSuite) TestGet() {
value := config.TypeBlocklistURI{}
suite.Equal("/path", value.Get("/path"))
suite.NoError(value.Set("http://lalala.ru"))
suite.Equal("http://lalala.ru", value.Get("/path"))
suite.Equal("http://lalala.ru", value.Get(""))
}
func TestTypeBlocklistURI(t *testing.T) {
t.Parallel()
suite.Run(t, &TypeBlocklistURITestSuite{})
internal/config/type_bool.go
+40
View File
@@ -0,0 +1,40 @@
package config
import (
"fmt"
"strconv"
"strings"
)
type TypeBool struct {
Value bool
}
func (t *TypeBool) Set(data string) error {
switch strings.ToLower(data) {
case "1", "y", "yes", "enabled", "true":
t.Value = true
case "0", "n", "no", "disabled", "false":
t.Value = false
default:
return fmt.Errorf("incorrect bool value %s", data)
}
return nil
}
func (t TypeBool) Get(defaultValue bool) bool {
return t.Value || defaultValue
}
func (t *TypeBool) UnmarshalText(data []byte) error {
return t.Set(string(data))
}
func (t TypeBool) MarshalText() ([]byte, error) {
return []byte(t.String()), nil
}
func (t TypeBool) String() string {
return strconv.FormatBool(t.Value)
}
internal/config/type_bool_test.go
+113
View File
@@ -0,0 +1,113 @@
package config_test
import (
"encoding/json"
"fmt"
"strconv"
"testing"
"github.com/9seconds/mtg/v2/internal/config"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/suite"
)
type typeBoolTestStruct struct {
Value config.TypeBool `json:"value"`
}
type TypeBoolTestSuite struct {
suite.Suite
}
func (suite *TypeBoolTestSuite) TestUnmarshalFail() {
testData := []string{
"",
"np",
"нет",
}
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, &typeBoolTestStruct{}))
})
}
}
func (suite *TypeBoolTestSuite) TestUnmarshalOk() {
testData := map[string]bool{
"0": false,
"N": false,
"nO": false,
"no": false,
"dISAbLEd": false,
"False": false,
"false": false,
"1": true,
"y": true,
"Yes": true,
"yes": true,
"enABLED": true,
"True": true,
"TRUE": true,
"true": true,
}
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 := &typeBoolTestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
if value {
assert.True(t, testStruct.Value.Value)
} else {
assert.False(t, testStruct.Value.Value)
}
})
}
}
func (suite *TypeBoolTestSuite) TestMarshalOk() {
for _, v := range []bool{true, false} {
name := strconv.FormatBool(v)
suite.T().Run(name, func(t *testing.T) {
testStruct := typeBoolTestStruct{
Value: config.TypeBool{
Value: v,
},
}
data, err := json.Marshal(testStruct)
assert.NoError(t, err)
assert.JSONEq(t, fmt.Sprintf(`{"value": "%s"}`, name), string(data))
})
}
}
func (suite *TypeBoolTestSuite) TestGet() {
value := config.TypeBool{}
suite.False(value.Get(false))
suite.True(value.Get(true))
value.Value = true
suite.True(value.Get(false))
suite.True(value.Get(true))
}
func TestTypeBool(t *testing.T) {
t.Parallel()
suite.Run(t, &TypeBoolTestSuite{})
}
internal/config/type_bytes.go
+29 -28
View File
@@ -7,48 +7,49 @@ import (
"github.com/alecthomas/units"
)
var typeBytesStringCleaner = strings.NewReplacer(" ", "", "\t", "", "IB", "iB")
type TypeBytes struct {
value units.Base2Bytes
Value units.Base2Bytes
}
func (c *TypeBytes) UnmarshalText(data []byte) error {
if len(data) == 0 {
return nil
}
func (t *TypeBytes) Set(value string) error {
normalizedValue := typeBytesStringCleaner.Replace(strings.ToUpper(value))
normalizedData := strings.ToUpper(string(data))
normalizedData = strings.ReplaceAll(normalizedData, "IB", "iB")
value, err := units.ParseBase2Bytes(normalizedData)
parsedValue, err := units.ParseBase2Bytes(normalizedValue)
if err != nil {
return fmt.Errorf("incorrect bytes value: %w", err)
return fmt.Errorf("incorrect bytes value (%v): %w", value, err)
}
if value < 0 {
return fmt.Errorf("%d should be positive number", value)
if parsedValue < 0 {
return fmt.Errorf("bytes should be positive (%s)", value)
}
c.value = value
t.Value = parsedValue
return nil
}
func (c TypeBytes) MarshalText() ([]byte, error) {
return []byte(c.String()), nil
}
func (c TypeBytes) String() string {
if c.value == 0 {
return ""
}
return strings.ToLower(c.value.String())
}
func (c TypeBytes) Value(defaultValue uint) uint {
if c.value == 0 {
func (t TypeBytes) Get(defaultValue uint) uint {
if t.Value == 0 {
return defaultValue
}
return uint(c.value)
return uint(t.Value)
}
func (t *TypeBytes) UnmarshalText(data []byte) error {
return t.Set(string(data))
}
func (t TypeBytes) MarshalText() ([]byte, error) {
return []byte(t.String()), nil
}
func (t TypeBytes) String() string {
if t.Value == 0 {
return ""
}
return strings.ToLower(t.Value.String())
}
internal/config/type_bytes_test.go
+11 -45
View File
@@ -17,19 +17,12 @@ type TypeBytesTestSuite struct {
suite.Suite
}
func (suite *TypeBytesTestSuite) TestUnmarshalNil() {
typ := &config.TypeBytes{}
suite.NoError(typ.UnmarshalText(nil))
suite.Empty(typ.String())
}
func (suite *TypeBytesTestSuite) TestUnmarshalFail() {
testData := []string{
"1m",
"1",
"-1kb",
"-1kib",
"-1QB",
}
for _, v := range testData {
@@ -65,53 +58,26 @@ func (suite *TypeBytesTestSuite) TestUnmarshalOk() {
testStruct := &typeBytesTestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.EqualValues(t, value, testStruct.Value.Value(0))
assert.EqualValues(t, value, testStruct.Value.Get(0))
})
}
}
func (suite *TypeBytesTestSuite) TestMarshalOk() {
testData := []string{
"1b",
"1kib",
"2mib",
}
value := typeBytesTestStruct{}
suite.NoError(value.Value.Set("1kib"))
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, name, string(marshalled))
})
}
data, err := json.Marshal(value)
suite.NoError(err)
suite.JSONEq(`{"value": "1kib"}`, string(data))
}
func (suite *TypeBytesTestSuite) TestValue() {
testStruct := &typeBytesTestStruct{}
func (suite *TypeBytesTestSuite) TestGet() {
value := config.TypeBytes{}
suite.EqualValues(1000, value.Get(1000))
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))
suite.NoError(value.Set("1mib"))
suite.EqualValues(1048576, value.Get(1000))
}
func TestTypeBytes(t *testing.T) {
internal/config/type_concurrency.go
+45
View File
@@ -0,0 +1,45 @@
package config
import (
"fmt"
"strconv"
)
type TypeConcurrency struct {
Value uint
}
func (t *TypeConcurrency) Set(value string) error {
concurrencyValue, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return fmt.Errorf("Value is not uint (%s): %w", value, err)
}
if concurrencyValue == 0 {
return fmt.Errorf("Value should be >0 (%s)", value)
}
t.Value = uint(concurrencyValue)
return nil
}
func (t TypeConcurrency) Get(defaultValue uint) uint {
if t.Value == 0 {
return defaultValue
}
return t.Value
}
func (t *TypeConcurrency) UnmarshalJSON(data []byte) error {
return t.Set(string(data))
}
func (t TypeConcurrency) MarshalJSON() ([]byte, error) {
return []byte(t.String()), nil
}
func (t TypeConcurrency) String() string {
return strconv.FormatUint(uint64(t.Value), 10)
}
internal/config/type_concurrency_test.go
+73
View File
@@ -0,0 +1,73 @@
package config_test
import (
"encoding/json"
"testing"
"github.com/9seconds/mtg/v2/internal/config"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/suite"
)
type typeConcurrencyTestStruct struct {
Value config.TypeConcurrency `json:"value"`
}
type TypeConcurrencyTestSuite struct {
suite.Suite
}
func (suite *TypeConcurrencyTestSuite) TestUnmarshalFail() {
testData := []string{
"-1",
"0",
"0.0",
"1.0",
"1.1",
".",
"some_value",
}
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, &typeConcurrencyTestStruct{}))
})
}
}
func (suite *TypeConcurrencyTestSuite) TestUnmarshalOk() {
testStruct := &typeConcurrencyTestStruct{}
suite.NoError(json.Unmarshal([]byte(`{"value": 1}`), testStruct))
suite.EqualValues(1, testStruct.Value.Get(2))
}
func (suite *TypeConcurrencyTestSuite) TestMarshalOk() {
testStruct := &typeConcurrencyTestStruct{
Value: config.TypeConcurrency{
Value: 2,
},
}
data, err := json.Marshal(testStruct)
suite.NoError(err)
suite.JSONEq(`{"value": 2}`, string(data))
}
func (suite *TypeConcurrencyTestSuite) TestGet() {
value := config.TypeConcurrency{}
suite.EqualValues(1, value.Get(1))
value.Value = 3
suite.EqualValues(3, value.Get(1))
}
func TestTypeConcurrency(t *testing.T) {
t.Parallel()
suite.Run(t, &TypeConcurrencyTestSuite{})
}
internal/config/type_duration.go
+29 -22
View File
@@ -6,41 +6,48 @@ import (
"time"
)
var typeDurationStringCleaner = strings.NewReplacer(" ", "", "\t", "")
type TypeDuration struct {
value time.Duration
Value time.Duration
}
func (c *TypeDuration) UnmarshalText(data []byte) error {
if len(data) == 0 {
return nil
}
dur, err := time.ParseDuration(strings.ToLower(string(data)))
func (t *TypeDuration) Set(value string) error {
parsedValue, err := time.ParseDuration(
typeDurationStringCleaner.Replace(strings.ToLower(value)))
if err != nil {
return fmt.Errorf("incorrect duration: %w", err)
return fmt.Errorf("incorrect duration (%s): %w", value, err)
}
if dur < 0 {
return fmt.Errorf("%s should be positive duration", dur)
if parsedValue < 0 {
return fmt.Errorf("duration has to be a positive: %s", value)
}
c.value = dur
t.Value = parsedValue
return nil
}
func (c TypeDuration) MarshalText() ([]byte, error) {
return []byte(c.value.String()), nil
}
func (c TypeDuration) String() string {
return c.value.String()
}
func (c TypeDuration) Value(defaultValue time.Duration) time.Duration {
if c.value == 0 {
func (t TypeDuration) Get(defaultValue time.Duration) time.Duration {
if t.Value == 0 {
return defaultValue
}
return c.value
return t.Value
}
func (t *TypeDuration) UnmarshalText(data []byte) error {
return t.Set(string(data))
}
func (t TypeDuration) MarshalText() ([]byte, error) {
return []byte(t.String()), nil
}
func (t TypeDuration) String() string {
if t.Value == 0 {
return ""
}
return t.Value.String()
}
internal/config/type_duration_test.go
+33 -41
View File
@@ -18,18 +18,12 @@ type TypeDurationTestSuite struct {
suite.Suite
}
func (suite *TypeDurationTestSuite) TestUnmarshalNil() {
typ := &config.TypeDuration{}
suite.NoError(typ.UnmarshalText(nil))
suite.EqualValues(0, typ.Value(0))
}
func (suite *TypeDurationTestSuite) TestUnmarshalFail() {
testData := []string{
"1t",
"1",
"-1s",
"-1h",
"1 seconds ago",
"1s ago",
"",
}
for _, v := range testData {
@@ -47,8 +41,11 @@ func (suite *TypeDurationTestSuite) TestUnmarshalFail() {
func (suite *TypeDurationTestSuite) TestUnmarshalOk() {
testData := map[string]time.Duration{
"1s": time.Second,
"1m": time.Minute,
"2h1s": 2*time.Hour + time.Second,
"0": 0 * time.Second,
"0s": 0 * time.Second,
"1\tM": time.Minute,
"1H": time.Hour,
"1 h": time.Hour,
}
for k, v := range testData {
@@ -63,53 +60,48 @@ func (suite *TypeDurationTestSuite) TestUnmarshalOk() {
testStruct := &typeDurationTestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.Equal(t, value, testStruct.Value.Value(0))
assert.Equal(t, value, testStruct.Value.Value)
})
}
}
func (suite *TypeDurationTestSuite) TestMarshalOk() {
testData := []string{
"1s",
"1m0s",
"2h0m1s",
testData := map[string]string{
"1s": "1s",
"0": "",
"0s": "",
"0ms": "",
"1 H": "1h0m0s",
}
for _, v := range testData {
name := v
for k, v := range testData {
value := k
expected := v
data, err := json.Marshal(map[string]string{
"value": name,
})
suite.NoError(err)
suite.T().Run(name, func(t *testing.T) {
suite.T().Run(value, func(t *testing.T) {
testStruct := &typeDurationTestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.Equal(t, name, testStruct.Value.String())
assert.NoError(t, testStruct.Value.Set(value))
marshalled, err := testStruct.Value.MarshalText()
data, err := json.Marshal(testStruct)
assert.NoError(t, err)
assert.Equal(t, name, string(marshalled))
expectedJson, err := json.Marshal(map[string]string{
"value": expected,
})
assert.NoError(t, err)
assert.JSONEq(t, string(expectedJson), string(data))
})
}
}
func (suite *TypeDurationTestSuite) TestValue() {
testStruct := &typeDurationTestStruct{}
func (suite *TypeDurationTestSuite) TestGet() {
value := config.TypeDuration{}
suite.Equal(time.Second, value.Get(time.Second))
suite.EqualValues(0, testStruct.Value.Value(0))
suite.Equal(time.Second, testStruct.Value.Value(time.Second))
data, err := json.Marshal(map[string]string{
"value": "1s",
})
suite.NoError(err)
suite.NoError(json.Unmarshal(data, testStruct))
suite.Equal(time.Second, testStruct.Value.Value(0))
suite.Equal(time.Second, testStruct.Value.Value(time.Minute))
value.Value = 3 * time.Second
suite.Equal(3*time.Second, value.Get(time.Hour))
}
func TestTypeDuration(t *testing.T) {
internal/config/type_error_rate.go
+22 -18
View File
@@ -8,36 +8,40 @@ import (
const typeErrorRateIgnoreLess = 1e-8
type TypeErrorRate struct {
value float64
Value float64
}
func (c *TypeErrorRate) UnmarshalJSON(data []byte) error {
value, err := strconv.ParseFloat(string(data), 64)
func (t *TypeErrorRate) Set(value string) error {
parsedValue, err := strconv.ParseFloat(value, 64)
if err != nil {
return fmt.Errorf("incorrect float value: %w", err)
return fmt.Errorf("Value is not a float (%s): %w", value, err)
}
if value <= 0 || value >= 100 {
return fmt.Errorf("%f should be 0 < x < 100", value)
if parsedValue <= 0.0 || parsedValue >= 100.0 {
return fmt.Errorf("Value should be 0 < x < 100 (%s)", value)
}
c.value = value
t.Value = parsedValue
return nil
}
func (c *TypeErrorRate) MarshalText() ([]byte, error) {
return []byte(c.String()), nil
}
func (c TypeErrorRate) String() string {
return strconv.FormatFloat(c.value, 'f', -1, 64)
}
func (c TypeErrorRate) Value(defaultValue float64) float64 {
if c.value < typeErrorRateIgnoreLess {
func (t TypeErrorRate) Get(defaultValue float64) float64 {
if t.Value < typeErrorRateIgnoreLess {
return defaultValue
}
return c.value
return t.Value
}
func (t *TypeErrorRate) UnmarshalText(data []byte) error {
return t.Set(string(data))
}
func (t TypeErrorRate) MarshalText() ([]byte, error) {
return []byte(t.String()), nil
}
func (t TypeErrorRate) String() string {
return strconv.FormatFloat(t.Value, 'f', -1, 64)
}
internal/config/type_error_rate_test.go
+36 -67
View File
@@ -2,7 +2,6 @@ package config_test
import (
"encoding/json"
"strconv"
"testing"
"github.com/9seconds/mtg/v2/internal/config"
@@ -19,104 +18,74 @@ type TypeErrorRateTestSuite struct {
}
func (suite *TypeErrorRateTestSuite) TestUnmarshalFail() {
testData := []float64{
1000,
-100,
-0.0001,
testData := []string{
"",
"1s",
"1,",
"1,2",
".",
"3.4.5",
"3.5.",
".3.5",
"some word",
"1e2",
"-1.0",
}
for _, v := range testData {
data, err := json.Marshal(map[string]float64{
data, err := json.Marshal(map[string]string{
"value": v,
})
suite.NoError(err)
suite.T().Run(strconv.FormatFloat(v, 'f', -1, 64), func(t *testing.T) {
suite.T().Run(v, func(t *testing.T) {
assert.Error(t, json.Unmarshal(data, &typeErrorRateTestStruct{}))
})
}
data, err := json.Marshal(map[string]string{
"value": "hello",
})
suite.NoError(err)
suite.Error(json.Unmarshal(data, &typeErrorRateTestStruct{}))
}
func (suite *TypeErrorRateTestSuite) TestUnmarshalOk() {
testData := []float64{
1,
55.5,
0.0001,
1e-6,
testData := map[string]float64{
"1": 1.0,
"1.0": 1.0,
"0.5": 0.5,
".5": 0.5,
}
for _, v := range testData {
for k, v := range testData {
value := v
data, err := json.Marshal(map[string]float64{
"value": v,
data, err := json.Marshal(map[string]string{
"value": k,
})
suite.NoError(err)
suite.T().Run(strconv.FormatFloat(v, 'f', -1, 64), func(t *testing.T) {
suite.T().Run(k, func(t *testing.T) {
testStruct := &typeErrorRateTestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.InEpsilon(t, value, testStruct.Value.Value(0), 1e-10)
assert.InEpsilon(t, value, testStruct.Value.Value, 1e-10)
})
}
}
func (suite *TypeErrorRateTestSuite) TestMarshalOk() {
testData := []float64{
1,
55.5,
0.0001,
1e-6,
testStruct := typeErrorRateTestStruct{
Value: config.TypeErrorRate{
Value: 1.01,
},
}
for _, v := range testData {
value := v
data, err := json.Marshal(map[string]float64{
"value": v,
})
suite.NoError(err)
suite.T().Run(strconv.FormatFloat(v, 'f', -1, 64), func(t *testing.T) {
testStruct := &typeErrorRateTestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
parsed, err := strconv.ParseFloat(testStruct.Value.String(), 64)
assert.NoError(t, err)
assert.InEpsilon(t, value, parsed, 1e-10)
marshalled, err := testStruct.Value.MarshalText()
assert.NoError(t, err)
parsed, err = strconv.ParseFloat(string(marshalled), 64)
assert.NoError(t, err)
assert.InEpsilon(t, value, parsed, 1e-10)
})
}
encodedJson, err := json.Marshal(testStruct)
suite.NoError(err)
suite.JSONEq(`{"value": "1.01"}`, string(encodedJson))
}
func (suite *TypeErrorRateTestSuite) TestValue() {
testStruct := &typeErrorRateTestStruct{}
func (suite *TypeErrorRateTestSuite) TestGet() {
value := config.TypeErrorRate{}
suite.InEpsilon(1.0, value.Get(1.0), 1e-10)
suite.InEpsilon(1, testStruct.Value.Value(1), 1e-10)
suite.InEpsilon(2, testStruct.Value.Value(2), 1e-10)
data, err := json.Marshal(map[string]float64{
"value": 1,
})
suite.NoError(err)
suite.NoError(json.Unmarshal(data, testStruct))
suite.InEpsilon(1, testStruct.Value.Value(2), 1e-10)
suite.InEpsilon(1, testStruct.Value.Value(3), 1e-10)
value.Value = 5.0
suite.InEpsilon(5.0, value.Get(1.0), 1e-10)
}
func TestTypeErrorRate(t *testing.T) {
internal/config/type_hostport.go
+33 -41
View File
@@ -7,61 +7,53 @@ import (
)
type TypeHostPort struct {
host TypeIP
port TypePort
Value string
}
func (c *TypeHostPort) UnmarshalText(data []byte) error {
if len(data) == 0 {
return nil
}
text := string(data)
host, port, err := net.SplitHostPort(text)
func (t *TypeHostPort) Set(value string) error {
host, port, err := net.SplitHostPort(value)
if err != nil {
return fmt.Errorf("incorrect host:port syntax: %w", err)
return fmt.Errorf("incorrect host:port value (%v): %w", value, err)
}
if port == "" {
return fmt.Errorf("port in %s host:port pair cannot be empty", text)
portValue, err := strconv.ParseUint(port, 10, 16)
if err != nil {
return fmt.Errorf("incorrect port number (%v): %w", value, err)
}
if err := c.port.UnmarshalJSON([]byte(port)); err != nil {
return fmt.Errorf("incorrect port in host:port: %w", err)
if portValue == 0 {
return fmt.Errorf("incorrect port number (%s)", value)
}
if err := c.host.UnmarshalText([]byte(host)); err != nil {
return fmt.Errorf("incorrect host: %w", err)
if host == "" {
return fmt.Errorf("empty host: %s", value)
}
if net.ParseIP(host) == nil {
return fmt.Errorf("host is not an IP address: %s", value)
}
t.Value = net.JoinHostPort(host, port)
return nil
}
func (c TypeHostPort) MarshalText() ([]byte, error) {
return []byte(c.String()), nil
}
func (c TypeHostPort) String() string {
return c.Value(net.IP{}, 0)
}
func (c TypeHostPort) HostValue(defaultValue net.IP) net.IP {
return c.host.Value(defaultValue)
}
func (c TypeHostPort) PortValue(defaultValue uint) uint {
return c.port.Value(defaultValue)
}
func (c TypeHostPort) Value(defaultHostValue net.IP, defaultPortValue uint) string {
host := c.HostValue(defaultHostValue)
port := c.PortValue(defaultPortValue)
hostStr := ""
if len(host) > 0 {
hostStr = host.String()
func (t TypeHostPort) Get(defaultValue string) string {
if t.Value == "" {
return defaultValue
}
return net.JoinHostPort(hostStr, strconv.Itoa(int(port)))
return t.Value
}
func (t *TypeHostPort) UnmarshalText(data []byte) error {
return t.Set(string(data))
}
func (t TypeHostPort) MarshalText() ([]byte, error) {
return []byte(t.String()), nil
}
func (t TypeHostPort) String() string {
return t.Value
}
internal/config/type_hostport_test.go
+21 -48
View File
@@ -2,7 +2,6 @@ package config_test
import (
"encoding/json"
"net"
"testing"
"github.com/9seconds/mtg/v2/internal/config"
@@ -20,11 +19,13 @@ type TypeHostPortTestSuite struct {
func (suite *TypeHostPortTestSuite) TestUnmarshalFail() {
testData := []string{
"10.0.0.10:aaa",
"10.0.0.10:",
":",
"xxx",
"xxx:80",
":800",
"127.0.0.1:8000000",
"12...:80",
"",
"localhost",
"google.com:",
}
for _, v := range testData {
@@ -41,9 +42,8 @@ func (suite *TypeHostPortTestSuite) TestUnmarshalFail() {
func (suite *TypeHostPortTestSuite) TestUnmarshalOk() {
testData := []string{
"10.0.0.10:80",
"0.0.0.0:80",
":8000",
"127.0.0.1:80",
"10.0.0.10:6553",
}
for _, v := range testData {
@@ -56,57 +56,30 @@ func (suite *TypeHostPortTestSuite) TestUnmarshalOk() {
suite.T().Run(v, func(t *testing.T) {
testStruct := &typeHostPortTestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.EqualValues(t, value, testStruct.Value.Value(nil, 0))
assert.Equal(t, value, testStruct.Value.Value)
})
}
}
func (suite *TypeHostPortTestSuite) TestMarshalOk() {
testData := []string{
"10.0.0.10:80",
"0.0.0.0:80",
":8000",
testStruct := typeHostPortTestStruct{
Value: config.TypeHostPort{
Value: "127.0.0.1:8000",
},
}
for _, v := range testData {
value := v
data, err := json.Marshal(map[string]string{
"value": v,
})
suite.NoError(err)
suite.T().Run(v, func(t *testing.T) {
testStruct := &typeHostPortTestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.Equal(t, value, testStruct.Value.String())
marshalled, err := testStruct.Value.MarshalText()
assert.NoError(t, err)
assert.Equal(t, value, string(marshalled))
})
}
data, err := json.Marshal(testStruct)
suite.NoError(err)
suite.JSONEq(`{"value": "127.0.0.1:8000"}`, string(data))
}
func (suite *TypeHostPortTestSuite) TestValue() {
testStruct := &typeHostPortTestStruct{}
func (suite *TypeHostPortTestSuite) TestGet() {
value := config.TypeHostPort{}
suite.Equal("127.0.0.1:9000", value.Get("127.0.0.1:9000"))
suite.EqualValues("127.0.0.1:80",
testStruct.Value.Value(net.ParseIP("127.0.0.1"), 80))
suite.EqualValues("127.1.0.1:80",
testStruct.Value.Value(net.ParseIP("127.1.0.1"), 80))
data, err := json.Marshal(map[string]string{
"value": "127.0.0.1:80",
})
suite.NoError(err)
suite.NoError(json.Unmarshal(data, testStruct))
suite.EqualValues("127.0.0.1:80", testStruct.Value.Value(nil, 0))
suite.EqualValues("127.0.0.1:80", testStruct.Value.Value(net.ParseIP("10.0.0.10"), 3000))
value.Value = "127.0.0.1:80"
suite.Equal("127.0.0.1:80", value.Get("127.0.0.1:9000"))
}
func TestTypeHostPort(t *testing.T) {
internal/config/type_http_path.go
+18 -20
View File
@@ -3,33 +3,31 @@ package config
import "strings"
type TypeHTTPPath struct {
value string
Value string
}
func (c *TypeHTTPPath) UnmarshalText(data []byte) error {
if len(data) > 0 {
c.value = "/" + strings.Trim(string(data), "/")
}
func (t *TypeHTTPPath) Set(value string) error {
t.Value = "/" + strings.Trim(value, "/")
return nil
}
func (c TypeHTTPPath) MarshalText() ([]byte, error) {
return []byte(c.String()), nil
}
func (c TypeHTTPPath) String() string {
if c.value == "" {
return "/"
}
return c.value
}
func (c TypeHTTPPath) Value(defaultValue string) string {
if c.value == "" {
func (t TypeHTTPPath) Get(defaultValue string) string {
if t.Value == "" {
return defaultValue
}
return c.value
return t.Value
}
func (t *TypeHTTPPath) UnmarshalText(data []byte) error {
return t.Set(string(data))
}
func (t TypeHTTPPath) MarshalText() ([]byte, error) {
return []byte(t.String()), nil
}
func (t TypeHTTPPath) String() string {
return t.Value
}
internal/config/type_http_path_test.go
+24 -48
View File
@@ -17,72 +17,48 @@ type TypeHTTPPathTestSuite struct {
suite.Suite
}
func (suite *TypeHTTPPathTestSuite) TestUnmarshal() {
testData := []string{
"/hello",
"hello",
"hello/",
"/hello/",
func (suite *TypeHTTPPathTestSuite) TestUnmarshalOk() {
testData := map[string]string{
"": "/",
"/": "/",
"/path": "/path",
"path": "/path",
}
for _, v := range testData {
for k, v := range testData {
value := v
data, err := json.Marshal(map[string]string{
"value": v,
"value": k,
})
suite.NoError(err)
suite.T().Run(v, func(t *testing.T) {
suite.T().Run(k, func(t *testing.T) {
testStruct := &typeHTTPPathTestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.Equal(t, "/hello", testStruct.Value.Value(""))
assert.Equal(t, value, testStruct.Value.Get(""))
})
}
}
func (suite *TypeHTTPPathTestSuite) TestMarshalOk() {
testData := map[string]string{
"": "/",
"/hello": "/hello",
"/hello/": "/hello",
"hello/": "/hello",
"hello": "/hello",
value := typeHTTPPathTestStruct{
Value: config.TypeHTTPPath{
Value: "/path",
},
}
for k, v := range testData {
toPass := k
compareWith := v
data, err := json.Marshal(map[string]string{
"value": toPass,
})
suite.NoError(err)
suite.T().Run(toPass, func(t *testing.T) {
testStruct := &typeHTTPPathTestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.Equal(t, compareWith, testStruct.Value.String())
marshalled, err := testStruct.Value.MarshalText()
assert.NoError(t, err)
assert.Equal(t, compareWith, string(marshalled))
})
}
data, err := json.Marshal(value)
suite.NoError(err)
suite.JSONEq(`{"value": "/path"}`, string(data))
}
func (suite *TypeHTTPPathTestSuite) TestValue() {
testStruct := &typeHTTPPathTestStruct{}
func (suite *TypeHTTPPathTestSuite) TestGet() {
value := config.TypeHTTPPath{}
suite.Equal("/hello", value.Get("/hello"))
suite.Equal("/hello", testStruct.Value.Value("/hello"))
data, err := json.Marshal(map[string]string{
"value": "/map",
})
suite.NoError(err)
suite.NoError(json.Unmarshal(data, testStruct))
suite.Equal("/map", testStruct.Value.Value("/hello"))
suite.NoError(value.Set("/lalala"))
suite.Equal("/lalala", value.Get("/hello"))
}
func TestTypeHTTPPath(t *testing.T) {
internal/config/type_ip.go
+24 -24
View File
@@ -6,40 +6,40 @@ import (
)
type TypeIP struct {
value net.IP
Value net.IP
}
func (c *TypeIP) UnmarshalText(data []byte) error {
if len(data) == 0 {
return nil
}
ip := net.ParseIP(string(data))
func (t *TypeIP) Set(value string) error {
ip := net.ParseIP(value)
if ip == nil {
return fmt.Errorf("incorrect ip address: %s", string(data))
return fmt.Errorf("incorret ip %s", value)
}
c.value = ip
t.Value = ip
return nil
}
func (c *TypeIP) MarshalText() ([]byte, error) {
return []byte(c.String()), nil
}
func (c TypeIP) String() string {
if len(c.value) > 0 {
return c.value.String()
}
return ""
}
func (c TypeIP) Value(defaultValue net.IP) net.IP {
if c.value == nil {
func (t *TypeIP) Get(defaultValue net.IP) net.IP {
if len(t.Value) == 0 {
return defaultValue
}
return c.value
return t.Value
}
func (t *TypeIP) UnmarshalText(data []byte) error {
return t.Set(string(data))
}
func (t TypeIP) MarshalText() ([]byte, error) {
return []byte(t.String()), nil
}
func (t TypeIP) String() string {
if len(t.Value) == 0 {
return ""
}
return t.Value.String()
}
internal/config/type_ip_test.go
+34 -45
View File
@@ -20,10 +20,11 @@ type TypeIPTestSuite struct {
func (suite *TypeIPTestSuite) TestUnmarshalFail() {
testData := []string{
"0.0.10",
"10.0.0.10:",
"xxx:80",
"2001:0db8:85a3:0000:0000:8a2e:4",
"",
"....",
"0...",
"300.200.200.800",
"[]",
}
for _, v := range testData {
@@ -39,74 +40,62 @@ func (suite *TypeIPTestSuite) TestUnmarshalFail() {
}
func (suite *TypeIPTestSuite) TestUnmarshalOk() {
testData := []string{
"0.0.0.0",
"10.0.0.10",
"2001:0db8:85a3:0000:0000:8a2e:0370:7334",
testData := map[string]string{
"2001:0db8:85a3:0000:0000:8a2e:0370:7334": "2001:db8:85a3::8a2e:370:7334",
"127.0.0.1": "127.0.0.1",
}
for _, v := range testData {
value := v
for k, v := range testData {
expected := v
data, err := json.Marshal(map[string]string{
"value": v,
"value": k,
})
suite.NoError(err)
suite.T().Run(v, func(t *testing.T) {
suite.T().Run(k, func(t *testing.T) {
testStruct := &typeIPTestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.Equal(t,
net.ParseIP(value).String(),
testStruct.Value.Value(nil).String())
assert.Equal(t, expected, testStruct.Value.Get(nil).String())
})
}
}
func (suite *TypeIPTestSuite) TestMarshalOk() {
testData := []string{
"0.0.0.0",
"10.0.0.10",
"2001:0db8:85a3:0000:0000:8a2e:0370:7334",
"2001:db8:85a3::8a2e:370:7334",
"127.0.0.1",
}
for _, v := range testData {
value := net.ParseIP(v).String()
data, err := json.Marshal(map[string]string{
"value": v,
})
suite.NoError(err)
value := v
suite.T().Run(v, func(t *testing.T) {
testStruct := &typeIPTestStruct{}
testStruct := &typeIPTestStruct{
Value: config.TypeIP{
Value: net.ParseIP(value),
},
}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.Equal(t, value, testStruct.Value.String())
marshalled, err := testStruct.Value.MarshalText()
encodedJSON, err := json.Marshal(testStruct)
assert.NoError(t, err)
assert.Equal(t, value, string(marshalled))
expectedJSON, err := json.Marshal(map[string]string{
"value": value,
})
assert.NoError(t, err)
assert.JSONEq(t, string(expectedJSON), string(encodedJSON))
})
}
}
func (suite *TypeIPTestSuite) TestValue() {
testStruct := &typeIPTestStruct{}
suite.Empty(testStruct.Value.String())
func (suite *TypeIPTestSuite) TestGet() {
value := config.TypeIP{}
suite.Equal("127.0.0.1", value.Get(net.ParseIP("127.0.0.1")).String())
suite.Nil(testStruct.Value.Value(nil))
suite.Equal("127.1.0.1", testStruct.Value.Value(net.ParseIP("127.1.0.1")).String())
data, err := json.Marshal(map[string]string{
"value": "127.0.0.1",
})
suite.NoError(err)
suite.NoError(json.Unmarshal(data, testStruct))
suite.Equal("127.0.0.1", testStruct.Value.Value(nil).String())
suite.Equal("127.0.0.1", testStruct.Value.Value(net.ParseIP("10.0.0.10")).String())
suite.NoError(value.Set("127.0.0.2"))
suite.Equal("127.0.0.2", value.Get(net.ParseIP("127.0.0.1")).String())
}
func TestTypeIP(t *testing.T) {
internal/config/type_metric_prefix.go
+20 -21
View File
@@ -6,36 +6,35 @@ import (
)
type TypeMetricPrefix struct {
value string
Value string
}
func (c *TypeMetricPrefix) UnmarshalText(data []byte) error {
if len(data) == 0 {
return nil
func (t *TypeMetricPrefix) Set(value string) error {
if ok, err := regexp.MatchString("^[a-z0-9]+$", value); !ok || err != nil {
return fmt.Errorf("incorrect metric prefix %s: %w", value, err)
}
prefix := string(data)
if ok, err := regexp.MatchString("^[a-z0-9]+$", prefix); !ok || err != nil {
return fmt.Errorf("incorrect metric prefix: %s", prefix)
}
c.value = prefix
t.Value = value
return nil
}
func (c TypeMetricPrefix) MarshalText() ([]byte, error) {
return []byte(c.String()), nil
}
func (c TypeMetricPrefix) String() string {
return c.value
}
func (c TypeMetricPrefix) Value(defaultValue string) string {
if c.value == "" {
func (t TypeMetricPrefix) Get(defaultValue string) string {
if t.Value == "" {
return defaultValue
}
return c.value
return t.Value
}
func (t *TypeMetricPrefix) UnmarshalText(data []byte) error {
return t.Set(string(data))
}
func (t TypeMetricPrefix) MarshalText() ([]byte, error) {
return []byte(t.String()), nil
}
func (t TypeMetricPrefix) String() string {
return t.Value
}
internal/config/type_metric_prefix_test.go
+20 -65
View File
@@ -17,18 +17,13 @@ type TypeMetricPrefixTestSuite struct {
suite.Suite
}
func (suite *TypeMetricPrefixTestSuite) TestUnmarshalNil() {
typ := &config.TypeMetricPrefix{}
suite.NoError(typ.UnmarshalText(nil))
suite.Empty(typ.String())
}
func (suite *TypeMetricPrefixTestSuite) TestUnmarshalFail() {
testData := []string{
"aaa.aaa",
"aaa-bbb",
"aaa:ccc",
"metric prefix",
"",
"-",
"hello/world",
"lala*",
"++sdf++",
}
for _, v := range testData {
@@ -44,69 +39,29 @@ func (suite *TypeMetricPrefixTestSuite) TestUnmarshalFail() {
}
func (suite *TypeMetricPrefixTestSuite) TestUnmarshalOk() {
testData := []string{
"mtg",
"mtg111",
}
for _, v := range testData {
value := v
data, err := json.Marshal(map[string]string{
"value": v,
})
suite.NoError(err)
suite.T().Run(v, func(t *testing.T) {
testStruct := &typeMetricPrefixTestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.Equal(t, value, testStruct.Value.Value(""))
})
}
testStruct := &typeMetricPrefixTestStruct{}
suite.NoError(json.Unmarshal([]byte(`{"value": "mtg"}`), testStruct))
suite.Equal("mtg", testStruct.Value.Get("lalala"))
}
func (suite *TypeMetricPrefixTestSuite) TestMarshalOk() {
testData := []string{
"mtg",
"mtg111",
testStruct := &typeMetricPrefixTestStruct{
Value: config.TypeMetricPrefix{
Value: "mtg",
},
}
for _, v := range testData {
value := v
data, err := json.Marshal(map[string]string{
"value": v,
})
suite.NoError(err)
suite.T().Run(v, func(t *testing.T) {
testStruct := &typeMetricPrefixTestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.Equal(t, value, testStruct.Value.String())
marshalled, err := testStruct.Value.MarshalText()
assert.NoError(t, err)
assert.Equal(t, value, string(marshalled))
})
}
data, err := json.Marshal(testStruct)
suite.NoError(err)
suite.JSONEq(`{"value": "mtg"}`, string(data))
}
func (suite *TypeMetricPrefixTestSuite) TestValue() {
testStruct := &typeMetricPrefixTestStruct{}
func (suite *TypeMetricPrefixTestSuite) TestGet() {
value := config.TypeMetricPrefix{}
suite.Equal("lalala", value.Get("lalala"))
suite.Equal("mtg", testStruct.Value.Value("mtg"))
suite.Equal("vvv", testStruct.Value.Value("vvv"))
data, err := json.Marshal(map[string]string{
"value": "aaa",
})
suite.NoError(err)
suite.NoError(json.Unmarshal(data, testStruct))
suite.Equal("aaa", testStruct.Value.Value("mtg"))
suite.Equal("aaa", testStruct.Value.Value("vvv"))
value.Value = "mtg"
suite.Equal("mtg", value.Get("lalala"))
}
func TestTypeMetricPrefix(t *testing.T) {
internal/config/type_port.go
+22 -22
View File
@@ -6,40 +6,40 @@ import (
)
type TypePort struct {
value uint
Value uint16
}
func (c *TypePort) UnmarshalJSON(data []byte) error {
if len(data) == 0 {
return nil
}
intValue, err := strconv.ParseUint(string(data), 10, 64)
func (t *TypePort) Set(value string) error {
portValue, err := strconv.ParseUint(value, 10, 16)
if err != nil {
return fmt.Errorf("port number is not a number: %w", err)
return fmt.Errorf("incorrect port number (%v): %w", value, err)
}
if intValue == 0 || intValue >= 65536 {
return fmt.Errorf("port number should be 0 < portNo < 65536: %d", intValue)
if portValue == 0 {
return fmt.Errorf("incorrect port number (%s)", value)
}
c.value = uint(intValue)
t.Value = uint16(portValue)
return nil
}
func (c *TypePort) MarshalJSON() ([]byte, error) {
return []byte(c.String()), nil
}
func (c TypePort) String() string {
return strconv.Itoa(int(c.value))
}
func (c TypePort) Value(defaultValue uint) uint {
if c.value == 0 {
func (t TypePort) Get(defaultValue uint16) uint16 {
if t.Value == 0 {
return defaultValue
}
return c.value
return t.Value
}
func (t *TypePort) UnmarshalJSON(data []byte) error {
return t.Set(string(data))
}
func (t TypePort) MarshalJSON() ([]byte, error) {
return []byte(t.String()), nil
}
func (t TypePort) String() string {
return strconv.Itoa(int(t.Value))
}
internal/config/type_port_test.go
+24 -70
View File
@@ -2,7 +2,6 @@ package config_test
import (
"encoding/json"
"strconv"
"testing"
"github.com/9seconds/mtg/v2/internal/config"
@@ -18,97 +17,52 @@ type TypePortTestSuite struct {
suite.Suite
}
func (suite *TypePortTestSuite) TestUnmarshalNil() {
typ := &config.TypePort{}
suite.NoError(typ.UnmarshalJSON(nil))
suite.Equal("0", typ.String())
}
func (suite *TypePortTestSuite) TestUnmarshalFail() {
testData := []int{
-1,
1_000_000,
testData := []string{
"",
"port",
"0",
"-1",
"1.5",
"70000",
}
for _, v := range testData {
data, err := json.Marshal(map[string]int{
data, err := json.Marshal(map[string]string{
"value": v,
})
suite.NoError(err)
suite.T().Run(strconv.Itoa(v), func(t *testing.T) {
suite.T().Run(v, func(t *testing.T) {
assert.Error(t, json.Unmarshal(data, &typePortTestStruct{}))
})
}
}
func (suite *TypePortTestSuite) TestUnmarshalOk() {
testData := []int{
1,
1_000,
65535,
}
for _, v := range testData {
value := v
data, err := json.Marshal(map[string]int{
"value": v,
})
suite.NoError(err)
suite.T().Run(strconv.Itoa(v), func(t *testing.T) {
testStruct := &typePortTestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.EqualValues(t, value, testStruct.Value.Value(0))
})
}
testStruct := &typePortTestStruct{}
suite.NoError(json.Unmarshal([]byte(`{"value": 5}`), testStruct))
suite.EqualValues(5, testStruct.Value.Value)
}
func (suite *TypePortTestSuite) TestMarshalOk() {
testData := map[string]int{
"1": 1,
"1000": 1000,
"65535": 65535,
testStruct := &typePortTestStruct{
Value: config.TypePort{
Value: 10,
},
}
for k, v := range testData {
name := k
value := v
data, err := json.Marshal(map[string]int{
"value": value,
})
suite.NoError(err)
suite.T().Run(name, func(t *testing.T) {
testStruct := &typePortTestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.Equal(t, name, testStruct.Value.String())
marshalled, err := testStruct.Value.MarshalJSON()
assert.NoError(t, err)
assert.Equal(t, name, string(marshalled))
})
}
data, err := json.Marshal(testStruct)
suite.NoError(err)
suite.JSONEq(`{"value":10}`, string(data))
}
func (suite *TypePortTestSuite) TestValue() {
testStruct := &typePortTestStruct{}
func (suite *TypePortTestSuite) TestGet() {
value := config.TypePort{}
suite.EqualValues(10, value.Get(10))
suite.EqualValues(0, testStruct.Value.Value(0))
suite.EqualValues(1, testStruct.Value.Value(1))
data, err := json.Marshal(map[string]int{
"value": 5,
})
suite.NoError(err)
suite.NoError(json.Unmarshal(data, testStruct))
suite.EqualValues(5, testStruct.Value.Value(0))
suite.EqualValues(5, testStruct.Value.Value(1))
value.Value = 100
suite.EqualValues(100, value.Get(10))
}
func TestTypePort(t *testing.T) {
internal/config/type_prefer_ip.go
+25 -24
View File
@@ -24,38 +24,39 @@ const (
)
type TypePreferIP struct {
value string
Value string
}
func (c *TypePreferIP) UnmarshalText(data []byte) error {
if len(data) == 0 {
func (t *TypePreferIP) Set(value string) error {
value = strings.ToLower(value)
switch value {
case TypePreferIPPreferIPv4, TypePreferIPPreferIPv6,
TypePreferOnlyIPv4, TypePreferOnlyIPv6:
t.Value = value
return nil
}
text := strings.ToLower(string(data))
switch text {
case TypePreferIPPreferIPv4, TypePreferIPPreferIPv6, TypePreferOnlyIPv4, TypePreferOnlyIPv6:
c.value = text
default:
return fmt.Errorf("incorrect prefer-ip value: %s", string(data))
return fmt.Errorf("unsupported ip preference: %s", value)
}
return nil
}
func (c TypePreferIP) MarshalText() ([]byte, error) {
return []byte(c.value), nil
}
func (c *TypePreferIP) String() string {
return c.value
}
func (c *TypePreferIP) Value(defaultValue string) string {
if c.value == "" {
func (t *TypePreferIP) Get(defaultValue string) string {
if t.Value == "" {
return defaultValue
}
return c.value
return t.Value
}
func (t *TypePreferIP) UnmarshalText(data []byte) error {
return t.Set(string(data))
}
func (t TypePreferIP) MarshalText() ([]byte, error) {
return []byte(t.String()), nil
}
func (t TypePreferIP) String() string {
return t.Value
}
internal/config/type_prefer_ip_test.go
+29 -58
View File
@@ -18,18 +18,12 @@ type TypePreferIPTestSuite struct {
suite.Suite
}
func (suite *TypePreferIPTestSuite) TestUnmarshalNil() {
typ := &config.TypePreferIP{}
suite.NoError(typ.UnmarshalText(nil))
suite.Empty(typ.String())
}
func (suite *TypePreferIPTestSuite) TestUnmarshalFail() {
testData := []string{
"p",
"ipv4",
"onlyipv4",
"ipv6prefer",
"",
"prefer",
"preferipv4",
config.TypePreferIPPreferIPv4 + "_",
}
for _, v := range testData {
@@ -50,14 +44,10 @@ func (suite *TypePreferIPTestSuite) TestUnmarshalOk() {
config.TypePreferIPPreferIPv6,
config.TypePreferOnlyIPv4,
config.TypePreferOnlyIPv6,
strings.ToUpper(config.TypePreferIPPreferIPv4),
strings.ToUpper(config.TypePreferIPPreferIPv6),
strings.ToUpper(config.TypePreferOnlyIPv4),
strings.ToUpper(config.TypePreferOnlyIPv6),
strings.ToLower(config.TypePreferIPPreferIPv4),
strings.ToLower(config.TypePreferIPPreferIPv6),
strings.ToLower(config.TypePreferOnlyIPv4),
strings.ToLower(config.TypePreferOnlyIPv6),
strings.ToTitle(config.TypePreferOnlyIPv4),
strings.ToTitle(config.TypePreferOnlyIPv6),
strings.ToTitle(config.TypePreferIPPreferIPv4),
strings.ToTitle(config.TypePreferIPPreferIPv6),
}
for _, v := range testData {
@@ -70,11 +60,8 @@ func (suite *TypePreferIPTestSuite) TestUnmarshalOk() {
suite.T().Run(v, func(t *testing.T) {
testStruct := &typePreferIPTestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.EqualValues(t,
strings.ToLower(value),
testStruct.Value.Value(config.TypePreferIPPreferIPv4))
assert.Equal(t, strings.ToLower(value), testStruct.Value.Value)
})
}
}
@@ -85,55 +72,39 @@ func (suite *TypePreferIPTestSuite) TestMarshalOk() {
config.TypePreferIPPreferIPv6,
config.TypePreferOnlyIPv4,
config.TypePreferOnlyIPv6,
strings.ToUpper(config.TypePreferIPPreferIPv4),
strings.ToUpper(config.TypePreferIPPreferIPv6),
strings.ToUpper(config.TypePreferOnlyIPv4),
strings.ToUpper(config.TypePreferOnlyIPv6),
strings.ToLower(config.TypePreferIPPreferIPv4),
strings.ToLower(config.TypePreferIPPreferIPv6),
strings.ToLower(config.TypePreferOnlyIPv4),
strings.ToLower(config.TypePreferOnlyIPv6),
}
for _, v := range testData {
value := v
data, err := json.Marshal(map[string]string{
"value": v,
})
suite.NoError(err)
suite.T().Run(v, func(t *testing.T) {
testStruct := &typePreferIPTestStruct{}
testStruct := &typePreferIPTestStruct{
Value: config.TypePreferIP{
Value: value,
},
}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.Equal(t, strings.ToLower(value), testStruct.Value.String())
marshalled, err := testStruct.Value.MarshalText()
encodedJSON, err := json.Marshal(testStruct)
assert.NoError(t, err)
assert.Equal(t, strings.ToLower(value), string(marshalled))
expectedJSON, err := json.Marshal(map[string]string{
"value": value,
})
assert.NoError(t, err)
assert.JSONEq(t, string(expectedJSON), string(encodedJSON))
})
}
}
func (suite *TypePreferIPTestSuite) TestValue() {
testStruct := &typePreferIPTestStruct{}
func (suite *TypePreferIPTestSuite) TestGet() {
value := config.TypePreferIP{}
suite.Equal(config.TypePreferIPPreferIPv4,
value.Get(config.TypePreferIPPreferIPv4))
suite.EqualValues(config.TypePreferIPPreferIPv4,
testStruct.Value.Value(config.TypePreferIPPreferIPv4))
suite.EqualValues(config.TypePreferIPPreferIPv6,
testStruct.Value.Value(config.TypePreferIPPreferIPv6))
data, err := json.Marshal(map[string]string{
"value": config.TypePreferOnlyIPv4,
})
suite.NoError(err)
suite.NoError(json.Unmarshal(data, testStruct))
suite.EqualValues(config.TypePreferOnlyIPv4,
testStruct.Value.Value(config.TypePreferOnlyIPv6))
suite.EqualValues(config.TypePreferOnlyIPv4,
testStruct.Value.Value(config.TypePreferIPPreferIPv6))
suite.NoError(value.Set(config.TypePreferIPPreferIPv6))
suite.Equal(config.TypePreferIPPreferIPv6,
value.Get(config.TypePreferIPPreferIPv4))
}
func TestTypePreferIP(t *testing.T) {
internal/config/type_proxy_url.go
+61
View File
@@ -0,0 +1,61 @@
package config
import (
"fmt"
"net"
"net/url"
)
const typeProxyURLDefaultSOCKS5Port = "1080"
type TypeProxyURL struct {
Value *url.URL
}
func (t *TypeProxyURL) Set(value string) error {
parsedURL, err := url.Parse(value)
if err != nil {
return fmt.Errorf("Value is not corect URL (%s): %w", value, err)
}
if parsedURL.Host == "" {
return fmt.Errorf("url has to have a schema: %s", value)
}
if parsedURL.Scheme != "socks5" {
return fmt.Errorf("unsupported schema: %s", parsedURL.Scheme)
}
if _, _, err := net.SplitHostPort(parsedURL.Host); err != nil {
parsedURL.Host = net.JoinHostPort(parsedURL.Host,
typeProxyURLDefaultSOCKS5Port)
}
t.Value = parsedURL
return nil
}
func (t *TypeProxyURL) Get(defaultValue *url.URL) *url.URL {
if t.Value == nil {
return defaultValue
}
return t.Value
}
func (t *TypeProxyURL) UnmarshalText(data []byte) error {
return t.Set(string(data))
}
func (t TypeProxyURL) MarshalText() ([]byte, error) {
return []byte(t.String()), nil
}
func (t TypeProxyURL) String() string {
if t.Value == nil {
return ""
}
return t.Value.String()
}
internal/config/type_proxy_url_test.go
+96
View File
@@ -0,0 +1,96 @@
package config_test
import (
"encoding/json"
"net/url"
"testing"
"github.com/9seconds/mtg/v2/internal/config"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/suite"
)
type typeProxyURLTestStruct struct {
Value config.TypeProxyURL `json:"value"`
}
type ProxyURLTestSuite struct {
suite.Suite
}
func (suite *ProxyURLTestSuite) TestUnmarshalFail() {
testData := []string{
"",
"socks5://",
"://lala",
"/path",
}
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, &typeProxyURLTestStruct{}))
})
}
}
func (suite *ProxyURLTestSuite) TestUnmarshalOk() {
testData := map[string]string{
"socks5://127.0.0.1/?open_threshold=1": "socks5://127.0.0.1:1080/?open_threshold=1",
"socks5://127.0.0.1:80": "socks5://127.0.0.1:80",
}
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 := &typeProxyURLTestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
parsed, _ := url.Parse(value)
assert.Equal(t, parsed.Scheme, testStruct.Value.Get(nil).Scheme)
assert.Equal(t, parsed.Host, testStruct.Value.Get(nil).Host)
assert.Equal(t, parsed.RawQuery, testStruct.Value.Get(nil).RawQuery)
assert.Equal(t, parsed.Path, testStruct.Value.Get(nil).Path)
})
}
}
func (suite *ProxyURLTestSuite) TestMarshalOk() {
parsed, _ := url.Parse("socks5://127.0.0.1:1080?open_threshold=1")
testStruct := &typeProxyURLTestStruct{
Value: config.TypeProxyURL{
Value: parsed,
},
}
encodedJSON, err := json.Marshal(testStruct)
suite.NoError(err)
suite.JSONEq(`{"value": "socks5://127.0.0.1:1080?open_threshold=1"}`,
string(encodedJSON))
}
func (suite *ProxyURLTestSuite) TestGet() {
emptyURL := &url.URL{}
value := config.TypeProxyURL{}
suite.Equal(emptyURL, value.Get(emptyURL))
value.Value = &url.URL{}
suite.Equal(value.Value, value.Get(emptyURL))
}
func TestTypeProxyURL(t *testing.T) {
t.Parallel()
suite.Run(t, &ProxyURLTestSuite{})
}
internal/config/type_statsd_tag_format.go
+25 -24
View File
@@ -20,38 +20,39 @@ const (
)
type TypeStatsdTagFormat struct {
value string
Value string
}
func (c *TypeStatsdTagFormat) UnmarshalText(data []byte) error {
if len(data) == 0 {
func (t *TypeStatsdTagFormat) Set(value string) error {
lowercasedValue := strings.ToLower(value)
switch lowercasedValue {
case TypeStatsdTagFormatDatadog, TypeStatsdTagFormatInfluxdb,
TypeStatsdTagFormatGraphite:
t.Value = lowercasedValue
return nil
}
text := strings.ToLower(string(data))
switch text {
case TypeStatsdTagFormatInfluxdb, TypeStatsdTagFormatDatadog, TypeStatsdTagFormatGraphite:
c.value = text
default:
return fmt.Errorf("incorrect tag format value: %s", string(data))
return fmt.Errorf("unknown tag format %s", value)
}
return nil
}
func (c TypeStatsdTagFormat) MarshalText() ([]byte, error) {
return []byte(c.value), nil
}
func (c *TypeStatsdTagFormat) String() string {
return c.value
}
func (c *TypeStatsdTagFormat) Value(defaultValue string) string {
if c.value == "" {
func (t TypeStatsdTagFormat) Get(defaultValue string) string {
if t.Value == "" {
return defaultValue
}
return c.value
return t.Value
}
func (t *TypeStatsdTagFormat) UnmarshalText(data []byte) error {
return t.Set(string(data))
}
func (t *TypeStatsdTagFormat) MarshalText() ([]byte, error) {
return []byte(t.String()), nil
}
func (t *TypeStatsdTagFormat) String() string {
return t.Value
}
internal/config/type_statsd_tag_format_test.go
+31 -59
View File
@@ -14,22 +14,14 @@ type typeStatsdTagFormatTestStruct struct {
Value config.TypeStatsdTagFormat `json:"value"`
}
type TypeStatsdTagFormatTestSuite struct {
type StatsdTagFormatTestSuite struct {
suite.Suite
}
func (suite *TypeStatsdTagFormatTestSuite) TestUnmarshalNil() {
typ := &config.TypeStatsdTagFormat{}
suite.NoError(typ.UnmarshalText(nil))
suite.Equal("lalala", typ.Value("lalala"))
}
func (suite *TypeStatsdTagFormatTestSuite) TestUnmarshalFail() {
func (suite *StatsdTagFormatTestSuite) TestUnmarshalFail() {
testData := []string{
"p",
"ipv4",
"onlyipv4",
"ipv6prefer",
"",
"dogdog",
}
for _, v := range testData {
@@ -44,17 +36,14 @@ func (suite *TypeStatsdTagFormatTestSuite) TestUnmarshalFail() {
}
}
func (suite *TypeStatsdTagFormatTestSuite) TestUnmarshalOk() {
func (suite *StatsdTagFormatTestSuite) TestUnmarshalOk() {
testData := []string{
config.TypeStatsdTagFormatDatadog,
config.TypeStatsdTagFormatInfluxdb,
config.TypeStatsdTagFormatGraphite,
strings.ToUpper(config.TypeStatsdTagFormatDatadog),
config.TypeStatsdTagFormatDatadog,
strings.ToUpper(config.TypeStatsdTagFormatInfluxdb),
strings.ToUpper(config.TypeStatsdTagFormatGraphite),
strings.ToLower(config.TypeStatsdTagFormatDatadog),
strings.ToLower(config.TypeStatsdTagFormatInfluxdb),
strings.ToLower(config.TypeStatsdTagFormatGraphite),
strings.ToUpper(config.TypeStatsdTagFormatDatadog),
}
for _, v := range testData {
@@ -67,70 +56,53 @@ func (suite *TypeStatsdTagFormatTestSuite) TestUnmarshalOk() {
suite.T().Run(v, func(t *testing.T) {
testStruct := &typeStatsdTagFormatTestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.EqualValues(t,
strings.ToLower(value),
testStruct.Value.Value(config.TypeStatsdTagFormatDatadog))
assert.Equal(t, strings.ToLower(value), testStruct.Value.Value)
})
}
}
func (suite *TypeStatsdTagFormatTestSuite) TestMarshalOk() {
func (suite *StatsdTagFormatTestSuite) TestMarshalOk() {
testData := []string{
config.TypeStatsdTagFormatDatadog,
config.TypeStatsdTagFormatInfluxdb,
config.TypeStatsdTagFormatGraphite,
strings.ToUpper(config.TypeStatsdTagFormatDatadog),
strings.ToUpper(config.TypeStatsdTagFormatInfluxdb),
strings.ToUpper(config.TypeStatsdTagFormatGraphite),
strings.ToLower(config.TypeStatsdTagFormatDatadog),
strings.ToLower(config.TypeStatsdTagFormatInfluxdb),
strings.ToLower(config.TypeStatsdTagFormatGraphite),
config.TypeStatsdTagFormatDatadog,
}
for _, v := range testData {
value := v
data, err := json.Marshal(map[string]string{
"value": v,
})
suite.NoError(err)
suite.T().Run(v, func(t *testing.T) {
testStruct := &typeStatsdTagFormatTestStruct{}
testStruct := &typeStatsdTagFormatTestStruct{
Value: config.TypeStatsdTagFormat{
Value: value,
},
}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.Equal(t, strings.ToLower(value), testStruct.Value.String())
marshalled, err := testStruct.Value.MarshalText()
encodedJSON, err := json.Marshal(testStruct)
assert.NoError(t, err)
assert.Equal(t, strings.ToLower(value), string(marshalled))
expectedJSON, err := json.Marshal(map[string]string{
"value": value,
})
assert.NoError(t, err)
assert.JSONEq(t, string(expectedJSON), string(encodedJSON))
})
}
}
func (suite *TypeStatsdTagFormatTestSuite) TestValue() {
testStruct := &typePreferIPTestStruct{}
func (suite *StatsdTagFormatTestSuite) TestGet() {
value := config.TypeStatsdTagFormat{}
suite.Equal(config.TypeStatsdTagFormatDatadog,
value.Get(config.TypeStatsdTagFormatDatadog))
suite.EqualValues(config.TypePreferIPPreferIPv4,
testStruct.Value.Value(config.TypePreferIPPreferIPv4))
suite.EqualValues(config.TypePreferIPPreferIPv6,
testStruct.Value.Value(config.TypePreferIPPreferIPv6))
data, err := json.Marshal(map[string]string{
"value": config.TypePreferOnlyIPv4,
})
suite.NoError(err)
suite.NoError(json.Unmarshal(data, testStruct))
suite.EqualValues(config.TypePreferOnlyIPv4,
testStruct.Value.Value(config.TypePreferOnlyIPv6))
suite.EqualValues(config.TypePreferOnlyIPv4,
testStruct.Value.Value(config.TypePreferIPPreferIPv6))
suite.NoError(value.Set(config.TypeStatsdTagFormatInfluxdb))
suite.Equal(config.TypeStatsdTagFormatInfluxdb,
value.Get(config.TypeStatsdTagFormatDatadog))
}
func TestTypeStatsdTagFormat(t *testing.T) {
t.Parallel()
suite.Run(t, &TypeStatsdTagFormatTestSuite{})
suite.Run(t, &StatsdTagFormatTestSuite{})
}
internal/config/type_url.go
-71
View File
@@ -1,71 +0,0 @@
package config
import (
"fmt"
"net"
"net/url"
)
type TypeURL struct {
value *url.URL
}
func (c *TypeURL) UnmarshalText(data []byte) error { // nolint: cyclop
if len(data) == 0 {
return nil
}
value, err := url.Parse(string(data))
if err != nil {
return fmt.Errorf("incorrect URL: %w", err)
}
switch value.Scheme {
case "http", "https", "socks5":
case "":
return fmt.Errorf("url %s has to have a schema", value)
default:
return fmt.Errorf("unsupported schema %s", value.Scheme)
}
if value.Host == "" {
return fmt.Errorf("url %s has to have a host", value)
}
if _, _, err := net.SplitHostPort(value.Host); err != nil {
switch value.Scheme {
case "http":
value.Host = net.JoinHostPort(value.Host, "80")
case "https":
value.Host = net.JoinHostPort(value.Host, "443")
case "socks5":
value.Host = net.JoinHostPort(value.Host, "1080")
default:
return fmt.Errorf("cannot set a default port for %s", value)
}
}
c.value = value
return nil
}
func (c *TypeURL) MarshalText() ([]byte, error) {
return []byte(c.String()), nil
}
func (c TypeURL) String() string {
if c.value == nil {
return ""
}
return c.value.String()
}
func (c TypeURL) Value(defaultValue *url.URL) *url.URL {
if c.value == nil {
return defaultValue
}
return c.value
}
internal/config/type_url_test.go
-107
View File
@@ -1,107 +0,0 @@
package config_test
import (
"encoding/json"
"net/url"
"testing"
"github.com/9seconds/mtg/v2/internal/config"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/suite"
)
type typeURLTestStruct struct {
Value config.TypeURL `json:"value"`
}
type TypeURLTestSuite struct {
suite.Suite
}
func (suite *TypeURLTestSuite) TestUnmarshalNil() {
u, _ := url.Parse("https://google.com")
typ := &config.TypeURL{}
suite.NoError(typ.UnmarshalText(nil))
suite.Empty(typ.String())
suite.Equal("https://google.com", typ.Value(u).String())
}
func (suite *TypeURLTestSuite) TestUnmarshalFail() {
testData := []string{
"http:/aaa.com",
"ipv4",
"111",
"://111",
"http://aaa.com:xxx",
"gopher://aaa.com:888",
"gopher://aaa.com",
}
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, &typeURLTestStruct{}))
})
}
}
func (suite *TypeURLTestSuite) TestUnmarshalOk() {
testData := map[string]string{
"https://10.0.0.10:80": "https://10.0.0.10:80",
"https://10.0.0.10:443": "https://10.0.0.10",
"http://10.0.0.10:8": "http://10.0.0.10:8",
"http://10.0.0.10:80": "http://10.0.0.10",
"socks5://10.0.0.10:1080": "socks5://10.0.0.10",
"socks5://10.0.0.10:888": "socks5://10.0.0.10:888",
}
for k, v := range testData {
expected := k
actual := v
data, err := json.Marshal(map[string]string{
"value": actual,
})
suite.NoError(err)
suite.T().Run(actual, func(t *testing.T) {
testStruct := &typeURLTestStruct{}
assert.NoError(t, json.Unmarshal(data, testStruct))
assert.Equal(t, expected, testStruct.Value.Value(nil).String())
marshalled, err := testStruct.Value.MarshalText()
assert.NoError(t, err)
assert.Equal(t, expected, string(marshalled))
})
}
}
func (suite *TypeURLTestSuite) TestValue() {
testStruct := &typeURLTestStruct{}
u1, _ := url.Parse("https://10.0.0.10:80")
u2, _ := url.Parse("https://10.1.0.10:80")
suite.Equal("https://10.0.0.10:80", testStruct.Value.Value(u1).String())
suite.Equal("https://10.1.0.10:80", testStruct.Value.Value(u2).String())
data, err := json.Marshal(map[string]string{
"value": "http://127.0.0.1:80",
})
suite.NoError(err)
suite.NoError(json.Unmarshal(data, testStruct))
suite.Equal("http://127.0.0.1:80", testStruct.Value.Value(u1).String())
suite.Equal("http://127.0.0.1:80", testStruct.Value.Value(u2).String())
}
func TestTypeURL(t *testing.T) {
t.Parallel()
suite.Run(t, &TypeURLTestSuite{})
}