From 2b0fa874be6a2fc4b457bc68e96704681d29aa79 Mon Sep 17 00:00:00 2001 From: Ivan Krutov Date: Sun, 31 Dec 2023 12:32:28 +0300 Subject: [PATCH 1/3] Added stale.yml to close outdated issues --- .github/stale.yml | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 .github/stale.yml diff --git a/.github/stale.yml b/.github/stale.yml new file mode 100644 index 00000000..129e3131 --- /dev/null +++ b/.github/stale.yml @@ -0,0 +1,19 @@ +# Number of days of inactivity before an issue becomes stale +daysUntilStale: 60 +# Number of days of inactivity before a stale issue is closed +daysUntilClose: 7 +# Issues with these labels will never be considered stale +exemptLabels: + - new-feature + - bug + - improvement + - docs +# Label to use when marking an issue as stale +staleLabel: stale +# Comment to post when marking an issue as stale. Set to `false` to disable +markComment: > + This issue has been automatically marked as stale because it has not had + recent activity. It will be closed if no further activity occurs. Thank you + for your contributions. +# Comment to post when closing a stale issue. Set to `false` to disable +closeComment: false From 675a1fad82808db077797899800c4be445687d8c Mon Sep 17 00:00:00 2001 From: Ivan Krutov Date: Sun, 31 Dec 2023 12:36:04 +0300 Subject: [PATCH 2/3] Bump Golang to 1.21.5 --- .github/workflows/build.yml | 2 +- .github/workflows/release.yml | 2 +- .github/workflows/test.yml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 73b739cb..4effa451 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -14,7 +14,7 @@ jobs: - name: Setup Golang uses: actions/setup-go@v3 with: - go-version: ~1.21.3 + go-version: ~1.21.5 - uses: actions/cache@v3 with: diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 3302d23b..9e12797f 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -13,7 +13,7 @@ jobs: - name: Setup Golang uses: actions/setup-go@v3 with: - go-version: ~1.21.3 + go-version: ~1.21.5 - uses: actions/cache@v3 with: diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index d0e3b0d6..61f37fed 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -12,7 +12,7 @@ jobs: - name: Setup Golang uses: actions/setup-go@v3 with: - go-version: ~1.21.3 + go-version: ~1.21.5 - uses: actions/cache@v3 with: From 4015eda33828e8b2c26d2f3b008534ba7257e812 Mon Sep 17 00:00:00 2001 From: Ivan Krutov Date: Sun, 31 Dec 2023 15:46:25 +0300 Subject: [PATCH 3/3] Using github.com/stretchr/testify for tests --- config_test.go | 116 +++++----- go.mod | 5 +- go.sum | 8 +- s3_test.go | 42 ++-- selenoid_test.go | 554 ++++++++++++++++++++++++----------------------- service_test.go | 44 ++-- utils_test.go | 63 +++--- 7 files changed, 426 insertions(+), 406 deletions(-) diff --git a/config_test.go b/config_test.go index fbd200dc..39e7deec 100644 --- a/config_test.go +++ b/config_test.go @@ -6,9 +6,9 @@ import ( "os" "testing" - . "github.com/aandryashin/matchers" "github.com/aerokube/selenoid/config" "github.com/aerokube/selenoid/session" + assert "github.com/stretchr/testify/require" ) const testLogConf = "config/container-logs.json" @@ -34,15 +34,16 @@ func TestConfig(t *testing.T) { defer os.Remove(confFile) conf := config.NewConfig() err := conf.Load(confFile, testLogConf) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) } func TestConfigError(t *testing.T) { confFile := configfile(`{}`) - os.Remove(confFile) + _ = os.Remove(confFile) conf := config.NewConfig() err := conf.Load(confFile, testLogConf) - AssertThat(t, err.Error(), EqualTo{fmt.Sprintf("browsers config: read error: open %s: no such file or directory", confFile)}) + assert.Error(t, err) + assert.Equal(t, err.Error(), fmt.Sprintf("browsers config: read error: open %s: no such file or directory", confFile)) } func TestLogConfigError(t *testing.T) { @@ -50,7 +51,7 @@ func TestLogConfigError(t *testing.T) { defer os.Remove(confFile) conf := config.NewConfig() err := conf.Load(confFile, "some-missing-file") - AssertThat(t, err, Not{nil}) + assert.Error(t, err) } func TestConfigParseError(t *testing.T) { @@ -58,7 +59,8 @@ func TestConfigParseError(t *testing.T) { defer os.Remove(confFile) var conf config.Config err := conf.Load(confFile, testLogConf) - AssertThat(t, err.Error(), EqualTo{"browsers config: parse error: unexpected end of JSON input"}) + assert.Error(t, err) + assert.Equal(t, err.Error(), "browsers config: parse error: unexpected end of JSON input") } func TestConfigEmptyState(t *testing.T) { @@ -68,42 +70,42 @@ func TestConfigEmptyState(t *testing.T) { conf.Load(confFile, testLogConf) state := conf.State(session.NewMap(), 0, 0, 0) - AssertThat(t, state.Total, EqualTo{0}) - AssertThat(t, state.Queued, EqualTo{0}) - AssertThat(t, state.Pending, EqualTo{0}) - AssertThat(t, state.Used, EqualTo{0}) + assert.Equal(t, state.Total, 0) + assert.Equal(t, state.Queued, 0) + assert.Equal(t, state.Pending, 0) + assert.Equal(t, state.Used, 0) } func TestConfigNonEmptyState(t *testing.T) { confFile := configfile(`{}`) defer os.Remove(confFile) conf := config.NewConfig() - conf.Load(confFile, testLogConf) + _ = conf.Load(confFile, testLogConf) sessions := session.NewMap() sessions.Put("0", &session.Session{Caps: session.Caps{Name: "firefox", Version: "49.0"}, Quota: "unknown"}) state := conf.State(sessions, 1, 0, 0) - AssertThat(t, state.Total, EqualTo{1}) - AssertThat(t, state.Queued, EqualTo{0}) - AssertThat(t, state.Pending, EqualTo{0}) - AssertThat(t, state.Used, EqualTo{1}) - AssertThat(t, state.Browsers["firefox"]["49.0"]["unknown"].Count, EqualTo{1}) + assert.Equal(t, state.Total, 1) + assert.Equal(t, state.Queued, 0) + assert.Equal(t, state.Pending, 0) + assert.Equal(t, state.Used, 1) + assert.Equal(t, state.Browsers["firefox"]["49.0"]["unknown"].Count, 1) } func TestConfigEmptyVersions(t *testing.T) { confFile := configfile(`{"firefox":{}}`) defer os.Remove(confFile) conf := config.NewConfig() - conf.Load(confFile, testLogConf) + _ = conf.Load(confFile, testLogConf) sessions := session.NewMap() sessions.Put("0", &session.Session{Caps: session.Caps{Name: "firefox", Version: "49.0"}, Quota: "unknown"}) state := conf.State(sessions, 1, 0, 0) - AssertThat(t, state.Total, EqualTo{1}) - AssertThat(t, state.Queued, EqualTo{0}) - AssertThat(t, state.Pending, EqualTo{0}) - AssertThat(t, state.Used, EqualTo{1}) - AssertThat(t, state.Browsers["firefox"]["49.0"]["unknown"].Count, EqualTo{1}) + assert.Equal(t, state.Total, 1) + assert.Equal(t, state.Queued, 0) + assert.Equal(t, state.Pending, 0) + assert.Equal(t, state.Used, 1) + assert.Equal(t, state.Browsers["firefox"]["49.0"]["unknown"].Count, 1) } func TestConfigNonEmptyVersions(t *testing.T) { @@ -115,11 +117,11 @@ func TestConfigNonEmptyVersions(t *testing.T) { sessions := session.NewMap() sessions.Put("0", &session.Session{Caps: session.Caps{Name: "firefox", Version: "49.0"}, Quota: "unknown"}) state := conf.State(sessions, 1, 0, 0) - AssertThat(t, state.Total, EqualTo{1}) - AssertThat(t, state.Queued, EqualTo{0}) - AssertThat(t, state.Pending, EqualTo{0}) - AssertThat(t, state.Used, EqualTo{1}) - AssertThat(t, state.Browsers["firefox"]["49.0"]["unknown"].Count, EqualTo{1}) + assert.Equal(t, state.Total, 1) + assert.Equal(t, state.Queued, 0) + assert.Equal(t, state.Pending, 0) + assert.Equal(t, state.Used, 1) + assert.Equal(t, state.Browsers["firefox"]["49.0"]["unknown"].Count, 1) } func TestConfigFindMissingBrowser(t *testing.T) { @@ -129,7 +131,7 @@ func TestConfigFindMissingBrowser(t *testing.T) { conf.Load(confFile, testLogConf) _, _, ok := conf.Find("firefox", "") - AssertThat(t, ok, Is{false}) + assert.False(t, ok) } func TestConfigFindDefaultVersionError(t *testing.T) { @@ -139,65 +141,70 @@ func TestConfigFindDefaultVersionError(t *testing.T) { conf.Load(confFile, testLogConf) _, _, ok := conf.Find("firefox", "") - AssertThat(t, ok, Is{false}) + assert.False(t, ok) } func TestConfigFindDefaultVersion(t *testing.T) { confFile := configfile(`{"firefox":{"default":"49.0"}}`) defer os.Remove(confFile) conf := config.NewConfig() - conf.Load(confFile, testLogConf) + err := conf.Load(confFile, testLogConf) + assert.NoError(t, err) _, v, ok := conf.Find("firefox", "") - AssertThat(t, ok, Is{false}) - AssertThat(t, v, EqualTo{"49.0"}) + assert.False(t, ok) + assert.Equal(t, v, "49.0") } func TestConfigFindFoundByEmptyPrefix(t *testing.T) { confFile := configfile(`{"firefox":{"default":"49.0","versions":{"49.0":{}}}}`) defer os.Remove(confFile) conf := config.NewConfig() - conf.Load(confFile, testLogConf) + err := conf.Load(confFile, testLogConf) + assert.NoError(t, err) _, v, ok := conf.Find("firefox", "") - AssertThat(t, ok, Is{true}) - AssertThat(t, v, EqualTo{"49.0"}) + assert.True(t, ok) + assert.Equal(t, v, "49.0") } func TestConfigFindFoundByPrefix(t *testing.T) { confFile := configfile(`{"firefox":{"default":"49.0","versions":{"49.0":{}}}}`) defer os.Remove(confFile) conf := config.NewConfig() - conf.Load(confFile, testLogConf) + err := conf.Load(confFile, testLogConf) + assert.NoError(t, err) _, v, ok := conf.Find("firefox", "49") - AssertThat(t, ok, Is{true}) - AssertThat(t, v, EqualTo{"49.0"}) + assert.True(t, ok) + assert.Equal(t, v, "49.0") } func TestConfigFindFoundByMatch(t *testing.T) { confFile := configfile(`{"firefox":{"default":"49.0","versions":{"49.0":{}}}}`) defer os.Remove(confFile) conf := config.NewConfig() - conf.Load(confFile, testLogConf) + err := conf.Load(confFile, testLogConf) + assert.NoError(t, err) _, v, ok := conf.Find("firefox", "49.0") - AssertThat(t, ok, Is{true}) - AssertThat(t, v, EqualTo{"49.0"}) + assert.True(t, ok) + assert.Equal(t, v, "49.0") } func TestConfigFindImage(t *testing.T) { confFile := configfile(`{"firefox":{"default":"49.0","versions":{"49.0":{"image":"image","port":"5555", "path":"/"}}}}`) defer os.Remove(confFile) conf := config.NewConfig() - conf.Load(confFile, testLogConf) + err := conf.Load(confFile, testLogConf) + assert.NoError(t, err) b, v, ok := conf.Find("firefox", "49.0") - AssertThat(t, ok, Is{true}) - AssertThat(t, v, EqualTo{"49.0"}) - AssertThat(t, b.Image, EqualTo{"image"}) - AssertThat(t, b.Port, EqualTo{"5555"}) - AssertThat(t, b.Path, EqualTo{"/"}) + assert.True(t, ok) + assert.Equal(t, v, "49.0") + assert.Equal(t, b.Image, "image") + assert.Equal(t, b.Port, "5555") + assert.Equal(t, b.Path, "/") } func TestConfigConcurrentLoad(t *testing.T) { @@ -207,10 +214,10 @@ func TestConfigConcurrentLoad(t *testing.T) { done := make(chan struct{}) go func() { - conf.Load(confFile, testLogConf) + _ = conf.Load(confFile, testLogConf) done <- struct{}{} }() - conf.Load(confFile, testLogConf) + _ = conf.Load(confFile, testLogConf) <-done } @@ -219,15 +226,14 @@ func TestConfigConcurrentLoadAndRead(t *testing.T) { defer os.Remove(confFile) conf := config.NewConfig() err := conf.Load(confFile, testLogConf) - if err != nil { - t.Error(err) - } + assert.NoError(t, err) done := make(chan string) go func() { browser, _, _ := conf.Find("firefox", "") done <- browser.Tmpfs["/tmp"] }() - conf.Load(confFile, testLogConf) + err = conf.Load(confFile, testLogConf) + assert.NoError(t, err) <-done } @@ -236,9 +242,7 @@ func TestConfigConcurrentRead(t *testing.T) { defer os.Remove(confFile) var conf config.Config err := conf.Load(confFile, testLogConf) - if err != nil { - t.Error(err) - } + assert.NoError(t, err) done := make(chan string) go func() { browser, _, _ := conf.Find("firefox", "") diff --git a/go.mod b/go.mod index 61babcd5..3cc5bea9 100644 --- a/go.mod +++ b/go.mod @@ -3,7 +3,6 @@ module github.com/aerokube/selenoid go 1.21 require ( - github.com/aandryashin/matchers v0.0.0-20161126170413-435295ea180e github.com/aerokube/ggr v0.0.0-20221124163939-c041f40a7e45 github.com/aerokube/util v1.0.1 github.com/aws/aws-sdk-go v1.44.197 @@ -15,18 +14,22 @@ require ( github.com/mafredri/cdp v0.33.0 github.com/pborman/uuid v1.2.1 github.com/pkg/errors v0.9.1 + github.com/stretchr/testify v1.8.4 golang.org/x/net v0.17.0 ) require ( github.com/Microsoft/go-winio v0.6.1 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect github.com/docker/distribution v2.8.2+incompatible // indirect github.com/gogo/protobuf v1.3.2 // indirect github.com/google/uuid v1.0.0 // indirect github.com/jmespath/go-jmespath v0.4.0 // indirect github.com/opencontainers/go-digest v1.0.0 // indirect github.com/opencontainers/image-spec v1.0.2 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect golang.org/x/mod v0.10.0 // indirect golang.org/x/sys v0.13.0 // indirect golang.org/x/tools v0.9.1 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index 559b2c7c..04c78377 100644 --- a/go.sum +++ b/go.sum @@ -80,8 +80,8 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= -github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY= -github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw= github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= @@ -151,12 +151,14 @@ golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8T golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +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.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10= gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v3 v3.0.0 h1:hjy8E9ON/egN1tAYqKb61G10WtihqetD4sz2H+8nIeA= gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gotest.tools/v3 v3.4.0 h1:ZazjZUfuVeZGLAmlKKuyv3IKP5orXcwtOwDQH6YVr6o= gotest.tools/v3 v3.4.0/go.mod h1:CtbdzLSsqVhDgMtKsx03ird5YTGB3ar27v0u/yKBW5g= nhooyr.io/websocket v1.8.7 h1:usjR2uOr/zjjkVMy0lW+PPohFok7PCow5sDjLgX4P4g= diff --git a/s3_test.go b/s3_test.go index 7ba0fe69..3ade1170 100644 --- a/s3_test.go +++ b/s3_test.go @@ -13,10 +13,10 @@ import ( "testing" "time" - . "github.com/aandryashin/matchers" "github.com/aerokube/selenoid/event" "github.com/aerokube/selenoid/session" "github.com/aerokube/selenoid/upload" + assert "github.com/stretchr/testify/require" ) var ( @@ -75,8 +75,8 @@ func TestS3Uploader(t *testing.T) { Type: "log", } uploaded, err := uploader.Upload(input) - AssertThat(t, err, Is{nil}) - AssertThat(t, uploaded, Is{true}) + assert.NoError(t, err) + assert.True(t, uploaded) } func TestGetKey(t *testing.T) { @@ -93,48 +93,48 @@ func TestGetKey(t *testing.T) { } key := upload.GetS3Key(testPattern, input) - AssertThat(t, key, EqualTo{"some-user/some-Session-id_internet-explorer_11_windows/log.txt"}) + assert.Equal(t, key, "some-user/some-Session-id_internet-explorer_11_windows/log.txt") input.Session.Caps.Name = "" input.Session.Caps.DeviceName = "internet explorer" key = upload.GetS3Key(testPattern, input) - AssertThat(t, key, EqualTo{"some-user/some-Session-id_internet-explorer_11_windows/log.txt"}) + assert.Equal(t, key, "some-user/some-Session-id_internet-explorer_11_windows/log.txt") input.Session.Caps.S3KeyPattern = "$quota/$fileType$fileExtension" key = upload.GetS3Key(testPattern, input) - AssertThat(t, key, EqualTo{"some-user/log.txt"}) + assert.Equal(t, key, "some-user/log.txt") input.Session.Caps.S3KeyPattern = "$fileName" key = upload.GetS3Key(testPattern, input) - AssertThat(t, key, EqualTo{"Some-File.txt"}) + assert.Equal(t, key, "Some-File.txt") } func TestFileMatches(t *testing.T) { matches, err := upload.FileMatches("", "", "any-file-name") - AssertThat(t, err, Is{nil}) - AssertThat(t, matches, Is{true}) + assert.NoError(t, err) + assert.True(t, matches) matches, err = upload.FileMatches("[", "", "/path/to/file.mp4") - AssertThat(t, err, Not{nil}) - AssertThat(t, matches, Is{false}) + assert.Error(t, err) + assert.False(t, matches) matches, err = upload.FileMatches("", "[", "/path/to/file.mp4") - AssertThat(t, err, Not{nil}) - AssertThat(t, matches, Is{false}) + assert.Error(t, err) + assert.False(t, matches) matches, err = upload.FileMatches("*.mp4", "", "/path/to/file.mp4") - AssertThat(t, err, Is{nil}) - AssertThat(t, matches, Is{true}) + assert.NoError(t, err) + assert.True(t, matches) matches, err = upload.FileMatches("*.mp4", "", "/path/to/file.log") - AssertThat(t, err, Is{nil}) - AssertThat(t, matches, Is{false}) + assert.NoError(t, err) + assert.False(t, matches) matches, err = upload.FileMatches("*.mp4", "", "/path/to/file.log") - AssertThat(t, err, Is{nil}) - AssertThat(t, matches, Is{false}) + assert.NoError(t, err) + assert.False(t, matches) matches, err = upload.FileMatches("", "*.log", "/path/to/file.log") - AssertThat(t, err, Is{nil}) - AssertThat(t, matches, Is{false}) + assert.NoError(t, err) + assert.False(t, matches) } diff --git a/selenoid_test.go b/selenoid_test.go index efeac113..357345a1 100644 --- a/selenoid_test.go +++ b/selenoid_test.go @@ -15,12 +15,11 @@ import ( "testing" "time" - . "github.com/aandryashin/matchers" - . "github.com/aandryashin/matchers/httpresp" ggr "github.com/aerokube/ggr/config" "github.com/aerokube/selenoid/config" "github.com/mafredri/cdp" "github.com/mafredri/cdp/rpcc" + assert "github.com/stretchr/testify/require" ) var _ = func() bool { @@ -49,56 +48,52 @@ func TestNewSessionWithGet(t *testing.T) { manager = &HTTPTest{Handler: Selenium()} rsp, err := http.Get(With(srv.URL).Path("/wd/hub/session")) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusMethodNotAllowed}) - - AssertThat(t, queue.Used(), EqualTo{0}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusMethodNotAllowed) + assert.Equal(t, queue.Used(), 0) } func TestBadJsonFormat(t *testing.T) { rsp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", nil) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusBadRequest}) - - AssertThat(t, queue.Used(), EqualTo{0}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusBadRequest) + assert.Equal(t, queue.Used(), 0) } func TestServiceStartupFailure(t *testing.T) { manager = &StartupError{} rsp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusInternalServerError}) - - AssertThat(t, queue.Used(), EqualTo{0}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusInternalServerError) + assert.Equal(t, queue.Used(), 0) } func TestBrowserNotFound(t *testing.T) { manager = &BrowserNotFound{} rsp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusBadRequest}) - - AssertThat(t, queue.Used(), EqualTo{0}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusBadRequest) + assert.Equal(t, queue.Used(), 0) } func TestGetDefaultScreenResolution(t *testing.T) { res, err := getScreenResolution("") - AssertThat(t, err, Is{nil}) - AssertThat(t, res, EqualTo{"1920x1080x24"}) + assert.NoError(t, err) + assert.Equal(t, res, "1920x1080x24") } func TestGetFullScreenResolution(t *testing.T) { res, err := getScreenResolution("1024x768x24") - AssertThat(t, err, Is{nil}) - AssertThat(t, res, EqualTo{"1024x768x24"}) + assert.NoError(t, err) + assert.Equal(t, res, "1024x768x24") } func TestGetShortScreenResolution(t *testing.T) { res, err := getScreenResolution("1024x768") - AssertThat(t, err, Is{nil}) - AssertThat(t, res, EqualTo{"1024x768x24"}) + assert.NoError(t, err) + assert.Equal(t, res, "1024x768x24") } func TestTooBigSessionTimeoutCapability(t *testing.T) { @@ -113,52 +108,48 @@ func testBadSessionTimeoutCapability(t *testing.T, timeoutValue string) { manager = &BrowserNotFound{} rsp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte(fmt.Sprintf(`{"desiredCapabilities":{"sessionTimeout":"%s"}}`, timeoutValue)))) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusBadRequest}) - - AssertThat(t, queue.Used(), EqualTo{0}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusBadRequest) + assert.Equal(t, queue.Used(), 0) } func TestMalformedScreenResolutionCapability(t *testing.T) { manager = &BrowserNotFound{} rsp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte(`{"desiredCapabilities":{"screenResolution":"bad-resolution"}}`))) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusBadRequest}) - - AssertThat(t, queue.Used(), EqualTo{0}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusBadRequest) + assert.Equal(t, queue.Used(), 0) } func TestGetVideoScreenSizeFromCapability(t *testing.T) { res, err := getVideoScreenSize("1024x768", "anything") - AssertThat(t, err, Is{nil}) - AssertThat(t, res, EqualTo{"1024x768"}) + assert.NoError(t, err) + assert.Equal(t, res, "1024x768") } func TestDetermineVideoScreenSizeFromScreenResolution(t *testing.T) { res, err := getVideoScreenSize("", "1024x768x24") - AssertThat(t, err, Is{nil}) - AssertThat(t, res, EqualTo{"1024x768"}) + assert.NoError(t, err) + assert.Equal(t, res, "1024x768") } func TestMalformedVideoScreenSizeCapability(t *testing.T) { manager = &BrowserNotFound{} rsp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte(`{"desiredCapabilities":{"videoScreenSize":"bad-size"}}`))) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusBadRequest}) - - AssertThat(t, queue.Used(), EqualTo{0}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusBadRequest) + assert.Equal(t, queue.Used(), 0) } func TestNewSessionNotFound(t *testing.T) { manager = &HTTPTest{Handler: Selenium()} rsp, err := http.Get(With(srv.URL).Path("/wd/hub/session/123")) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusNotFound}) - - AssertThat(t, queue.Used(), EqualTo{0}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusNotFound) + assert.Equal(t, queue.Used(), 0) } func TestNewSessionHostDown(t *testing.T) { @@ -175,13 +166,13 @@ func TestNewSessionHostDown(t *testing.T) { } rsp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusInternalServerError}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusInternalServerError) canceled = <-ch - AssertThat(t, canceled, Is{true}) + assert.True(t, canceled) - AssertThat(t, queue.Used(), EqualTo{0}) + assert.Equal(t, queue.Used(), 0) } func TestNewSessionBadHostResponse(t *testing.T) { @@ -193,13 +184,12 @@ func TestNewSessionBadHostResponse(t *testing.T) { } rsp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusBadRequest}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusBadRequest) canceled = <-ch - AssertThat(t, canceled, Is{true}) - - AssertThat(t, queue.Used(), EqualTo{0}) + assert.True(t, canceled) + assert.Equal(t, queue.Used(), 0) } func TestSessionCreated(t *testing.T) { @@ -207,16 +197,18 @@ func TestSessionCreated(t *testing.T) { timeout = 5 * time.Second resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte(`{"desiredCapabilities": {"enableVideo": true, "enableVNC": true, "sessionTimeout": "3s"}}`))) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) resp, err = http.Get(With(srv.URL).Path("/status")) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var state config.State - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&state}}) - AssertThat(t, state.Used, EqualTo{1}) - AssertThat(t, queue.Used(), EqualTo{1}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&state)) + assert.Equal(t, state.Used, 1) + assert.Equal(t, queue.Used(), 1) sessions.Remove(sess["sessionId"]) queue.Release() } @@ -225,26 +217,28 @@ func TestSessionCreatedW3C(t *testing.T) { manager = &HTTPTest{Handler: Selenium()} resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte(`{"capabilities":{"alwaysMatch":{"acceptInsecureCerts":true, "browserName":"firefox", "browserVersion":"latest", "selenoid:options":{"enableVNC": true}}}}`))) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) resp, err = http.Get(With(srv.URL).Path("/status")) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var state config.State - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&state}}) - AssertThat(t, state.Used, EqualTo{1}) - AssertThat(t, queue.Used(), EqualTo{1}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&state)) + assert.Equal(t, state.Used, 1) + assert.Equal(t, queue.Used(), 1) versions, firefoxPresent := state.Browsers["firefox"] - AssertThat(t, firefoxPresent, Is{true}) + assert.True(t, firefoxPresent) users, versionPresent := versions["latest"] - AssertThat(t, versionPresent, Is{true}) + assert.True(t, versionPresent) userInfo, userPresent := users["unknown"] - AssertThat(t, userPresent, Is{true}) - AssertThat(t, userInfo, Not{nil}) - AssertThat(t, len(userInfo.Sessions), EqualTo{1}) - AssertThat(t, userInfo.Sessions[0].VNC, EqualTo{true}) + assert.True(t, userPresent) + assert.NotNil(t, userInfo) + assert.Len(t, userInfo.Sessions, 1) + assert.True(t, userInfo.Sessions[0].VNC) sessions.Remove(sess["sessionId"]) queue.Release() @@ -254,26 +248,28 @@ func TestSessionCreatedFirstMatchOnly(t *testing.T) { manager = &HTTPTest{Handler: Selenium()} resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte(`{"capabilities":{"firstMatch":[{"browserName":"firefox", "browserVersion":"latest", "selenoid:options":{"enableVNC": true}}]}}`))) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) resp, err = http.Get(With(srv.URL).Path("/status")) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var state config.State - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&state}}) - AssertThat(t, state.Used, EqualTo{1}) - AssertThat(t, queue.Used(), EqualTo{1}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&state)) + assert.Equal(t, state.Used, 1) + assert.Equal(t, queue.Used(), 1) versions, firefoxPresent := state.Browsers["firefox"] - AssertThat(t, firefoxPresent, Is{true}) + assert.True(t, firefoxPresent) users, versionPresent := versions["latest"] - AssertThat(t, versionPresent, Is{true}) + assert.True(t, versionPresent) userInfo, userPresent := users["unknown"] - AssertThat(t, userPresent, Is{true}) - AssertThat(t, userInfo, Not{nil}) - AssertThat(t, len(userInfo.Sessions), EqualTo{1}) - AssertThat(t, userInfo.Sessions[0].VNC, EqualTo{true}) + assert.True(t, userPresent) + assert.NotNil(t, userInfo) + assert.Len(t, userInfo.Sessions, 1) + assert.True(t, userInfo.Sessions[0].VNC) sessions.Remove(sess["sessionId"]) queue.Release() @@ -288,16 +284,18 @@ func TestSessionCreatedWdHub(t *testing.T) { manager = &HTTPTest{Handler: root} resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) resp, err = http.Get(With(srv.URL).Path("/status")) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var state config.State - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&state}}) - AssertThat(t, state.Used, EqualTo{1}) - AssertThat(t, queue.Used(), EqualTo{1}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&state)) + assert.Equal(t, state.Used, 1) + assert.Equal(t, queue.Used(), 1) sessions.Remove(sess["sessionId"]) queue.Release() } @@ -306,22 +304,24 @@ func TestSessionWithContentTypeCreatedWdHub(t *testing.T) { root := http.NewServeMux() root.Handle("/wd/hub/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { r.URL.Path = strings.TrimPrefix(r.URL.Path, "/wd/hub") - AssertThat(t, r.Header.Get("Content-Type"), Is{"application/json; charset=utf-8"}) + assert.Equal(t, r.Header.Get("Content-Type"), "application/json; charset=utf-8") Selenium().ServeHTTP(w, r) })) manager = &HTTPTest{Handler: root} resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "application/json; charset=utf-8", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) resp, err = http.Get(With(srv.URL).Path("/status")) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var state config.State - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&state}}) - AssertThat(t, state.Used, EqualTo{1}) - AssertThat(t, queue.Used(), EqualTo{1}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&state)) + assert.Equal(t, state.Used, 1) + assert.Equal(t, queue.Used(), 1) sessions.Remove(sess["sessionId"]) queue.Release() } @@ -333,15 +333,16 @@ func TestSessionFailedAfterTimeout(t *testing.T) { })} resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) - AssertThat(t, resp, AllOf{Code{http.StatusInternalServerError}}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusInternalServerError) resp, err = http.Get(With(srv.URL).Path("/status")) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var state config.State - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&state}}) - AssertThat(t, state.Used, EqualTo{0}) - AssertThat(t, queue.Used(), EqualTo{0}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&state)) + assert.Equal(t, state.Used, 0) + assert.Equal(t, queue.Used(), 0) } func TestClientDisconnected(t *testing.T) { @@ -356,11 +357,12 @@ func TestClientDisconnected(t *testing.T) { cancel() resp, err := http.Get(With(srv.URL).Path("/status")) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var state config.State - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&state}}) - AssertThat(t, state.Used, EqualTo{0}) - AssertThat(t, queue.Used(), EqualTo{0}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&state)) + assert.Equal(t, state.Used, 0) + assert.Equal(t, queue.Used(), 0) } func TestSessionFailedAfterTwoTimeout(t *testing.T) { @@ -371,15 +373,16 @@ func TestSessionFailedAfterTwoTimeout(t *testing.T) { })} resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) - AssertThat(t, resp, AllOf{Code{http.StatusInternalServerError}}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusInternalServerError) resp, err = http.Get(With(srv.URL).Path("/status")) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var state config.State - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&state}}) - AssertThat(t, state.Used, EqualTo{0}) - AssertThat(t, queue.Used(), EqualTo{0}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&state)) + assert.Equal(t, state.Used, 0) + assert.Equal(t, queue.Used(), 0) } func TestSessionCreatedRedirect(t *testing.T) { @@ -395,19 +398,19 @@ func TestSessionCreatedRedirect(t *testing.T) { manager = &HTTPTest{Handler: root} resp, err := httpClient.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) - AssertThat(t, resp.StatusCode, Is{http.StatusFound}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusFound) location := resp.Header.Get("Location") - AssertThat(t, resp.StatusCode, Is{Not{""}}) fragments := strings.Split(location, "/") sid := fragments[len(fragments)-1] resp, err = http.Get(With(srv.URL).Path("/status")) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var state config.State - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&state}}) - AssertThat(t, state.Used, EqualTo{1}) - AssertThat(t, queue.Used(), EqualTo{1}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&state)) + assert.Equal(t, state.Used, 1) + assert.Equal(t, queue.Used(), 1) sessions.Remove(sid) queue.Release() } @@ -429,37 +432,38 @@ func TestSessionCreatedRemoveExtensionCapabilities(t *testing.T) { root := http.NewServeMux() root.Handle("/wd/hub/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { err := json.NewDecoder(r.Body).Decode(&browser) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) _, desiredCapabilitiesPresent = browser.Caps["selenoid:options"] _, alwaysMatchPresent = browser.W3CCaps.AlwaysMatch["selenoid:options"] _, chromeOptionsPresent = browser.W3CCaps.AlwaysMatch["goog:chromeOptions"] - AssertThat(t, len(browser.W3CCaps.FirstMatch), EqualTo{1}) + assert.Len(t, browser.W3CCaps.FirstMatch, 1) _, firstMatchPresent = browser.W3CCaps.FirstMatch[0]["selenoid:options"] })) manager = &HTTPTest{Handler: root} resp, err := httpClient.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte(`{"desiredCapabilities": {"browserName": "chrome", "selenoid:options": {"enableVNC": true}}, "capabilities":{"alwaysMatch":{"browserName": "chrome", "goog:chromeOptions": {"args": ["headless"]}, "selenoid:options":{"enableVNC": true}}, "firstMatch": [{"platform": "linux", "selenoid:options": {"enableVideo": true}}]}}`))) - AssertThat(t, err, Is{nil}) - AssertThat(t, resp, Code{http.StatusOK}) - AssertThat(t, desiredCapabilitiesPresent, Is{false}) - AssertThat(t, alwaysMatchPresent, Is{false}) - AssertThat(t, chromeOptionsPresent, Is{true}) - AssertThat(t, firstMatchPresent, Is{false}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) + assert.False(t, desiredCapabilitiesPresent) + assert.False(t, alwaysMatchPresent) + assert.True(t, chromeOptionsPresent) + assert.False(t, firstMatchPresent) } func TestProxySession(t *testing.T) { manager = &HTTPTest{Handler: Selenium()} resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) resp, err = http.Get(With(srv.URL).Path(fmt.Sprintf("/wd/hub/session/%s/url", sess["sessionId"]))) - AssertThat(t, err, Is{nil}) - AssertThat(t, resp, Code{http.StatusOK}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) - AssertThat(t, queue.Used(), EqualTo{1}) + assert.Equal(t, queue.Used(), 1) sessions.Remove(sess["sessionId"]) queue.Release() } @@ -469,13 +473,14 @@ func TestProxySessionPanicOnAbortHandler(t *testing.T) { manager = &HTTPTest{Handler: Selenium()} resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) req, _ := http.NewRequest(http.MethodGet, With(srv.URL).Path(fmt.Sprintf("/wd/hub/session/%s/url?abort-handler=true", sess["sessionId"])), nil) resp, err = http.DefaultClient.Do(req) - AssertThat(t, err, Not{nil}) + assert.NoError(t, err) sessions.Remove(sess["sessionId"]) queue.Release() @@ -490,39 +495,42 @@ func TestSessionDeleted(t *testing.T) { } resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte(`{"desiredCapabilities": {"enableVideo": true}}`))) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) req, _ := http.NewRequest(http.MethodDelete, With(srv.URL).Path(fmt.Sprintf("/wd/hub/session/%s", sess["sessionId"])), nil) http.DefaultClient.Do(req) resp, err = http.Get(With(srv.URL).Path("/status")) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var state config.State - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&state}}) - AssertThat(t, state.Used, EqualTo{0}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&state)) + assert.Equal(t, state.Used, 0) canceled = <-ch - AssertThat(t, canceled, Is{true}) + assert.True(t, canceled) - AssertThat(t, queue.Used(), EqualTo{0}) + assert.Equal(t, queue.Used(), 0) } func TestSessionOnClose(t *testing.T) { manager = &HTTPTest{Handler: Selenium()} resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) req, _ := http.NewRequest(http.MethodDelete, With(srv.URL).Path(fmt.Sprintf("/wd/hub/session/%s/window", sess["sessionId"])), nil) - http.DefaultClient.Do(req) + _, _ = http.DefaultClient.Do(req) - AssertThat(t, queue.Used(), EqualTo{1}) + assert.Equal(t, queue.Used(), 1) sessions.Remove(sess["sessionId"]) queue.Release() } @@ -537,29 +545,30 @@ func TestProxySessionCanceled(t *testing.T) { timeout = 100 * time.Millisecond resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) _, ok := sessions.Get(sess["sessionId"]) - AssertThat(t, ok, Is{true}) + assert.True(t, ok) req, _ := http.NewRequest(http.MethodGet, With(srv.URL).Path(fmt.Sprintf("/wd/hub/session/%s/url?timeout=1s", sess["sessionId"])), nil) ctx, cancel := context.WithCancel(context.Background()) req = req.WithContext(ctx) go func() { - http.DefaultClient.Do(req) + _, _ = http.DefaultClient.Do(req) }() <-time.After(50 * time.Millisecond) cancel() <-time.After(100 * time.Millisecond) _, ok = sessions.Get(sess["sessionId"]) - AssertThat(t, ok, Is{false}) + assert.False(t, ok) canceled = <-ch - AssertThat(t, canceled, Is{true}) + assert.True(t, canceled) - AssertThat(t, queue.Used(), EqualTo{0}) + assert.Equal(t, queue.Used(), 0) } func TestNewSessionTimeout(t *testing.T) { @@ -572,21 +581,22 @@ func TestNewSessionTimeout(t *testing.T) { timeout = 30 * time.Millisecond resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) _, ok := sessions.Get(sess["sessionId"]) - AssertThat(t, ok, Is{true}) + assert.True(t, ok) <-time.After(50 * time.Millisecond) _, ok = sessions.Get(sess["sessionId"]) - AssertThat(t, ok, Is{false}) + assert.False(t, ok) canceled = <-ch - AssertThat(t, canceled, Is{true}) + assert.True(t, canceled) - AssertThat(t, queue.Used(), EqualTo{0}) + assert.Equal(t, queue.Used(), 0) } func TestProxySessionTimeout(t *testing.T) { @@ -599,63 +609,63 @@ func TestProxySessionTimeout(t *testing.T) { timeout = 30 * time.Millisecond resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) _, ok := sessions.Get(sess["sessionId"]) - AssertThat(t, ok, Is{true}) + assert.True(t, ok) <-time.After(20 * time.Millisecond) _, ok = sessions.Get(sess["sessionId"]) - AssertThat(t, ok, Is{true}) - http.Get(With(srv.URL).Path(fmt.Sprintf("/wd/hub/session/%s/url", sess["sessionId"]))) + assert.True(t, ok) + _, _ = http.Get(With(srv.URL).Path(fmt.Sprintf("/wd/hub/session/%s/url", sess["sessionId"]))) <-time.After(20 * time.Millisecond) _, ok = sessions.Get(sess["sessionId"]) - AssertThat(t, ok, Is{true}) + assert.True(t, ok) <-time.After(50 * time.Millisecond) _, ok = sessions.Get(sess["sessionId"]) - AssertThat(t, ok, Is{false}) + assert.False(t, ok) canceled = <-ch - AssertThat(t, canceled, Is{true}) + assert.True(t, canceled) - AssertThat(t, queue.Used(), EqualTo{0}) + assert.Equal(t, queue.Used(), 0) } func TestFileUpload(t *testing.T) { manager = &HTTPTest{Handler: Selenium()} resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) - + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) fileContents := []byte(`{"file":"UEsDBBQACAgIAJiC4koAAAAAAAAAAAAAAAAJAAAAaGVsbG8udHh080jNyclXCM8vyklRBABQSwcIoxwpHA4AAAAMAAAAUEsBAhQAFAAICAgAmILiSqMcKRwOAAAADAAAAAkAAAAAAAAAAAAAAAAAAAAAAGhlbGxvLnR4dFBLBQYAAAAAAQABADcAAABFAAAAAAA="}`) //Doing two times to test sequential upload resp, err = http.Post(With(srv.URL).Path(fmt.Sprintf("/wd/hub/session/%s/file", sess["sessionId"])), "", bytes.NewReader(fileContents)) - AssertThat(t, err, Is{nil}) - AssertThat(t, resp, Code{http.StatusOK}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) resp, err = http.Post(With(srv.URL).Path(fmt.Sprintf("/wd/hub/session/%s/file", sess["sessionId"])), "", bytes.NewReader(fileContents)) - AssertThat(t, err, Is{nil}) - AssertThat(t, resp, Code{http.StatusOK}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var jsonResponse map[string]string - - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&jsonResponse}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&jsonResponse)) f, err := os.Open(jsonResponse["value"]) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) content, err := io.ReadAll(f) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) - AssertThat(t, string(content), EqualTo{"Hello World!"}) + assert.Equal(t, string(content), "Hello World!") sessions.Remove(sess["sessionId"]) queue.Release() @@ -665,14 +675,14 @@ func TestFileUploadBadJson(t *testing.T) { manager = &HTTPTest{Handler: Selenium()} resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) - + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) resp, err = http.Post(With(srv.URL).Path(fmt.Sprintf("/wd/hub/session/%s/file", sess["sessionId"])), "", bytes.NewReader([]byte(`malformed json`))) - AssertThat(t, err, Is{nil}) - AssertThat(t, resp, Code{http.StatusBadRequest}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusBadRequest) sessions.Remove(sess["sessionId"]) queue.Release() @@ -682,14 +692,14 @@ func TestFileUploadNoFile(t *testing.T) { manager = &HTTPTest{Handler: Selenium()} resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) - + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) resp, err = http.Post(With(srv.URL).Path(fmt.Sprintf("/wd/hub/session/%s/file", sess["sessionId"])), "", bytes.NewReader([]byte(`{}`))) - AssertThat(t, err, Is{nil}) - AssertThat(t, resp, Code{http.StatusBadRequest}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusBadRequest) sessions.Remove(sess["sessionId"]) queue.Release() @@ -699,14 +709,14 @@ func TestFileUploadTwoFiles(t *testing.T) { manager = &HTTPTest{Handler: Selenium()} resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) - + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) resp, err = http.Post(With(srv.URL).Path(fmt.Sprintf("/wd/hub/session/%s/file", sess["sessionId"])), "", bytes.NewReader([]byte(`{"file":"UEsDBAoAAAAAAKGJ4koAAAAAAAAAAAAAAAAHABwAb25lLnR4dFVUCQADbv9YWZT/WFl1eAsAAQT1AQAABBQAAABQSwMECgAAAAAApIniSgAAAAAAAAAAAAAAAAcAHAB0d28udHh0VVQJAANz/1hZc/9YWXV4CwABBPUBAAAEFAAAAFBLAQIeAwoAAAAAAKGJ4koAAAAAAAAAAAAAAAAHABgAAAAAAAAAAACkgQAAAABvbmUudHh0VVQFAANu/1hZdXgLAAEE9QEAAAQUAAAAUEsBAh4DCgAAAAAApIniSgAAAAAAAAAAAAAAAAcAGAAAAAAAAAAAAKSBQQAAAHR3by50eHRVVAUAA3P/WFl1eAsAAQT1AQAABBQAAABQSwUGAAAAAAIAAgCaAAAAggAAAAAA"}`))) - AssertThat(t, err, Is{nil}) - AssertThat(t, resp, Code{http.StatusBadRequest}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusBadRequest) sessions.Remove(sess["sessionId"]) queue.Release() @@ -715,99 +725,99 @@ func TestFileUploadTwoFiles(t *testing.T) { func TestPing(t *testing.T) { rsp, err := http.Get(With(srv.URL).Path("/ping")) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusOK}) - AssertThat(t, rsp.Body, Is{Not{nil}}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusOK) + assert.NotNil(t, rsp.Body) var data map[string]interface{} bt, readErr := io.ReadAll(rsp.Body) - AssertThat(t, readErr, Is{nil}) + assert.NoError(t, readErr) jsonErr := json.Unmarshal(bt, &data) - AssertThat(t, jsonErr, Is{nil}) + assert.NoError(t, jsonErr) _, hasUptime := data["uptime"] - AssertThat(t, hasUptime, Is{true}) + assert.True(t, hasUptime) _, hasLastReloadTime := data["lastReloadTime"] - AssertThat(t, hasLastReloadTime, Is{true}) + assert.True(t, hasLastReloadTime) _, hasNumRequests := data["numRequests"] - AssertThat(t, hasNumRequests, Is{true}) + assert.True(t, hasNumRequests) version, hasVersion := data["version"] - AssertThat(t, hasVersion, Is{true}) - AssertThat(t, version, EqualTo{"test-revision"}) + assert.True(t, hasVersion) + assert.Equal(t, version, "test-revision") } func TestStatus(t *testing.T) { rsp, err := http.Get(With(srv.URL).Path("/wd/hub/status")) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusOK}) - AssertThat(t, rsp.Body, Is{Not{nil}}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusOK) + assert.NotNil(t, rsp.Body) var data map[string]interface{} bt, readErr := io.ReadAll(rsp.Body) - AssertThat(t, readErr, Is{nil}) + assert.NoError(t, readErr) jsonErr := json.Unmarshal(bt, &data) - AssertThat(t, jsonErr, Is{nil}) + assert.NoError(t, jsonErr) value, hasValue := data["value"] - AssertThat(t, hasValue, Is{true}) + assert.True(t, hasValue) valueMap := value.(map[string]interface{}) ready, hasReady := valueMap["ready"] - AssertThat(t, hasReady, Is{true}) - AssertThat(t, ready, Is{true}) + assert.True(t, hasReady) + assert.Equal(t, ready, true) _, hasMessage := valueMap["message"] - AssertThat(t, hasMessage, Is{true}) + assert.True(t, hasMessage) } func TestServeAndDeleteVideoFile(t *testing.T) { fileName := "testfile" filePath := filepath.Join(videoOutputDir, fileName) - os.WriteFile(filePath, []byte("test-data"), 0644) + _ = os.WriteFile(filePath, []byte("test-data"), 0644) rsp, err := http.Get(With(srv.URL).Path("/video/testfile")) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusOK}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusOK) rsp, err = http.Get(With(srv.URL).Path("/video/?json")) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusOK}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusOK) var files []string - AssertThat(t, rsp, IsJson{&files}) - AssertThat(t, files, EqualTo{[]string{"testfile"}}) + assert.NoError(t, json.NewDecoder(rsp.Body).Decode(&files)) + assert.Equal(t, files, []string{"testfile"}) deleteReq, _ := http.NewRequest(http.MethodDelete, With(srv.URL).Path("/video/testfile"), nil) rsp, err = http.DefaultClient.Do(deleteReq) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusOK}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusOK) //Deleting already deleted file rsp, err = http.DefaultClient.Do(deleteReq) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusNotFound}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusNotFound) } func TestServeAndDeleteLogFile(t *testing.T) { fileName := "logfile.log" filePath := filepath.Join(logOutputDir, fileName) - os.WriteFile(filePath, []byte("test-data"), 0644) + _ = os.WriteFile(filePath, []byte("test-data"), 0644) rsp, err := http.Get(With(srv.URL).Path("/logs/logfile.log")) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusOK}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusOK) rsp, err = http.Get(With(srv.URL).Path("/logs/?json")) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusOK}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusOK) var files []string - AssertThat(t, rsp, IsJson{&files}) - AssertThat(t, len(files) > 0, Is{true}) + assert.NoError(t, json.NewDecoder(rsp.Body).Decode(&files)) + assert.True(t, len(files) > 0) deleteReq, _ := http.NewRequest(http.MethodDelete, With(srv.URL).Path("/logs/logfile.log"), nil) rsp, err = http.DefaultClient.Do(deleteReq) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusOK}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusOK) rsp, err = http.DefaultClient.Do(deleteReq) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusNotFound}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusNotFound) } func TestFileDownload(t *testing.T) { @@ -826,17 +836,17 @@ func testFileDownload(t *testing.T, path func(string) string) { manager = &HTTPTest{Handler: Selenium()} resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) - + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) rsp, err := http.Get(With(srv.URL).Path(path(sess["sessionId"]))) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusOK}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) data, err := io.ReadAll(rsp.Body) - AssertThat(t, err, Is{nil}) - AssertThat(t, string(data), EqualTo{"test-data"}) + assert.NoError(t, err) + assert.Equal(t, string(data), "test-data") sessions.Remove(sess["sessionId"]) queue.Release() @@ -844,8 +854,8 @@ func testFileDownload(t *testing.T, path func(string) string) { func TestFileDownloadMissingSession(t *testing.T) { rsp, err := http.Get(With(srv.URL).Path("/download/missing-session/testfile")) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusNotFound}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusNotFound) } func TestClipboard(t *testing.T) { @@ -864,21 +874,21 @@ func testClipboard(t *testing.T, path func(string) string) { manager = &HTTPTest{Handler: Selenium()} resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) - + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) rsp, err := http.Get(With(srv.URL).Path(path(sess["sessionId"]))) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusOK}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) data, err := io.ReadAll(rsp.Body) - AssertThat(t, err, Is{nil}) - AssertThat(t, string(data), EqualTo{"test-clipboard-value"}) + assert.NoError(t, err) + assert.Equal(t, string(data), "test-clipboard-value") rsp, err = http.Post(With(srv.URL).Path(path(sess["sessionId"])), "text/plain", bytes.NewReader([]byte("any-data"))) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusOK}) + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) sessions.Remove(sess["sessionId"]) queue.Release() @@ -886,18 +896,18 @@ func testClipboard(t *testing.T, path func(string) string) { func TestClipboardMissingSession(t *testing.T) { rsp, err := http.Get(With(srv.URL).Path("/clipboard/missing-session")) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusNotFound}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusNotFound) } func TestDevtools(t *testing.T) { manager = &HTTPTest{Handler: Selenium()} resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) - + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) u := fmt.Sprintf("ws://%s/devtools/%s", srv.Listener.Addr().String(), sess["sessionId"]) @@ -905,12 +915,12 @@ func TestDevtools(t *testing.T) { defer cancel() conn, err := rpcc.DialContext(ctx, u) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) defer conn.Close() c := cdp.NewClient(conn) err = c.Page.Enable(ctx) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) sessions.Remove(sess["sessionId"]) queue.Release() @@ -920,21 +930,21 @@ func TestAddedSeCdpCapability(t *testing.T) { manager = &HTTPTest{Handler: Selenium()} resp, err := http.Post(With(srv.URL).Path("/wd/hub/session"), "", bytes.NewReader([]byte("{}"))) - AssertThat(t, err, Is{nil}) - + assert.NoError(t, err) + assert.Equal(t, resp.StatusCode, http.StatusOK) var sess map[string]string - AssertThat(t, resp, AllOf{Code{http.StatusOK}, IsJson{&sess}}) + assert.NoError(t, json.NewDecoder(resp.Body).Decode(&sess)) ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond) defer cancel() conn, err := rpcc.DialContext(ctx, sess["se:cdp"]) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) defer conn.Close() c := cdp.NewClient(conn) err = c.Page.Enable(ctx) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) sessions.Remove(sess["sessionId"]) queue.Release() @@ -942,16 +952,16 @@ func TestAddedSeCdpCapability(t *testing.T) { func TestParseGgrHost(t *testing.T) { h := parseGgrHost("some-host.example.com:4444") - AssertThat(t, h.Name, EqualTo{"some-host.example.com"}) - AssertThat(t, h.Port, EqualTo{4444}) + assert.Equal(t, h.Name, "some-host.example.com") + assert.Equal(t, h.Port, 4444) } func TestWelcomeScreen(t *testing.T) { rsp, err := http.Get(With(srv.URL).Path("/")) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusOK}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusOK) rsp, err = http.Get(With(srv.URL).Path("/wd/hub")) - AssertThat(t, err, Is{nil}) - AssertThat(t, rsp, Code{http.StatusOK}) + assert.NoError(t, err) + assert.Equal(t, rsp.StatusCode, http.StatusOK) } diff --git a/service_test.go b/service_test.go index b59f6289..86012f16 100644 --- a/service_test.go +++ b/service_test.go @@ -13,13 +13,13 @@ import ( "testing" "time" - . "github.com/aandryashin/matchers" "github.com/aerokube/selenoid/config" "github.com/aerokube/selenoid/service" "github.com/aerokube/selenoid/session" "github.com/aerokube/util" "github.com/docker/docker/api/types/container" "github.com/docker/docker/client" + assert "github.com/stretchr/testify/require" "golang.org/x/net/websocket" ) @@ -40,8 +40,8 @@ func updateMux(mux http.Handler) { lock.Lock() defer lock.Unlock() mockServer = httptest.NewServer(mux) - os.Setenv("DOCKER_HOST", "tcp://"+hostPort(mockServer.URL)) - os.Setenv("DOCKER_API_VERSION", "1.29") + _ = os.Setenv("DOCKER_HOST", "tcp://"+hostPort(mockServer.URL)) + _ = os.Setenv("DOCKER_API_VERSION", "1.29") cli, _ = client.NewClientWithOpts(client.FromEnv) } @@ -263,18 +263,18 @@ func TestFindDockerIPSpecified(t *testing.T) { func testDocker(t *testing.T, env *service.Environment, cfg *config.Config) { starter := createDockerStarter(t, env, cfg) startedService, err := starter.StartWithCancel() - AssertThat(t, err, Is{nil}) - AssertThat(t, startedService.Url, Not{nil}) - AssertThat(t, startedService.Container, Not{nil}) - AssertThat(t, startedService.Container.ID, EqualTo{"e90e34656806"}) - AssertThat(t, startedService.HostPort.VNC, EqualTo{"127.0.0.1:5900"}) - AssertThat(t, startedService.Cancel, Not{nil}) + assert.NoError(t, err) + assert.NotNil(t, startedService.Url) + assert.NotNil(t, startedService.Container) + assert.Equal(t, startedService.Container.ID, "e90e34656806") + assert.Equal(t, startedService.HostPort.VNC, "127.0.0.1:5900") + assert.NotNil(t, startedService.Cancel) startedService.Cancel() } func createDockerStarter(t *testing.T, env *service.Environment, cfg *config.Config) service.Starter { cli, err := client.NewClientWithOpts(client.FromEnv) - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) manager := service.DefaultManager{Environment: env, Client: cli, Config: cfg} caps := session.Caps{ DeviceName: "firefox", @@ -299,8 +299,8 @@ func createDockerStarter(t *testing.T, env *service.Environment, cfg *config.Con TestName: "my-cool-test", } starter, success := manager.Find(caps, 42) - AssertThat(t, success, Is{true}) - AssertThat(t, starter, Not{nil}) + assert.True(t, success) + assert.NotNil(t, starter) return starter } @@ -334,8 +334,8 @@ func TestDeleteContainerOnStartupError(t *testing.T) { env := testEnvironment() starter := createDockerStarter(t, env, testConfig(env)) _, err := starter.StartWithCancel() - AssertThat(t, err, Not{nil}) - AssertThat(t, numDeleteRequests, EqualTo{1}) + assert.NoError(t, err) + assert.Equal(t, numDeleteRequests, 1) } func TestFindDriver(t *testing.T) { @@ -347,8 +347,8 @@ func TestFindDriver(t *testing.T) { VNC: true, } starter, success := manager.Find(caps, 42) - AssertThat(t, success, Is{true}) - AssertThat(t, starter, Not{nil}) + assert.True(t, success) + assert.NotNil(t, starter) } func TestGetVNC(t *testing.T) { @@ -365,7 +365,7 @@ func TestGetVNC(t *testing.T) { defer sessions.Remove("test-session") u := fmt.Sprintf("ws://%s/vnc/test-session", util.HostPort(srv.URL)) - AssertThat(t, readDataFromWebSocket(t, u), EqualTo{"test-data"}) + assert.Equal(t, readDataFromWebSocket(t, u), "test-data") } func testTCPServer(data string) net.Listener { @@ -376,8 +376,8 @@ func testTCPServer(data string) net.Listener { if err != nil { continue } - io.WriteString(conn, data) - conn.Close() + _, _ = io.WriteString(conn, data) + _ = conn.Close() return } }() @@ -386,12 +386,12 @@ func testTCPServer(data string) net.Listener { func readDataFromWebSocket(t *testing.T, wsURL string) string { ws, err := websocket.Dial(wsURL, "", "http://localhost") - AssertThat(t, err, Is{nil}) + assert.NoError(t, err) var msg = make([]byte, 512) _, err = ws.Read(msg) msg = bytes.Trim(msg, "\x00") - //AssertThat(t, err, Is{nil}) + //assert.NoError(t, err) return string(msg) } @@ -409,5 +409,5 @@ func TestGetLogs(t *testing.T) { defer sessions.Remove("test-session") u := fmt.Sprintf("ws://%s/logs/test-session", util.HostPort(srv.URL)) - AssertThat(t, readDataFromWebSocket(t, u), EqualTo{"test-data"}) + assert.Equal(t, readDataFromWebSocket(t, u), "test-data") } diff --git a/utils_test.go b/utils_test.go index 23d5682a..e6338cd5 100644 --- a/utils_test.go +++ b/utils_test.go @@ -15,12 +15,12 @@ import ( "testing" "time" - . "github.com/aandryashin/matchers" "github.com/aerokube/selenoid/protect" "github.com/aerokube/selenoid/service" "github.com/aerokube/selenoid/session" "github.com/gorilla/websocket" "github.com/pborman/uuid" + assert "github.com/stretchr/testify/require" ) type HTTPTest struct { @@ -199,20 +199,20 @@ func TestProcessExtensionCapabilities(t *testing.T) { }` var caps session.Caps err := json.Unmarshal([]byte(capsJson), &caps) - AssertThat(t, err, Is{nil}) - AssertThat(t, caps.Name, EqualTo{"firefox"}) - AssertThat(t, caps.Version, EqualTo{"57.0"}) - AssertThat(t, caps.TestName, EqualTo{""}) + assert.NoError(t, err) + assert.Equal(t, caps.Name, "firefox") + assert.Equal(t, caps.Version, "57.0") + assert.Equal(t, caps.TestName, "") caps.ProcessExtensionCapabilities() - AssertThat(t, caps.Name, EqualTo{"firefox"}) - AssertThat(t, caps.Version, EqualTo{"57.0"}) - AssertThat(t, caps.DeviceName, EqualTo{"android"}) - AssertThat(t, caps.TestName, EqualTo{"ExampleTestName"}) - AssertThat(t, caps.VNC, EqualTo{true}) - AssertThat(t, caps.VideoFrameRate, EqualTo{uint16(24)}) - AssertThat(t, caps.Env, EqualTo{[]string{"LANG=de_DE.UTF-8"}}) - AssertThat(t, caps.Labels, EqualTo{map[string]string{"key": "value"}}) + assert.Equal(t, caps.Name, "firefox") + assert.Equal(t, caps.Version, "57.0") + assert.Equal(t, caps.DeviceName, "android") + assert.Equal(t, caps.TestName, "ExampleTestName") + assert.True(t, caps.VNC) + assert.Equal(t, caps.VideoFrameRate, uint16(24)) + assert.Equal(t, caps.Env, []string{"LANG=de_DE.UTF-8"}) + assert.Equal(t, caps.Labels, map[string]string{"key": "value"}) } func TestSumUsedTotalGreaterThanPending(t *testing.T) { @@ -230,27 +230,28 @@ func TestSumUsedTotalGreaterThanPending(t *testing.T) { u := srv.URL + "/" _, err := http.Get(u) - AssertThat(t, err, Is{nil}) - AssertThat(t, queue.Pending(), EqualTo{1}) + assert.NoError(t, err) + assert.Equal(t, queue.Pending(), 1) queue.Create() - AssertThat(t, queue.Pending(), EqualTo{0}) - AssertThat(t, queue.Used(), EqualTo{1}) + assert.Equal(t, queue.Pending(), 0) + assert.Equal(t, queue.Used(), 1) _, err = http.Get(u) - AssertThat(t, err, Is{nil}) - AssertThat(t, queue.Pending(), EqualTo{1}) + assert.NoError(t, err) + assert.Equal(t, queue.Pending(), 1) queue.Create() - AssertThat(t, queue.Pending(), EqualTo{0}) - AssertThat(t, queue.Used(), EqualTo{2}) + assert.Equal(t, queue.Pending(), 0) + assert.Equal(t, queue.Used(), 2) req, _ := http.NewRequest(http.MethodGet, u, nil) - ctx, _ := context.WithTimeout(context.Background(), 100*time.Millisecond) + ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond) + defer cancel() req = req.WithContext(ctx) _, err = http.DefaultClient.Do(req) - AssertThat(t, err, Not{nil}) - AssertThat(t, queue.Pending(), EqualTo{0}) - AssertThat(t, queue.Used(), EqualTo{2}) + assert.NoError(t, err) + assert.Equal(t, queue.Pending(), 0) + assert.Equal(t, queue.Used(), 2) } func TestBrowserName(t *testing.T) { @@ -260,15 +261,15 @@ func TestBrowserName(t *testing.T) { "appium:deviceName": "iPhone 7" }` err := json.Unmarshal([]byte(capsJson), &caps) - AssertThat(t, err, Is{nil}) - AssertThat(t, caps.BrowserName(), EqualTo{"iPhone 7"}) + assert.NoError(t, err) + assert.Equal(t, caps.BrowserName(), "iPhone 7") capsJson = `{ "deviceName": "android 11" }` err = json.Unmarshal([]byte(capsJson), &caps) - AssertThat(t, err, Is{nil}) - AssertThat(t, caps.BrowserName(), EqualTo{"android 11"}) + assert.NoError(t, err) + assert.Equal(t, caps.BrowserName(), "android 11") capsJson = `{ "deviceName": "android 11", @@ -276,6 +277,6 @@ func TestBrowserName(t *testing.T) { "browserName": "firefox" }` err = json.Unmarshal([]byte(capsJson), &caps) - AssertThat(t, err, Is{nil}) - AssertThat(t, caps.BrowserName(), EqualTo{"firefox"}) + assert.NoError(t, err) + assert.Equal(t, caps.BrowserName(), "firefox") }