Merge pull request #114 from aykhans/core/refactor

General refactor
🔧 Add 'skip-verify' parameter to skip SSL/TLS cert verification
2025-07-18 07:04:02 +00:00 · 2025-05-29 02:42:57 +04:00 · 2025-05-29 02:38:07 +04:00 · 2025-05-29 00:38:48 +04:00 · 2025-05-25 19:18:03 +04:00 · 2025-05-25 19:16:30 +04:00
22 changed files with 85 additions and 1075 deletions
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -31,9 +31,3 @@ linters:
                - "all"
                - "-S1002"
                - "-ST1000"
-
-    exclusions:
-        rules:
-        - path: _test\.go
-          linters:
-            - errcheck
--- a/README.md
+++ b/README.md
@@ -84,6 +84,7 @@ Send 1000 GET requests to https://example.com with 10 parallel dodos (threads),
    "dodos": 10,
    "requests": 1000,
    "duration": "250s",
+    "skip_verify": false,

    "params": [
        // A random value will be selected from the list for first "key1" param on each request
@@ -162,6 +163,7 @@ timeout: "800ms"
 dodos: 10
 requests: 1000
 duration: "250s"
+skip_verify: false

 params:
    # A random value will be selected from the list for first "key1" param on each request
@@ -248,7 +250,7 @@ If `Headers`, `Params`, `Cookies`, `Body`, or `Proxy` fields have multiple value

 | Parameter       | config file | CLI Flag     | CLI Short Flag | Type                           | Description                                                 | Default |
 | --------------- | ----------- | ------------ | -------------- | ------------------------------ | ----------------------------------------------------------- | ------- |
-| Config file     | -           | -config-file | -f             | String                         | Path to local config file or http(s) URL of the config file | -       |
+| Config file     |             | -config-file | -f             | String                         | Path to local config file or http(s) URL of the config file | -       |
 | Yes             | yes         | -yes         | -y             | Boolean                        | Answer yes to all questions                                 | false   |
 | URL             | url         | -url         | -u             | String                         | URL to send the request to                                  | -       |
 | Method          | method      | -method      | -m             | String                         | HTTP method                                                 | GET     |
@@ -261,3 +263,4 @@ If `Headers`, `Params`, `Cookies`, `Body`, or `Proxy` fields have multiple value
 | Cookies         | cookies     | -cookie      | -c             | [{String: String OR [String]}] | Request cookies                                             | -       |
 | Body            | body        | -body        | -b             | String OR [String]             | Request body or list of request bodies                      | -       |
 | Proxy           | proxies     | -proxy       | -x             | String OR [String]             | Proxy URL or list of proxy URLs                             | -       |
+| Skip Verify     | skip_verify | -skip-verify |                | Boolean                        | Skip SSL/TLS certificate verification                       | false   |
--- a/Taskfile.yaml
+++ b/Taskfile.yaml
@@ -20,11 +20,17 @@ vars:
 tasks:
    run: go run main.go

+    ftl:
+        cmds:
+            - task: fmt
+            - task: tidy
+            - task: lint
+
    fmt: gofmt -w -d .

-    lint: golangci-lint run
+    tidy: go mod tidy

-    test: go test ./...
+    lint: golangci-lint run

    build: go build -ldflags "-s -w" -o "dodo"

--- a/config.json
+++ b/config.json
@@ -6,6 +6,7 @@
    "dodos": 8,
    "requests": 1000,
    "duration": "10s",
+    "skip_verify": false,

    "params": [
        { "key1": ["value1", "value2", "value3", "value4"] },
--- a/config.yaml
+++ b/config.yaml
@@ -5,6 +5,7 @@ timeout: "5s"
 dodos: 8
 requests: 1000
 duration: "10s"
+skip_verify: false

 params:
    - key1: ["value1", "value2", "value3", "value4"]
--- a/config/cli.go
+++ b/config/cli.go
@@ -31,7 +31,7 @@ Usage with all flags:
    -p "param1=value1" -param "param2=value2" \
    -c "cookie1=value1" -cookie "cookie2=value2" \
    -x "http://proxy.example.com:8080" -proxy "socks5://proxy2.example.com:8080" \
-    -y
+    -skip-verify -y

 Flags:
  -h, -help                   help for dodo
@@ -48,7 +48,8 @@ Flags:
  -p, -param        [string]  Parameter for the request (e.g. "key1=value1")
  -H, -header       [string]  Header for the request (e.g. "key1:value1")
  -c, -cookie       [string]  Cookie for the request (e.g. "key1=value1")
-  -x, -proxy        [string]  Proxy for the request (e.g. "http://proxy.example.com:8080")`
+  -x, -proxy        [string]  Proxy for the request (e.g. "http://proxy.example.com:8080")
+  -skip-verify      bool      Skip SSL/TLS certificate verification (default %v)`

 func (config *Config) ReadCLI() (types.ConfigFile, error) {
 	flag.Usage = func() {
@@ -58,6 +59,7 @@ func (config *Config) ReadCLI() (types.ConfigFile, error) {
 			DefaultDodosCount,
 			DefaultTimeout,
 			DefaultMethod,
+			DefaultSkipVerify,
 		)
 	}

@@ -65,6 +67,7 @@ func (config *Config) ReadCLI() (types.ConfigFile, error) {
 		version      = false
 		configFile   = ""
 		yes          = false
+		skipVerify   = false
 		method       = ""
 		url          types.RequestURL
 		dodosCount   = uint(0)
@@ -83,6 +86,8 @@ func (config *Config) ReadCLI() (types.ConfigFile, error) {
 		flag.BoolVar(&yes, "yes", false, "Answer yes to all questions")
 		flag.BoolVar(&yes, "y", false, "Answer yes to all questions")

+		flag.BoolVar(&skipVerify, "skip-verify", false, "Skip SSL/TLS certificate verification")
+
 		flag.StringVar(&method, "method", "", "HTTP Method")
 		flag.StringVar(&method, "m", "", "HTTP Method")

@@ -149,6 +154,8 @@ func (config *Config) ReadCLI() (types.ConfigFile, error) {
 			config.Timeout = &types.Timeout{Duration: timeout}
 		case "yes", "y":
 			config.Yes = utils.ToPtr(yes)
+		case "skip-verify":
+			config.SkipVerify = utils.ToPtr(skipVerify)
 		}
 	})

--- a/config/cli_test.go
+++ b/config/cli_test.go
@@ -1,159 +0,0 @@
-package config
-
-import (
-	"flag"
-	"io"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/aykhans/dodo/types"
-	"github.com/aykhans/dodo/utils"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestReadCLI(t *testing.T) {
-	tests := []struct {
-		name           string
-		args           []string
-		expectFile     types.ConfigFile
-		expectError    bool
-		expectedConfig *Config
-	}{
-		{
-			name:        "simple url and duration",
-			args:        []string{"-u", "https://example.com", "-o", "1m"},
-			expectFile:  "",
-			expectError: false,
-			expectedConfig: &Config{
-				URL:      &types.RequestURL{},
-				Duration: &types.Duration{Duration: time.Minute},
-			},
-		},
-		{
-			name:           "config file only",
-			args:           []string{"-f", "/path/to/config.json"},
-			expectFile:     "/path/to/config.json",
-			expectError:    false,
-			expectedConfig: &Config{},
-		},
-		{
-			name:        "all flags",
-			args:        []string{"-f", "/path/to/config.json", "-u", "https://example.com", "-m", "POST", "-d", "10", "-r", "1000", "-o", "3m", "-t", "3s", "-b", "body1", "-H", "header1:value1", "-p", "param1=value1", "-c", "cookie1=value1", "-x", "http://proxy.example.com:8080", "-y"},
-			expectFile:  "/path/to/config.json",
-			expectError: false,
-			expectedConfig: &Config{
-				Method:       utils.ToPtr("POST"),
-				URL:          &types.RequestURL{},
-				DodosCount:   utils.ToPtr[uint](10),
-				RequestCount: utils.ToPtr[uint](1000),
-				Duration:     &types.Duration{Duration: 3 * time.Minute},
-				Timeout:      &types.Timeout{Duration: 3 * time.Second},
-				Yes:          utils.ToPtr(true),
-			},
-		},
-		{
-			name:           "unexpected arguments",
-			args:           []string{"-u", "https://example.com", "extraArg"},
-			expectFile:     "",
-			expectError:    true,
-			expectedConfig: &Config{},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Reset flag.CommandLine to its original state
-			flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
-
-			// Override os.Args for the test
-			os.Args = append([]string{"dodo"}, tt.args...)
-
-			// Initialize a new config
-			config := NewConfig()
-
-			// Mock URL to avoid actual URL parsing issues in tests
-			if tt.expectedConfig.URL != nil {
-				urlObj := types.RequestURL{}
-				urlObj.Set("https://example.com")
-				tt.expectedConfig.URL = &urlObj
-			}
-
-			// Call the function being tested
-			file, err := config.ReadCLI()
-
-			// Assert expected results
-			assert.Equal(t, tt.expectFile, file)
-			if tt.expectError {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-
-				// Check expected config values if URL is set
-				if tt.expectedConfig.URL != nil {
-					assert.NotNil(t, config.URL)
-					assert.Equal(t, "https://example.com", config.URL.String())
-				}
-
-				// Check duration if expected
-				if tt.expectedConfig.Duration != nil {
-					assert.NotNil(t, config.Duration)
-					assert.Equal(t, tt.expectedConfig.Duration.Duration, config.Duration.Duration)
-				}
-
-				// Check other values as needed
-				if tt.expectedConfig.Method != nil {
-					assert.Equal(t, *tt.expectedConfig.Method, *config.Method)
-				}
-				if tt.expectedConfig.DodosCount != nil {
-					assert.Equal(t, *tt.expectedConfig.DodosCount, *config.DodosCount)
-				}
-				if tt.expectedConfig.RequestCount != nil {
-					assert.Equal(t, *tt.expectedConfig.RequestCount, *config.RequestCount)
-				}
-				if tt.expectedConfig.Timeout != nil {
-					assert.Equal(t, tt.expectedConfig.Timeout.Duration, config.Timeout.Duration)
-				}
-				if tt.expectedConfig.Yes != nil {
-					assert.Equal(t, *tt.expectedConfig.Yes, *config.Yes)
-				}
-			}
-		})
-	}
-}
-
-// Skip the prompt tests as they require interactive input/output handling
-// which is difficult to test reliably in unit tests
-func TestCLIYesOrNoReaderBasic(t *testing.T) {
-	// We're just going to verify the function exists and returns the default value
-	// when called with "\n" as input (which should trigger the default path)
-	result := func() bool {
-		// Save original standard input
-		origStdin := os.Stdin
-		origStdout := os.Stdout
-
-		// Create a pipe to mock standard input
-		r, w, _ := os.Pipe()
-		os.Stdin = r
-
-		// Redirect stdout to null device
-		devNull, _ := os.Open(os.DevNull)
-		os.Stdout = devNull
-
-		// Write newline to mock stdin (should trigger default behavior)
-		io.WriteString(w, "\n")
-		w.Close()
-
-		// Call the function being tested with default=true
-		result := CLIYesOrNoReader("Test message", true)
-
-		// Restore original stdin and stdout
-		os.Stdin = origStdin
-		os.Stdout = origStdout
-
-		return result
-	}()
-
-	// Default value should be returned
-	assert.True(t, result)
-}
--- a/config/config.go
+++ b/config/config.go
@@ -15,7 +15,7 @@ import (
 )

 const (
-	VERSION             string        = "0.6.3"
+	VERSION             string        = "0.6.5"
 	DefaultUserAgent    string        = "Dodo/" + VERSION
 	DefaultMethod       string        = "GET"
 	DefaultTimeout      time.Duration = time.Second * 10
@@ -23,6 +23,7 @@ const (
 	DefaultRequestCount uint          = 0
 	DefaultDuration     time.Duration = 0
 	DefaultYes          bool          = false
+	DefaultSkipVerify   bool          = false
 )

 var SupportedProxySchemes []string = []string{"http", "socks5", "socks5h"}
@@ -35,6 +36,7 @@ type RequestConfig struct {
 	RequestCount uint
 	Duration     time.Duration
 	Yes          bool
+	SkipVerify   bool
 	Params       types.Params
 	Headers      types.Headers
 	Cookies      types.Cookies
@@ -51,6 +53,7 @@ func NewRequestConfig(conf *Config) *RequestConfig {
 		RequestCount: *conf.RequestCount,
 		Duration:     conf.Duration.Duration,
 		Yes:          *conf.Yes,
+		SkipVerify:   *conf.SkipVerify,
 		Params:       conf.Params,
 		Headers:      conf.Headers,
 		Cookies:      conf.Cookies,
@@ -122,6 +125,8 @@ func (rc *RequestConfig) Print() {
 	t.AppendRow(table.Row{"Proxy", rc.Proxies.String()})
 	t.AppendSeparator()
 	t.AppendRow(table.Row{"Body", rc.Body.String()})
+	t.AppendSeparator()
+	t.AppendRow(table.Row{"Skip Verify", rc.SkipVerify})

 	t.Render()
 }
@@ -134,6 +139,7 @@ type Config struct {
 	RequestCount *uint             `json:"requests" yaml:"requests"`
 	Duration     *types.Duration   `json:"duration" yaml:"duration"`
 	Yes          *bool             `json:"yes" yaml:"yes"`
+	SkipVerify   *bool             `json:"skip_verify" yaml:"skip_verify"`
 	Params       types.Params      `json:"params" yaml:"params"`
 	Headers      types.Headers     `json:"headers" yaml:"headers"`
 	Cookies      types.Cookies     `json:"cookies" yaml:"cookies"`
@@ -220,6 +226,9 @@ func (config *Config) MergeConfig(newConfig *Config) {
 	if newConfig.Yes != nil {
 		config.Yes = newConfig.Yes
 	}
+	if newConfig.SkipVerify != nil {
+		config.SkipVerify = newConfig.SkipVerify
+	}
 	if len(newConfig.Params) != 0 {
 		config.Params = newConfig.Params
 	}
@@ -256,5 +265,8 @@ func (config *Config) SetDefaults() {
 	if config.Yes == nil {
 		config.Yes = utils.ToPtr(DefaultYes)
 	}
+	if config.SkipVerify == nil {
+		config.SkipVerify = utils.ToPtr(DefaultSkipVerify)
+	}
 	config.Headers.SetIfNotExists("User-Agent", DefaultUserAgent)
 }
--- a/config/config_test.go
+++ b/config/config_test.go
@@ -1,515 +0,0 @@
-package config
-
-import (
-	"net/url"
-	"os"
-	"slices"
-	"testing"
-	"time"
-
-	"github.com/aykhans/dodo/types"
-	"github.com/aykhans/dodo/utils"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestNewConfig(t *testing.T) {
-	config := NewConfig()
-	assert.NotNil(t, config)
-	assert.IsType(t, &Config{}, config)
-}
-
-func TestNewRequestConfig(t *testing.T) {
-	// Create a sample Config object
-	urlObj := types.RequestURL{}
-	urlObj.Set("https://example.com")
-
-	conf := &Config{
-		Method:       utils.ToPtr("GET"),
-		URL:          &urlObj,
-		Timeout:      &types.Timeout{Duration: 5 * time.Second},
-		DodosCount:   utils.ToPtr(uint(10)),
-		RequestCount: utils.ToPtr(uint(100)),
-		Duration:     &types.Duration{Duration: 1 * time.Minute},
-		Yes:          utils.ToPtr(true),
-		Params:       types.Params{{Key: "key1", Value: []string{"value1"}}},
-		Headers:      types.Headers{{Key: "User-Agent", Value: []string{"TestAgent"}}},
-		Cookies:      types.Cookies{{Key: "session", Value: []string{"123"}}},
-		Body:         types.Body{"test body"},
-		Proxies:      types.Proxies{url.URL{Scheme: "http", Host: "proxy.example.com:8080"}},
-	}
-
-	// Call the function being tested
-	rc := NewRequestConfig(conf)
-
-	// Assert the fields are correctly mapped
-	assert.Equal(t, "GET", rc.Method)
-	assert.Equal(t, "https://example.com", rc.URL.String())
-	assert.Equal(t, 5*time.Second, rc.Timeout)
-	assert.Equal(t, uint(10), rc.DodosCount)
-	assert.Equal(t, uint(100), rc.RequestCount)
-	assert.Equal(t, 1*time.Minute, rc.Duration)
-	assert.True(t, rc.Yes)
-	assert.Equal(t, types.Params{{Key: "key1", Value: []string{"value1"}}}, rc.Params)
-	assert.Equal(t, types.Headers{{Key: "User-Agent", Value: []string{"TestAgent"}}}, rc.Headers)
-	assert.Equal(t, types.Cookies{{Key: "session", Value: []string{"123"}}}, rc.Cookies)
-	assert.Equal(t, types.Body{"test body"}, rc.Body)
-	assert.Equal(t, types.Proxies{url.URL{Scheme: "http", Host: "proxy.example.com:8080"}}, rc.Proxies)
-}
-
-func TestGetValidDodosCountForRequests(t *testing.T) {
-	tests := []struct {
-		name         string
-		dodosCount   uint
-		requestCount uint
-		expected     uint
-	}{
-		{
-			name:         "no request count limit",
-			dodosCount:   10,
-			requestCount: 0,
-			expected:     10,
-		},
-		{
-			name:         "dodos count less than request count",
-			dodosCount:   5,
-			requestCount: 100,
-			expected:     5,
-		},
-		{
-			name:         "dodos count greater than request count",
-			dodosCount:   100,
-			requestCount: 10,
-			expected:     10,
-		},
-		{
-			name:         "dodos count equal to request count",
-			dodosCount:   50,
-			requestCount: 50,
-			expected:     50,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			rc := &RequestConfig{
-				DodosCount:   tt.dodosCount,
-				RequestCount: tt.requestCount,
-			}
-			result := rc.GetValidDodosCountForRequests()
-			assert.Equal(t, tt.expected, result)
-		})
-	}
-}
-
-func TestGetMaxConns(t *testing.T) {
-	tests := []struct {
-		name         string
-		dodosCount   uint
-		requestCount uint
-		minConns     uint
-		expected     uint
-	}{
-		{
-			name:         "min connections higher than valid dodos count",
-			dodosCount:   10,
-			requestCount: 0,
-			minConns:     20,
-			expected:     30, // 20 * 150%
-		},
-		{
-			name:         "min connections lower than valid dodos count",
-			dodosCount:   30,
-			requestCount: 0,
-			minConns:     10,
-			expected:     45, // 30 * 150%
-		},
-		{
-			name:         "request count limits dodos count",
-			dodosCount:   100,
-			requestCount: 20,
-			minConns:     5,
-			expected:     30, // 20 * 150%
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			rc := &RequestConfig{
-				DodosCount:   tt.dodosCount,
-				RequestCount: tt.requestCount,
-			}
-			result := rc.GetMaxConns(tt.minConns)
-			assert.Equal(t, tt.expected, result)
-		})
-	}
-}
-
-// Skip the Print test as it's mainly a formatting function
-// that uses external table rendering library
-func TestRequestConfigPrint(t *testing.T) {
-	// Create a sample RequestConfig
-	rc := &RequestConfig{
-		Method:       "GET",
-		URL:          url.URL{Scheme: "https", Host: "example.com"},
-		Timeout:      5 * time.Second,
-		DodosCount:   10,
-		RequestCount: 100,
-		Duration:     1 * time.Minute,
-		Params:       types.Params{{Key: "param1", Value: []string{"value1"}}},
-		Headers:      types.Headers{{Key: "User-Agent", Value: []string{"TestAgent"}}},
-		Cookies:      types.Cookies{{Key: "session", Value: []string{"123"}}},
-		Body:         types.Body{"test body"},
-		Proxies:      types.Proxies{url.URL{Scheme: "http", Host: "proxy.example.com:8080"}},
-	}
-
-	// We'll just call the function to ensure it doesn't panic
-	// Redirect output to /dev/null
-	origStdout := os.Stdout
-	devNull, _ := os.Open(os.DevNull)
-	os.Stdout = devNull
-
-	// Call the function
-	rc.Print()
-
-	// Restore stdout
-	os.Stdout = origStdout
-
-	// No assertions needed, we're just checking that it doesn't panic
-}
-
-func TestConfigValidate(t *testing.T) {
-	tests := []struct {
-		name           string
-		config         *Config
-		expectedErrors int
-		expectURLQuery bool
-	}{
-		{
-			name: "valid config",
-			config: &Config{
-				Method:       utils.ToPtr("GET"),
-				URL:          func() *types.RequestURL { u := &types.RequestURL{}; u.Set("https://example.com"); return u }(),
-				Timeout:      &types.Timeout{Duration: 5 * time.Second},
-				DodosCount:   utils.ToPtr(uint(10)),
-				RequestCount: utils.ToPtr(uint(100)),
-				Duration:     &types.Duration{Duration: 1 * time.Minute},
-			},
-			expectedErrors: 0,
-			expectURLQuery: false,
-		},
-		{
-			name: "missing URL",
-			config: &Config{
-				Method:       utils.ToPtr("GET"),
-				URL:          nil,
-				Timeout:      &types.Timeout{Duration: 5 * time.Second},
-				DodosCount:   utils.ToPtr(uint(10)),
-				RequestCount: utils.ToPtr(uint(100)),
-				Duration:     &types.Duration{Duration: 1 * time.Minute},
-			},
-			expectedErrors: 1,
-			expectURLQuery: false,
-		},
-		{
-			name: "missing method",
-			config: &Config{
-				Method:       nil,
-				URL:          func() *types.RequestURL { u := &types.RequestURL{}; u.Set("https://example.com"); return u }(),
-				Timeout:      &types.Timeout{Duration: 5 * time.Second},
-				DodosCount:   utils.ToPtr(uint(10)),
-				RequestCount: utils.ToPtr(uint(100)),
-				Duration:     &types.Duration{Duration: 1 * time.Minute},
-			},
-			expectedErrors: 1,
-			expectURLQuery: false,
-		},
-		{
-			name: "invalid URL scheme",
-			config: &Config{
-				Method:       utils.ToPtr("GET"),
-				URL:          func() *types.RequestURL { u := &types.RequestURL{}; u.Scheme = "ftp"; u.Host = "example.com"; return u }(),
-				Timeout:      &types.Timeout{Duration: 5 * time.Second},
-				DodosCount:   utils.ToPtr(uint(10)),
-				RequestCount: utils.ToPtr(uint(100)),
-				Duration:     &types.Duration{Duration: 1 * time.Minute},
-			},
-			expectedErrors: 1,
-			expectURLQuery: false,
-		},
-		{
-			name: "missing both duration and request count",
-			config: &Config{
-				Method:       utils.ToPtr("GET"),
-				URL:          func() *types.RequestURL { u := &types.RequestURL{}; u.Set("https://example.com"); return u }(),
-				Timeout:      &types.Timeout{Duration: 5 * time.Second},
-				DodosCount:   utils.ToPtr(uint(10)),
-				RequestCount: utils.ToPtr(uint(0)),
-				Duration:     &types.Duration{Duration: 0},
-			},
-			expectedErrors: 1,
-			expectURLQuery: false,
-		},
-		{
-			name: "URL with query parameters",
-			config: &Config{
-				Method: utils.ToPtr("GET"),
-				URL: func() *types.RequestURL {
-					u := &types.RequestURL{}
-					u.Set("https://example.com?param1=value1&param2=value2")
-					return u
-				}(),
-				Timeout:      &types.Timeout{Duration: 5 * time.Second},
-				DodosCount:   utils.ToPtr(uint(10)),
-				RequestCount: utils.ToPtr(uint(100)),
-				Duration:     &types.Duration{Duration: 1 * time.Minute},
-			},
-			expectedErrors: 0,
-			expectURLQuery: true,
-		},
-		{
-			name: "invalid proxy scheme",
-			config: &Config{
-				Method:       utils.ToPtr("GET"),
-				URL:          func() *types.RequestURL { u := &types.RequestURL{}; u.Set("https://example.com"); return u }(),
-				Timeout:      &types.Timeout{Duration: 5 * time.Second},
-				DodosCount:   utils.ToPtr(uint(10)),
-				RequestCount: utils.ToPtr(uint(100)),
-				Duration:     &types.Duration{Duration: 1 * time.Minute},
-				Proxies:      types.Proxies{url.URL{Scheme: "invalid", Host: "proxy.example.com:8080"}},
-			},
-			expectedErrors: 1,
-			expectURLQuery: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			errors := tt.config.Validate()
-
-			// Check number of errors
-			assert.Len(t, errors, tt.expectedErrors)
-
-			// Check if URL query parameters are extracted properly
-			if tt.expectURLQuery {
-				assert.Empty(t, tt.config.URL.RawQuery)
-				assert.NotEmpty(t, tt.config.Params)
-				found := false
-				for _, param := range tt.config.Params {
-					if param.Key == "param1" && len(param.Value) > 0 && param.Value[0] == "value1" {
-						found = true
-						break
-					}
-				}
-				assert.True(t, found, "Expected param1=value1 in Params but not found")
-			}
-		})
-	}
-}
-
-func TestMergeConfig(t *testing.T) {
-	baseURL := func() *types.RequestURL { u := &types.RequestURL{}; u.Set("https://example.com"); return u }()
-	newURL := func() *types.RequestURL { u := &types.RequestURL{}; u.Set("https://new-example.com"); return u }()
-
-	baseConfig := &Config{
-		Method:       utils.ToPtr("GET"),
-		URL:          baseURL,
-		Timeout:      &types.Timeout{Duration: 5 * time.Second},
-		DodosCount:   utils.ToPtr(uint(10)),
-		RequestCount: utils.ToPtr(uint(100)),
-		Duration:     &types.Duration{Duration: 1 * time.Minute},
-		Yes:          utils.ToPtr(false),
-		Params:       types.Params{{Key: "base-param", Value: []string{"base-value"}}},
-		Headers:      types.Headers{{Key: "base-header", Value: []string{"base-value"}}},
-		Cookies:      types.Cookies{{Key: "base-cookie", Value: []string{"base-value"}}},
-		Body:         types.Body{"base-body"},
-		Proxies:      types.Proxies{url.URL{Scheme: "http", Host: "base-proxy.example.com:8080"}},
-	}
-
-	tests := []struct {
-		name       string
-		newConfig  *Config
-		assertions func(t *testing.T, result *Config)
-	}{
-		{
-			name: "merge all fields",
-			newConfig: &Config{
-				Method:       utils.ToPtr("POST"),
-				URL:          newURL,
-				Timeout:      &types.Timeout{Duration: 10 * time.Second},
-				DodosCount:   utils.ToPtr(uint(20)),
-				RequestCount: utils.ToPtr(uint(200)),
-				Duration:     &types.Duration{Duration: 2 * time.Minute},
-				Yes:          utils.ToPtr(true),
-				Params:       types.Params{{Key: "new-param", Value: []string{"new-value"}}},
-				Headers:      types.Headers{{Key: "new-header", Value: []string{"new-value"}}},
-				Cookies:      types.Cookies{{Key: "new-cookie", Value: []string{"new-value"}}},
-				Body:         types.Body{"new-body"},
-				Proxies:      types.Proxies{url.URL{Scheme: "http", Host: "new-proxy.example.com:8080"}},
-			},
-			assertions: func(t *testing.T, result *Config) {
-				assert.Equal(t, "POST", *result.Method)
-				assert.Equal(t, "https://new-example.com", result.URL.String())
-				assert.Equal(t, 10*time.Second, result.Timeout.Duration)
-				assert.Equal(t, uint(20), *result.DodosCount)
-				assert.Equal(t, uint(200), *result.RequestCount)
-				assert.Equal(t, 2*time.Minute, result.Duration.Duration)
-				assert.True(t, *result.Yes)
-				assert.Equal(t, types.Params{{Key: "new-param", Value: []string{"new-value"}}}, result.Params)
-				assert.Equal(t, types.Headers{{Key: "new-header", Value: []string{"new-value"}}}, result.Headers)
-				assert.Equal(t, types.Cookies{{Key: "new-cookie", Value: []string{"new-value"}}}, result.Cookies)
-				assert.Equal(t, types.Body{"new-body"}, result.Body)
-				assert.Equal(t, types.Proxies{url.URL{Scheme: "http", Host: "new-proxy.example.com:8080"}}, result.Proxies)
-			},
-		},
-		{
-			name: "merge only specified fields",
-			newConfig: &Config{
-				Method: utils.ToPtr("POST"),
-				URL:    newURL,
-				Yes:    utils.ToPtr(true),
-			},
-			assertions: func(t *testing.T, result *Config) {
-				assert.Equal(t, "POST", *result.Method)
-				assert.Equal(t, "https://new-example.com", result.URL.String())
-				assert.Equal(t, 5*time.Second, result.Timeout.Duration)                                                      // unchanged
-				assert.Equal(t, uint(10), *result.DodosCount)                                                                // unchanged
-				assert.Equal(t, uint(100), *result.RequestCount)                                                             // unchanged
-				assert.Equal(t, 1*time.Minute, result.Duration.Duration)                                                     // unchanged
-				assert.True(t, *result.Yes)                                                                                  // changed
-				assert.Equal(t, types.Params{{Key: "base-param", Value: []string{"base-value"}}}, result.Params)             // unchanged
-				assert.Equal(t, types.Headers{{Key: "base-header", Value: []string{"base-value"}}}, result.Headers)          // unchanged
-				assert.Equal(t, types.Cookies{{Key: "base-cookie", Value: []string{"base-value"}}}, result.Cookies)          // unchanged
-				assert.Equal(t, types.Body{"base-body"}, result.Body)                                                        // unchanged
-				assert.Equal(t, types.Proxies{url.URL{Scheme: "http", Host: "base-proxy.example.com:8080"}}, result.Proxies) // unchanged
-			},
-		},
-		{
-			name:      "merge empty config",
-			newConfig: &Config{},
-			assertions: func(t *testing.T, result *Config) {
-				// All fields should remain unchanged
-				assert.Equal(t, "GET", *result.Method)
-				assert.Equal(t, "https://example.com", result.URL.String())
-				assert.Equal(t, 5*time.Second, result.Timeout.Duration)
-				assert.Equal(t, uint(10), *result.DodosCount)
-				assert.Equal(t, uint(100), *result.RequestCount)
-				assert.Equal(t, 1*time.Minute, result.Duration.Duration)
-				assert.False(t, *result.Yes)
-				assert.Equal(t, types.Params{{Key: "base-param", Value: []string{"base-value"}}}, result.Params)
-				assert.Equal(t, types.Headers{{Key: "base-header", Value: []string{"base-value"}}}, result.Headers)
-				assert.Equal(t, types.Cookies{{Key: "base-cookie", Value: []string{"base-value"}}}, result.Cookies)
-				assert.Equal(t, types.Body{"base-body"}, result.Body)
-				assert.Equal(t, types.Proxies{url.URL{Scheme: "http", Host: "base-proxy.example.com:8080"}}, result.Proxies)
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Create a copy of the base config for each test
-			baseURL := func() *types.RequestURL { u := &types.RequestURL{}; u.Set("https://example.com"); return u }()
-			testConfig := &Config{
-				Method:       utils.ToPtr(*baseConfig.Method),
-				URL:          baseURL,
-				Timeout:      &types.Timeout{Duration: baseConfig.Timeout.Duration},
-				DodosCount:   utils.ToPtr(*baseConfig.DodosCount),
-				RequestCount: utils.ToPtr(*baseConfig.RequestCount),
-				Duration:     &types.Duration{Duration: baseConfig.Duration.Duration},
-				Yes:          utils.ToPtr(*baseConfig.Yes),
-				Params:       slices.Clone(baseConfig.Params),
-				Headers:      slices.Clone(baseConfig.Headers),
-				Cookies:      slices.Clone(baseConfig.Cookies),
-				Body:         slices.Clone(baseConfig.Body),
-				Proxies:      slices.Clone(baseConfig.Proxies),
-			}
-
-			// Call the function being tested
-			testConfig.MergeConfig(tt.newConfig)
-
-			// Run assertions
-			tt.assertions(t, testConfig)
-		})
-	}
-}
-
-func TestSetDefaults(t *testing.T) {
-	tests := []struct {
-		name     string
-		config   *Config
-		validate func(t *testing.T, config *Config)
-	}{
-		{
-			name:   "empty config",
-			config: &Config{},
-			validate: func(t *testing.T, config *Config) {
-				assert.Equal(t, DefaultMethod, *config.Method)
-				assert.Equal(t, DefaultTimeout, config.Timeout.Duration)
-				assert.Equal(t, DefaultDodosCount, *config.DodosCount)
-				assert.Equal(t, DefaultRequestCount, *config.RequestCount)
-				assert.Equal(t, DefaultDuration, config.Duration.Duration)
-				assert.Equal(t, DefaultYes, *config.Yes)
-				assert.True(t, config.Headers.Has("User-Agent"))
-				userAgent := config.Headers.GetValue("User-Agent")
-				assert.NotNil(t, userAgent)
-				assert.Contains(t, (*userAgent)[0], DefaultUserAgent)
-			},
-		},
-		{
-			name: "partial config",
-			config: &Config{
-				Method:  utils.ToPtr("POST"),
-				Timeout: &types.Timeout{Duration: 30 * time.Second},
-				Headers: types.Headers{{Key: "Custom-Header", Value: []string{"value"}}},
-			},
-			validate: func(t *testing.T, config *Config) {
-				assert.Equal(t, "POST", *config.Method)                    // should keep existing value
-				assert.Equal(t, 30*time.Second, config.Timeout.Duration)   // should keep existing value
-				assert.Equal(t, DefaultDodosCount, *config.DodosCount)     // should set default
-				assert.Equal(t, DefaultRequestCount, *config.RequestCount) // should set default
-				assert.Equal(t, DefaultDuration, config.Duration.Duration) // should set default
-				assert.Equal(t, DefaultYes, *config.Yes)                   // should set default
-				assert.True(t, config.Headers.Has("Custom-Header"))        // should keep existing header
-				assert.True(t, config.Headers.Has("User-Agent"))           // should add User-Agent
-				userAgent := config.Headers.GetValue("User-Agent")
-				assert.NotNil(t, userAgent)
-				assert.Contains(t, (*userAgent)[0], DefaultUserAgent)
-			},
-		},
-		{
-			name: "complete config",
-			config: &Config{
-				Method:       utils.ToPtr("DELETE"),
-				URL:          func() *types.RequestURL { u := &types.RequestURL{}; u.Set("https://example.com"); return u }(),
-				Timeout:      &types.Timeout{Duration: 15 * time.Second},
-				DodosCount:   utils.ToPtr(uint(5)),
-				RequestCount: utils.ToPtr(uint(500)),
-				Duration:     &types.Duration{Duration: 5 * time.Minute},
-				Yes:          utils.ToPtr(true),
-				Headers:      types.Headers{{Key: "User-Agent", Value: []string{"CustomAgent"}}},
-			},
-			validate: func(t *testing.T, config *Config) {
-				assert.Equal(t, "DELETE", *config.Method)
-				assert.Equal(t, 15*time.Second, config.Timeout.Duration)
-				assert.Equal(t, uint(5), *config.DodosCount)
-				assert.Equal(t, uint(500), *config.RequestCount)
-				assert.Equal(t, 5*time.Minute, config.Duration.Duration)
-				assert.True(t, *config.Yes)
-				assert.True(t, config.Headers.Has("User-Agent"))
-				userAgent := config.Headers.GetValue("User-Agent")
-				assert.NotNil(t, userAgent)
-				assert.Equal(t, "CustomAgent", (*userAgent)[0])       // should keep custom user agent
-				assert.NotEqual(t, DefaultUserAgent, (*userAgent)[0]) // should not overwrite
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Call the function being tested
-			tt.config.SetDefaults()
-
-			// Validate the result
-			tt.validate(t, tt.config)
-		})
-	}
-}
--- a/config/file_test.go
+++ b/config/file_test.go
@@ -1,350 +0,0 @@
-package config
-
-import (
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/aykhans/dodo/types"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestReadFile(t *testing.T) {
-	// Create temporary files for testing
-	tempDir := t.TempDir()
-
-	// Create a valid JSON config file
-	validJSONFile := filepath.Join(tempDir, "valid.json")
-	jsonContent := `{
-		"method": "POST",
-		"url": "https://example.com",
-		"timeout": "5s",
-		"dodos": 5,
-		"requests": 100,
-		"duration": "1m",
-		"yes": true,
-		"headers": [{"Content-Type": "application/json"}]
-	}`
-	err := os.WriteFile(validJSONFile, []byte(jsonContent), 0644)
-	assert.NoError(t, err)
-
-	// Create a valid YAML config file
-	validYAMLFile := filepath.Join(tempDir, "valid.yaml")
-	yamlContent := `
-method: POST
-url: https://example.com
-timeout: 5s
-dodos: 5
-requests: 100
-duration: 1m
-yes: true
-headers:
-  - Content-Type: application/json
-`
-	err = os.WriteFile(validYAMLFile, []byte(yamlContent), 0644)
-	assert.NoError(t, err)
-
-	// Create an invalid JSON config file
-	invalidJSONFile := filepath.Join(tempDir, "invalid.json")
-	invalidJSONContent := `{
-		"method": "POST",
-		"url": "https://example.com",
-		syntax error
-	}`
-	err = os.WriteFile(invalidJSONFile, []byte(invalidJSONContent), 0644)
-	assert.NoError(t, err)
-
-	// Create a file with unsupported extension
-	unsupportedFile := filepath.Join(tempDir, "config.txt")
-	err = os.WriteFile(unsupportedFile, []byte("some content"), 0644)
-	assert.NoError(t, err)
-
-	// Setup HTTP test server for remote config
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/valid.json":
-			w.Header().Set("Content-Type", "application/json")
-			w.WriteHeader(http.StatusOK)
-			io.WriteString(w, jsonContent)
-		case "/invalid.json":
-			w.Header().Set("Content-Type", "application/json")
-			w.WriteHeader(http.StatusOK)
-			io.WriteString(w, invalidJSONContent)
-		case "/valid.yaml":
-			w.Header().Set("Content-Type", "application/yaml")
-			w.WriteHeader(http.StatusOK)
-			io.WriteString(w, yamlContent)
-		default:
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}))
-	defer server.Close()
-
-	tests := []struct {
-		name      string
-		filePath  types.ConfigFile
-		expectErr bool
-		validate  func(t *testing.T, config *Config)
-	}{
-		{
-			name:      "valid local JSON file",
-			filePath:  types.ConfigFile(validJSONFile),
-			expectErr: false,
-			validate: func(t *testing.T, config *Config) {
-				assert.Equal(t, "POST", *config.Method)
-				assert.Equal(t, "https://example.com", config.URL.String())
-				assert.Equal(t, int64(5000000000), config.Timeout.Nanoseconds())
-				assert.Equal(t, uint(5), *config.DodosCount)
-				assert.Equal(t, uint(100), *config.RequestCount)
-				assert.Equal(t, int64(60000000000), config.Duration.Nanoseconds())
-				assert.True(t, *config.Yes)
-				assert.Equal(t, 1, len(config.Headers))
-				assert.Equal(t, "Content-Type", config.Headers[0].Key)
-				assert.Equal(t, "application/json", config.Headers[0].Value[0])
-			},
-		},
-		{
-			name:      "valid local YAML file",
-			filePath:  types.ConfigFile(validYAMLFile),
-			expectErr: false,
-			validate: func(t *testing.T, config *Config) {
-				assert.Equal(t, "POST", *config.Method)
-				assert.Equal(t, "https://example.com", config.URL.String())
-				assert.Equal(t, int64(5000000000), config.Timeout.Nanoseconds())
-				assert.Equal(t, uint(5), *config.DodosCount)
-				assert.Equal(t, uint(100), *config.RequestCount)
-				assert.Equal(t, int64(60000000000), config.Duration.Nanoseconds())
-				assert.True(t, *config.Yes)
-				assert.Equal(t, 1, len(config.Headers))
-				assert.Equal(t, "Content-Type", config.Headers[0].Key)
-				assert.Equal(t, "application/json", config.Headers[0].Value[0])
-			},
-		},
-		{
-			name:      "invalid local JSON file",
-			filePath:  types.ConfigFile(invalidJSONFile),
-			expectErr: true,
-			validate:  func(t *testing.T, config *Config) {},
-		},
-		{
-			name:      "unsupported file extension",
-			filePath:  types.ConfigFile(unsupportedFile),
-			expectErr: true,
-			validate:  func(t *testing.T, config *Config) {},
-		},
-		{
-			name:      "non-existent file",
-			filePath:  types.ConfigFile(filepath.Join(tempDir, "nonexistent.json")),
-			expectErr: true,
-			validate:  func(t *testing.T, config *Config) {},
-		},
-		{
-			name:      "valid remote JSON file",
-			filePath:  types.ConfigFile(server.URL + "/valid.json"),
-			expectErr: false,
-			validate: func(t *testing.T, config *Config) {
-				assert.Equal(t, "POST", *config.Method)
-				assert.Equal(t, "https://example.com", config.URL.String())
-				assert.Equal(t, int64(5000000000), config.Timeout.Nanoseconds())
-				assert.Equal(t, uint(5), *config.DodosCount)
-				assert.Equal(t, uint(100), *config.RequestCount)
-				assert.Equal(t, int64(60000000000), config.Duration.Nanoseconds())
-				assert.True(t, *config.Yes)
-				assert.Equal(t, 1, len(config.Headers))
-				assert.Equal(t, "Content-Type", config.Headers[0].Key)
-				assert.Equal(t, "application/json", config.Headers[0].Value[0])
-			},
-		},
-		{
-			name:      "valid remote YAML file",
-			filePath:  types.ConfigFile(server.URL + "/valid.yaml"),
-			expectErr: false,
-			validate: func(t *testing.T, config *Config) {
-				assert.Equal(t, "POST", *config.Method)
-				assert.Equal(t, "https://example.com", config.URL.String())
-				assert.Equal(t, int64(5000000000), config.Timeout.Nanoseconds())
-				assert.Equal(t, uint(5), *config.DodosCount)
-				assert.Equal(t, uint(100), *config.RequestCount)
-				assert.Equal(t, int64(60000000000), config.Duration.Nanoseconds())
-				assert.True(t, *config.Yes)
-				assert.Equal(t, 1, len(config.Headers))
-				assert.Equal(t, "Content-Type", config.Headers[0].Key)
-				assert.Equal(t, "application/json", config.Headers[0].Value[0])
-			},
-		},
-		{
-			name:      "invalid remote JSON file",
-			filePath:  types.ConfigFile(server.URL + "/invalid.json"),
-			expectErr: true,
-			validate:  func(t *testing.T, config *Config) {},
-		},
-		{
-			name:      "non-existent remote file",
-			filePath:  types.ConfigFile(server.URL + "/nonexistent.json"),
-			expectErr: true,
-			validate:  func(t *testing.T, config *Config) {},
-		},
-		{
-			name:      "invalid URL",
-			filePath:  types.ConfigFile("http://nonexistent.example.com/config.json"),
-			expectErr: true,
-			validate:  func(t *testing.T, config *Config) {},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			config := NewConfig()
-			err := config.ReadFile(tt.filePath)
-
-			if tt.expectErr {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-				tt.validate(t, config)
-			}
-		})
-	}
-}
-
-func TestParseJSONConfig(t *testing.T) {
-	tests := []struct {
-		name      string
-		jsonData  string
-		expectErr bool
-		validate  func(t *testing.T, config *Config)
-	}{
-		{
-			name: "valid JSON config",
-			jsonData: `{
-				"method": "POST",
-				"url": "https://example.com",
-				"timeout": "5s",
-				"dodos": 5,
-				"requests": 100
-			}`,
-			expectErr: false,
-			validate: func(t *testing.T, config *Config) {
-				assert.Equal(t, "POST", *config.Method)
-				assert.Equal(t, "https://example.com", config.URL.String())
-				assert.Equal(t, int64(5000000000), config.Timeout.Nanoseconds())
-				assert.Equal(t, uint(5), *config.DodosCount)
-				assert.Equal(t, uint(100), *config.RequestCount)
-			},
-		},
-		{
-			name: "invalid JSON syntax",
-			jsonData: `{
-				"method": "POST",
-				"url": "https://example.com",
-				syntax error
-			}`,
-			expectErr: true,
-			validate:  func(t *testing.T, config *Config) {},
-		},
-		{
-			name: "invalid type for field",
-			jsonData: `{
-				"method": "POST",
-				"url": "https://example.com",
-				"dodos": "not-a-number"
-			}`,
-			expectErr: true,
-			validate:  func(t *testing.T, config *Config) {},
-		},
-		{
-			name:      "empty JSON object",
-			jsonData:  `{}`,
-			expectErr: false,
-			validate: func(t *testing.T, config *Config) {
-				assert.Nil(t, config.Method)
-				assert.Nil(t, config.URL)
-				assert.Nil(t, config.Timeout)
-				assert.Nil(t, config.DodosCount)
-				assert.Nil(t, config.RequestCount)
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			config := NewConfig()
-			err := parseJSONConfig([]byte(tt.jsonData), config)
-
-			if tt.expectErr {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-				tt.validate(t, config)
-			}
-		})
-	}
-}
-
-func TestParseYAMLConfig(t *testing.T) {
-	tests := []struct {
-		name      string
-		yamlData  string
-		expectErr bool
-		validate  func(t *testing.T, config *Config)
-	}{
-		{
-			name: "valid YAML config",
-			yamlData: `
-method: POST
-url: https://example.com
-timeout: 5s
-dodos: 5
-requests: 100
-`,
-			expectErr: false,
-			validate: func(t *testing.T, config *Config) {
-				assert.Equal(t, "POST", *config.Method)
-				assert.Equal(t, "https://example.com", config.URL.String())
-				assert.Equal(t, int64(5000000000), config.Timeout.Nanoseconds())
-				assert.Equal(t, uint(5), *config.DodosCount)
-				assert.Equal(t, uint(100), *config.RequestCount)
-			},
-		},
-		{
-			name: "invalid YAML syntax",
-			yamlData: `
-method: POST
-url: https://example.com
-dodos: 5
-    invalid indentation
-`,
-			expectErr: true,
-			validate:  func(t *testing.T, config *Config) {},
-		},
-		{
-			name:      "empty YAML",
-			yamlData:  ``,
-			expectErr: false,
-			validate: func(t *testing.T, config *Config) {
-				assert.Nil(t, config.Method)
-				assert.Nil(t, config.URL)
-				assert.Nil(t, config.Timeout)
-				assert.Nil(t, config.DodosCount)
-				assert.Nil(t, config.RequestCount)
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			config := NewConfig()
-			err := parseYAMLConfig([]byte(tt.yamlData), config)
-
-			if tt.expectErr {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-				tt.validate(t, config)
-			}
-		})
-	}
-}
--- a/go.mod
+++ b/go.mod
@@ -1,24 +1,21 @@
 module github.com/aykhans/dodo

-go 1.24.0
+go 1.24.2

 require (
 	github.com/jedib0t/go-pretty/v6 v6.6.7
-	github.com/stretchr/testify v1.10.0
-	github.com/valyala/fasthttp v1.60.0
+	github.com/valyala/fasthttp v1.62.0
 	gopkg.in/yaml.v3 v3.0.1
 )

 require (
 	github.com/andybalholm/brotli v1.1.1 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/klauspost/compress v1.18.0 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
-	golang.org/x/net v0.38.0 // indirect
-	golang.org/x/sys v0.31.0 // indirect
-	golang.org/x/term v0.30.0 // indirect
-	golang.org/x/text v0.23.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
+	golang.org/x/sys v0.33.0 // indirect
+	golang.org/x/term v0.32.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 )
--- a/go.sum
+++ b/go.sum
@@ -17,18 +17,18 @@ github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOf
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
-github.com/valyala/fasthttp v1.60.0 h1:kBRYS0lOhVJ6V+bYN8PqAHELKHtXqwq9zNMLKx1MBsw=
-github.com/valyala/fasthttp v1.60.0/go.mod h1:iY4kDgV3Gc6EqhRZ8icqcmlG6bqhcDXfuHgTO4FXCvc=
+github.com/valyala/fasthttp v1.62.0 h1:8dKRBX/y2rCzyc6903Zu1+3qN0H/d2MsxPPmVNamiH0=
+github.com/valyala/fasthttp v1.62.0/go.mod h1:FCINgr4GKdKqV8Q0xv8b+UxPV+H/O5nNFo3D+r54Htg=
 github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
 github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
-golang.org/x/net v0.38.0 h1:vRMAPTMaeGqVhG5QyLJHqNDwecKTomGeqbnfZyKlBI8=
-golang.org/x/net v0.38.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
-golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
-golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/term v0.30.0 h1:PQ39fJZ+mfadBm0y5WlL4vlM7Sx1Hgf13sMIY2+QS9Y=
-golang.org/x/term v0.30.0/go.mod h1:NYYFdzHoI5wRh/h5tDMdMqCqPJZEuNqVR5xJLd/n67g=
-golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
-golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
+golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
--- a/requests/client.go
+++ b/requests/client.go
@@ -2,6 +2,7 @@ package requests

 import (
 	"context"
+	"crypto/tls"
 	"errors"
 	"math/rand"
 	"net/url"
@@ -17,11 +18,12 @@ type ClientGeneratorFunc func() *fasthttp.HostClient
 // getClients initializes and returns a slice of fasthttp.HostClient based on the provided parameters.
 // It can either return clients with proxies or a single client without proxies.
 func getClients(
-	ctx context.Context,
+	_ context.Context,
 	timeout time.Duration,
 	proxies []url.URL,
 	maxConns uint,
 	URL url.URL,
+	skipVerify bool,
 ) []*fasthttp.HostClient {
 	isTLS := URL.Scheme == "https"

@@ -41,6 +43,9 @@ func getClients(
 			clients = append(clients, &fasthttp.HostClient{
 				MaxConns: int(maxConns),
 				IsTLS:    isTLS,
+				TLSConfig: &tls.Config{
+					InsecureSkipVerify: skipVerify,
+				},
 				Addr:                addr,
 				Dial:                dialFunc,
 				MaxIdleConnDuration: timeout,
@@ -56,6 +61,9 @@ func getClients(
 	client := &fasthttp.HostClient{
 		MaxConns: int(maxConns),
 		IsTLS:    isTLS,
+		TLSConfig: &tls.Config{
+			InsecureSkipVerify: skipVerify,
+		},
 		Addr:                URL.Host,
 		MaxIdleConnDuration: timeout,
 		MaxConnDuration:     timeout,
@@ -80,6 +88,11 @@ func getDialFunc(proxy *url.URL, timeout time.Duration) (fasthttp.DialFunc, erro
 	default:
 		return nil, errors.New("unsupported proxy scheme")
 	}
+
+	if dialer == nil {
+		return nil, errors.New("internal error: proxy dialer is nil")
+	}
+
 	return dialer, nil
 }

--- a/requests/run.go
+++ b/requests/run.go
@@ -20,8 +20,11 @@ import (
 //   - ctx: The context for managing request lifecycle and cancellation.
 //   - requestConfig: The configuration for the request, including timeout, proxies, and other settings.
 func Run(ctx context.Context, requestConfig *config.RequestConfig) (Responses, error) {
-	ctx, cancel := context.WithCancel(ctx)
+	if requestConfig.Duration > 0 {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, requestConfig.Duration)
 		defer cancel()
+	}

 	clients := getClients(
 		ctx,
@@ -29,15 +32,12 @@ func Run(ctx context.Context, requestConfig *config.RequestConfig) (Responses, e
 		requestConfig.Proxies,
 		requestConfig.GetMaxConns(fasthttp.DefaultMaxConnsPerHost),
 		requestConfig.URL,
+		requestConfig.SkipVerify,
 	)
 	if clients == nil {
 		return nil, types.ErrInterrupt
 	}

-	if requestConfig.Duration > 0 {
-		time.AfterFunc(requestConfig.Duration, func() { cancel() })
-	}
-
 	responses := releaseDodos(ctx, requestConfig, clients)
 	if ctx.Err() != nil && len(responses) == 0 {
 		return nil, types.ErrInterrupt
--- a/types/body.go
+++ b/types/body.go
@@ -66,7 +66,7 @@ func (body *Body) UnmarshalJSON(b []byte) error {
 	return nil
 }

-func (body *Body) UnmarshalYAML(unmarshal func(interface{}) error) error {
+func (body *Body) UnmarshalYAML(unmarshal func(any) error) error {
 	var data any
 	if err := unmarshal(&data); err != nil {
 		return err
--- a/types/cookies.go
+++ b/types/cookies.go
@@ -99,7 +99,7 @@ func (cookies *Cookies) UnmarshalJSON(b []byte) error {
 	return nil
 }

-func (cookies *Cookies) UnmarshalYAML(unmarshal func(interface{}) error) error {
+func (cookies *Cookies) UnmarshalYAML(unmarshal func(any) error) error {
 	var raw []map[string]any
 	if err := unmarshal(&raw); err != nil {
 		return err
--- a/types/duration.go
+++ b/types/duration.go
@@ -35,7 +35,7 @@ func (duration Duration) MarshalJSON() ([]byte, error) {
 	return json.Marshal(duration.String())
 }

-func (duration *Duration) UnmarshalYAML(unmarshal func(interface{}) error) error {
+func (duration *Duration) UnmarshalYAML(unmarshal func(any) error) error {
 	var v any
 	if err := unmarshal(&v); err != nil {
 		return err
--- a/types/headers.go
+++ b/types/headers.go
@@ -108,7 +108,7 @@ func (headers *Headers) UnmarshalJSON(b []byte) error {
 	return nil
 }

-func (headers *Headers) UnmarshalYAML(unmarshal func(interface{}) error) error {
+func (headers *Headers) UnmarshalYAML(unmarshal func(any) error) error {
 	var raw []map[string]any
 	if err := unmarshal(&raw); err != nil {
 		return err
--- a/types/params.go
+++ b/types/params.go
@@ -99,7 +99,7 @@ func (params *Params) UnmarshalJSON(b []byte) error {
 	return nil
 }

-func (params *Params) UnmarshalYAML(unmarshal func(interface{}) error) error {
+func (params *Params) UnmarshalYAML(unmarshal func(any) error) error {
 	var raw []map[string]any
 	if err := unmarshal(&raw); err != nil {
 		return err
--- a/types/proxies.go
+++ b/types/proxies.go
@@ -75,7 +75,7 @@ func (proxies *Proxies) UnmarshalJSON(b []byte) error {
 	return nil
 }

-func (proxies *Proxies) UnmarshalYAML(unmarshal func(interface{}) error) error {
+func (proxies *Proxies) UnmarshalYAML(unmarshal func(any) error) error {
 	var data any
 	if err := unmarshal(&data); err != nil {
 		return err
--- a/types/request_url.go
+++ b/types/request_url.go
@@ -25,7 +25,7 @@ func (requestURL *RequestURL) UnmarshalJSON(data []byte) error {
 	return nil
 }

-func (requestURL *RequestURL) UnmarshalYAML(unmarshal func(interface{}) error) error {
+func (requestURL *RequestURL) UnmarshalYAML(unmarshal func(any) error) error {
 	var urlStr string
 	if err := unmarshal(&urlStr); err != nil {
 		return err
--- a/types/timeout.go
+++ b/types/timeout.go
@@ -35,7 +35,7 @@ func (timeout Timeout) MarshalJSON() ([]byte, error) {
 	return json.Marshal(timeout.String())
 }

-func (timeout *Timeout) UnmarshalYAML(unmarshal func(interface{}) error) error {
+func (timeout *Timeout) UnmarshalYAML(unmarshal func(any) error) error {
 	var v any
 	if err := unmarshal(&v); err != nil {
 		return err
Author	SHA1	Message	Date
Aykhan Shahsuvarov	23c74bdbb1	Merge pull request #114 from aykhans/core/refactor General refactor	2025-05-29 02:42:57 +04:00
Aykhan Shahsuvarov	addf92df91	🔧 Add 'skip-verify' parameter to skip SSL/TLS cert verification	2025-05-29 02:38:07 +04:00
Aykhan Shahsuvarov	6aeda3706b	💄 general formatting	2025-05-29 00:38:48 +04:00
Aykhan Shahsuvarov	dc1cd05714	Merge pull request #112 from aykhans/core/refactor-clients 🔧 Update client configs to skip connection verification if it is not secure	2025-05-25 19:18:03 +04:00
Aykhan Shahsuvarov	2b9d0520b0	🔧 Update client configs to skip connection verification if it is not secure	2025-05-25 19:16:30 +04:00
Aykhan Shahsuvarov	bea2e7c040	Merge pull request #111 from aykhans/dependabot/go_modules/github.com/valyala/fasthttp-1.62.0 Bump github.com/valyala/fasthttp from 1.61.0 to 1.62.0	2025-05-08 15:11:32 +04:00
dependabot[bot]	b52b336a52	Bump github.com/valyala/fasthttp from 1.61.0 to 1.62.0 Bumps [github.com/valyala/fasthttp](https://github.com/valyala/fasthttp) from 1.61.0 to 1.62.0. - [Release notes](https://github.com/valyala/fasthttp/releases) - [Commits](https://github.com/valyala/fasthttp/compare/v1.61.0...v1.62.0) --- updated-dependencies: - dependency-name: github.com/valyala/fasthttp dependency-version: 1.62.0 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com>	2025-05-08 00:48:52 +00:00
Aykhan Shahsuvarov	c927e31c49	Merge pull request #110 from aykhans/core/update-go 🔧 bump go version to 1.24.2	2025-04-26 16:38:03 +04:00
Aykhan Shahsuvarov	d8e6f532a8	🔧 bump go version to 1.24.2	2025-04-26 16:36:27 +04:00
Aykhan Shahsuvarov	cf5cd23d97	Merge pull request #109 from aykhans/dependabot/go_modules/github.com/valyala/fasthttp-1.61.0 All checks were successful golangci-lint / lint (push) Successful in 2m31s Details Bump github.com/valyala/fasthttp from 1.60.0 to 1.61.0	2025-04-23 15:10:41 +04:00
dependabot[bot]	350ff4d66d	Bump github.com/valyala/fasthttp from 1.60.0 to 1.61.0 Bumps [github.com/valyala/fasthttp](https://github.com/valyala/fasthttp) from 1.60.0 to 1.61.0. - [Release notes](https://github.com/valyala/fasthttp/releases) - [Commits](https://github.com/valyala/fasthttp/compare/v1.60.0...v1.61.0) --- updated-dependencies: - dependency-name: github.com/valyala/fasthttp dependency-version: 1.61.0 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com>	2025-04-23 00:25:31 +00:00
Aykhan Shahsuvarov	cb8898d20e	Merge pull request #108 from aykhans/core/refactor-duration-logic All checks were successful golangci-lint / lint (push) Successful in 3m4s Details 🔨 Replace 'time.AfterFunc' with 'context.WithTimeout'	2025-04-18 15:42:21 +04:00
Aykhan Shahsuvarov	a552d1c9f9	🔨 Replace 'time.AfterFunc' with 'context.WithTimeout'	2025-04-18 15:39:17 +04:00