From 13ab12dd0a4112d91e9314035cc252f5227d38f8 Mon Sep 17 00:00:00 2001 From: Joona Hoikkala Date: Wed, 14 Nov 2018 22:38:13 +0200 Subject: [PATCH] Tests and performance fixes --- pkg/filter/filter_test.go | 41 ++++++++++++++++++++++++++++++++ pkg/filter/regexp_test.go | 44 +++++++++++++++++++++++++++++++++++ pkg/filter/size_test.go | 43 ++++++++++++++++++++++++++++++++++ pkg/filter/status_test.go | 45 +++++++++++++++++++++++++++++++++++ pkg/filter/words_test.go | 49 +++++++++++++++++++++++++++++++++++++++ pkg/runner/simple.go | 5 ++-- 6 files changed, 225 insertions(+), 2 deletions(-) create mode 100644 pkg/filter/filter_test.go create mode 100644 pkg/filter/regexp_test.go create mode 100644 pkg/filter/size_test.go create mode 100644 pkg/filter/status_test.go create mode 100644 pkg/filter/words_test.go diff --git a/pkg/filter/filter_test.go b/pkg/filter/filter_test.go new file mode 100644 index 0000000..7e4346d --- /dev/null +++ b/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") + } +} diff --git a/pkg/filter/regexp_test.go b/pkg/filter/regexp_test.go new file mode 100644 index 0000000..9a06853 --- /dev/null +++ b/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) + } + } +} diff --git a/pkg/filter/size_test.go b/pkg/filter/size_test.go new file mode 100644 index 0000000..22efeb1 --- /dev/null +++ b/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) + } + } +} diff --git a/pkg/filter/status_test.go b/pkg/filter/status_test.go new file mode 100644 index 0000000..823f476 --- /dev/null +++ b/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) + } + } +} diff --git a/pkg/filter/words_test.go b/pkg/filter/words_test.go new file mode 100644 index 0000000..d67e23e --- /dev/null +++ b/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) + } + } +} diff --git a/pkg/runner/simple.go b/pkg/runner/simple.go index 5608532..e5ab5ee 100644 --- a/pkg/runner/simple.go +++ b/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, - MaxIdleConnsPerHost: 100, + MaxIdleConns: 1000, + MaxIdleConnsPerHost: 500, + MaxConnsPerHost: 500, TLSClientConfig: &tls.Config{ InsecureSkipVerify: conf.TLSSkipVerify, },