Tests and performance fixes

pkg/filter/filter_test.go

@@ -0,0 +1,41 @@
+package filter
+
+import (
+	"testing"
+)
+
+func TestNewFilterByName(t *testing.T) {
+	scf, _ := NewFilterByName("status", "200")
+	if _, ok := scf.(*StatusFilter); !ok {
+		t.Errorf("Was expecting statusfilter")
+	}
+
+	szf, _ := NewFilterByName("size", "200")
+	if _, ok := szf.(*SizeFilter); !ok {
+		t.Errorf("Was expecting sizefilter")
+	}
+
+	wf, _ := NewFilterByName("word", "200")
+	if _, ok := wf.(*WordFilter); !ok {
+		t.Errorf("Was expecting wordfilter")
+	}
+
+	ref, _ := NewFilterByName("regexp", "200")
+	if _, ok := ref.(*RegexpFilter); !ok {
+		t.Errorf("Was expecting regexpfilter")
+	}
+}
+
+func TestNewFilterByNameError(t *testing.T) {
+	_, err := NewFilterByName("status", "invalid")
+	if err == nil {
+		t.Errorf("Was expecing an error")
+	}
+}
+
+func TestNewFilterByNameNotFound(t *testing.T) {
+	_, err := NewFilterByName("nonexistent", "invalid")
+	if err == nil {
+		t.Errorf("Was expecing an error with invalid filter name")
+	}
+}

pkg/filter/regexp_test.go

@@ -0,0 +1,44 @@
+package filter
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/ffuf/ffuf/pkg/ffuf"
+)
+
+func TestNewRegexpFilter(t *testing.T) {
+	f, _ := NewRegexpFilter("s([a-z]+)arch")
+	statusRepr := f.Repr()
+	if strings.Index(statusRepr, "s([a-z]+)arch") == -1 {
+		t.Errorf("Status filter was expected to have a regexp value")
+	}
+}
+
+func TestNewRegexpFilterError(t *testing.T) {
+	_, err := NewRegexpFilter("r((")
+	if err == nil {
+		t.Errorf("Was expecting an error from errenous input data")
+	}
+}
+
+func TestRegexpFiltering(t *testing.T) {
+	f, _ := NewRegexpFilter("s([a-z]+)arch")
+	for i, test := range []struct {
+		input  string
+		output bool
+	}{
+		{"search", true},
+		{"text and search", true},
+		{"sbarch in beginning", true},
+		{"midd scarch le", true},
+		{"s1arch", false},
+		{"invalid", false},
+	} {
+		resp := ffuf.Response{Data: []byte(test.input)}
+		filterReturn, _ := f.Filter(&resp)
+		if filterReturn != test.output {
+			t.Errorf("Filter test %d: Was expecing filter return value of %t but got %t", i, test.output, filterReturn)
+		}
+	}
+}

pkg/filter/size_test.go

@@ -0,0 +1,43 @@
+package filter
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/ffuf/ffuf/pkg/ffuf"
+)
+
+func TestNewSizeFilter(t *testing.T) {
+	f, _ := NewSizeFilter("1,2,3,444")
+	sizeRepr := f.Repr()
+	if strings.Index(sizeRepr, "1,2,3,444") == -1 {
+		t.Errorf("Size filter was expected to have 4 values")
+	}
+}
+
+func TestNewSizeFilterError(t *testing.T) {
+	_, err := NewSizeFilter("invalid")
+	if err == nil {
+		t.Errorf("Was expecting an error from errenous input data")
+	}
+}
+
+func TestFiltering(t *testing.T) {
+	f, _ := NewSizeFilter("1,2,3,444")
+	for i, test := range []struct {
+		input  int64
+		output bool
+	}{
+		{1, true},
+		{2, true},
+		{3, true},
+		{4, false},
+		{444, true},
+	} {
+		resp := ffuf.Response{ContentLength: test.input}
+		filterReturn, _ := f.Filter(&resp)
+		if filterReturn != test.output {
+			t.Errorf("Filter test %d: Was expecing filter return value of %t but got %t", i, test.output, filterReturn)
+		}
+	}
+}

pkg/filter/status_test.go

@@ -0,0 +1,45 @@
+package filter
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/ffuf/ffuf/pkg/ffuf"
+)
+
+func TestNewStatusFilter(t *testing.T) {
+	f, _ := NewStatusFilter("200,301,500")
+	statusRepr := f.Repr()
+	if strings.Index(statusRepr, "200,301,500") == -1 {
+		t.Errorf("Status filter was expected to have 3 values")
+	}
+}
+
+func TestNewStatusFilterError(t *testing.T) {
+	_, err := NewStatusFilter("invalid")
+	if err == nil {
+		t.Errorf("Was expecting an error from errenous input data")
+	}
+}
+
+func TestStatusFiltering(t *testing.T) {
+	f, _ := NewStatusFilter("200,301,500")
+	for i, test := range []struct {
+		input  int64
+		output bool
+	}{
+		{200, true},
+		{301, true},
+		{500, true},
+		{4, false},
+		{444, false},
+		{302, false},
+		{401, false},
+	} {
+		resp := ffuf.Response{StatusCode: test.input}
+		filterReturn, _ := f.Filter(&resp)
+		if filterReturn != test.output {
+			t.Errorf("Filter test %d: Was expecing filter return value of %t but got %t", i, test.output, filterReturn)
+		}
+	}
+}

pkg/filter/words_test.go

@@ -0,0 +1,49 @@
+package filter
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/ffuf/ffuf/pkg/ffuf"
+)
+
+func TestNewWordFilter(t *testing.T) {
+	f, _ := NewWordFilter("200,301,500")
+	wordsRepr := f.Repr()
+	if strings.Index(wordsRepr, "200,301,500") == -1 {
+		t.Errorf("Word filter was expected to have 3 values")
+	}
+}
+
+func TestNewWordFilterError(t *testing.T) {
+	_, err := NewWordFilter("invalid")
+	if err == nil {
+		t.Errorf("Was expecting an error from errenous input data")
+	}
+}
+
+func TestWordFiltering(t *testing.T) {
+	f, _ := NewWordFilter("200,301,500")
+	for i, test := range []struct {
+		input  int64
+		output bool
+	}{
+		{200, true},
+		{301, true},
+		{500, true},
+		{4, false},
+		{444, false},
+		{302, false},
+		{401, false},
+	} {
+		var data []string
+		for i := int64(0); i < test.input; i++ {
+			data = append(data, "A")
+		}
+		resp := ffuf.Response{Data: []byte(strings.Join(data, " "))}
+		filterReturn, _ := f.Filter(&resp)
+		if filterReturn != test.output {
+			t.Errorf("Filter test %d: Was expecing filter return value of %t but got %t", i, test.output, filterReturn)
+		}
+	}
+}

pkg/runner/simple.go

@@ -30,8 +30,9 @@ func NewSimpleRunner(conf *ffuf.Config) ffuf.RunnerProvider {
 		CheckRedirect: func(req *http.Request, via []*http.Request) error { return http.ErrUseLastResponse },
 		Timeout:       time.Duration(10 * time.Second),
 		Transport: &http.Transport{
-			MaxIdleConns:        100,
+			MaxIdleConns:        1000,
-			MaxIdleConnsPerHost: 100,
+			MaxIdleConnsPerHost: 500,
+			MaxConnsPerHost:     500,
 			TLSClientConfig: &tls.Config{
 				InsecureSkipVerify: conf.TLSSkipVerify,
 			},