remote_test.go

package webdriver

import (
	"flag"
	"fmt"
	"math"
	"net"
	"net/http"
	"net/http/httptest"
	"net/url"
	"os"
	"os/exec"
	"path/filepath"
	"reflect"
	"strings"
	"testing"
	"time"

	"github.com/blang/semver"
	"github.com/google/go-cmp/cmp"
	"github.com/radutopala/webdriver/chrome"
	"github.com/radutopala/webdriver/log"
)

var (
	chromeBinary = flag.String("chrome_binary", "/usr/bin/chrome", "The name of the Chrome binary or the path to it. If name is not an exact path, the PATH will be searched.")

	useDocker          = flag.Bool("docker", false, "If set, run the tests in a Docker container.")
	runningUnderDocker = flag.Bool("running_under_docker", false, "This is set by the Docker test harness and should not be needed otherwise.")

	serverURL string
)

func TestMain(m *testing.M) {
	flag.Parse()
	s := httptest.NewServer(http.HandlerFunc(handler))
	serverURL = s.URL
	defer s.Close()
	os.Exit(m.Run())
}

func pickUnusedPort() (int, error) {
	addr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:0")
	if err != nil {
		return 0, err
	}

	l, err := net.ListenTCP("tcp", addr)
	if err != nil {
		return 0, err
	}
	port := l.Addr().(*net.TCPAddr).Port
	if err := l.Close(); err != nil {
		return 0, err
	}
	return port, nil
}

type config struct {
	browser, path  string
	serviceOptions []ServiceOption
}

func TestChrome(t *testing.T) {
	if *useDocker {
		t.Skip("Skipping Chrome tests because they will be run under a Docker container")
	}
	if _, err := os.Stat(*chromeBinary); err != nil {
		path, err := exec.LookPath(*chromeBinary)
		if err != nil {
			t.Skipf("Skipping Chrome tests because binary %q not found", *chromeBinary)
		}
		*chromeBinary = path
	}

	var opts []ServiceOption
	if testing.Verbose() {
		SetDebug(true)
		opts = append(opts, Output(os.Stderr))
	}

	s, err := NewService(opts...)
	if err != nil {
		t.Fatalf("Error starting the ChromeDriver server: %v", err)
	}
	c := config{
		browser: "chrome",
		path:    *chromeBinary,
	}

	runTests(t, c)

	if err := s.Stop(); err != nil {
		t.Fatalf("Error stopping the ChromeDriver service: %v", err)
	}
}

func testChromeExtension(t *testing.T, c config) {
	t.Skip("Skipping Chrome Extension test it fails with headless true")
	caps := newTestCapabilities(t, c)
	co := caps[chrome.CapabilitiesKey].(chrome.Capabilities)
	const path = "testing/chrome-extension/css_page_red"
	if err := co.AddUnpackedExtension(path); err != nil {
		t.Fatalf("co.AddExtension(%q) returned error: %v", path, err)
	}
	caps[chrome.CapabilitiesKey] = co

	wd, err := NewRemote(caps, "")
	if err != nil {
		t.Fatalf("NewRemote(%+v) returned error: %v", caps, err)
	}
	defer wd.Quit()

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}

	e, err := wd.FindElement(ByCSSSelector, "body")
	if err != nil {
		t.Fatalf("error finding body: %v", err)
	}

	const property = "background-color"
	color, err := e.CSSProperty(property)
	if err != nil {
		t.Fatalf(`e.CSSProperty(%q) returned error: %v`, property, err)
	}

	const wantColor = "rgba(255, 0, 0, 1)"
	if color != wantColor {
		t.Fatalf("body background has color %q, want %q", color, wantColor)
	}
}

func TestDocker(t *testing.T) {
	if *runningUnderDocker {
		return
	}
	if !*useDocker {
		t.Skip("Skipping Docker tests because --docker was not specified.")
	}

	args := []string{"build", "-t", "webdriver", "testing/"}
	if out, err := exec.Command("docker", args...).CombinedOutput(); err != nil {
		t.Logf("Output from `docker %s`:\n%s", strings.Join(args, " "), string(out))
		t.Fatalf("Building Docker container failed: %v", err)
	}

	pathToMount := os.Getenv("GOPATH")
	if strings.Contains(pathToMount, ":") {
		cwd, err := os.Getwd()
		if err != nil {
			t.Fatalf("os.Getwd() returned error: %v", err)
		}
		pathToMount = filepath.Join(cwd, "../../../..")
	}
	// TODO(minusnine): pass through relevant flags to docker-test.sh to be
	// passed to go test.
	cmd := exec.Command("docker", "run", fmt.Sprintf("--volume=%s:/code", pathToMount), "--workdir=/code/src/github.com/radutopala/webdriver", "webdriver", "testing/docker-test.sh")
	if testing.Verbose() {
		cmd.Stdout = os.Stdout
		cmd.Stderr = os.Stderr
	}
	if err := cmd.Run(); err != nil {
		t.Fatalf("docker run failed: %v", err)
	}
}

func newTestCapabilities(t *testing.T, c config) Capabilities {
	caps := Capabilities{
		"browserName": c.browser,
	}
	switch c.browser {
	case "chrome":
		chrCaps := chrome.Capabilities{
			Path: c.path,
			Args: []string{
				// This flag is needed to test against Chrome binaries that are not the
				// default installation. The sandbox requires a setuid binary.
				"--headless",
				"--disable-gpu",
				"--no-sandbox",
				"--window-size=1200,1100",
			},
		}
		caps.AddChrome(chrCaps)
	}

	return caps
}

func newRemote(t *testing.T, c config) WebDriver {
	caps := newTestCapabilities(t, c)
	wd, err := NewRemote(caps, "")
	if err != nil {
		t.Fatalf("NewRemote(%+v) returned error: %v", caps, err)
	}
	return wd
}

func quitRemote(t *testing.T, wd WebDriver) {
	if err := wd.Quit(); err != nil {
		t.Errorf("wd.Quit() returned error: %v", err)
	}
}

func runTest(f func(*testing.T, config), c config) func(*testing.T) {
	return func(t *testing.T) {
		f(t, c)
	}
}

func runTests(t *testing.T, c config) {
	t.Run("Status", runTest(testStatus, c))
	t.Run("NewSession", runTest(testNewSession, c))
	t.Run("Error", runTest(testError, c))
	t.Run("Capabilities", runTest(testCapabilities, c))
	t.Run("SetAsyncScriptTimeout", runTest(testSetAsyncScriptTimeout, c))
	t.Run("SetImplicitWaitTimeout", runTest(testSetImplicitWaitTimeout, c))
	t.Run("SetPageLoadTimeout", runTest(testSetPageLoadTimeout, c))
	t.Run("Windows", runTest(testWindows, c))
	t.Run("Get", runTest(testGet, c))
	t.Run("Navigation", runTest(testNavigation, c))
	t.Run("Title", runTest(testTitle, c))
	t.Run("PageSource", runTest(testPageSource, c))
	t.Run("FindElement", runTest(testFindElement, c))
	t.Run("FindElements", runTest(testFindElements, c))
	t.Run("SendKeys", runTest(testSendKeys, c))
	t.Run("Click", runTest(testClick, c))
	t.Run("GetCookies", runTest(testGetCookies, c))
	t.Run("GetCookie", runTest(testGetCookie, c))
	t.Run("AddCookie", runTest(testAddCookie, c))
	t.Run("DeleteCookie", runTest(testDeleteCookie, c))
	t.Run("Location", runTest(testLocation, c))
	t.Run("LocationInView", runTest(testLocationInView, c))
	t.Run("Size", runTest(testSize, c))
	t.Run("ExecuteScript", runTest(testExecuteScript, c))
	t.Run("ExecuteScriptOnElement", runTest(testExecuteScriptOnElement, c))
	t.Run("ExecuteScriptWithNilArgs", runTest(testExecuteScriptWithNilArgs, c))
	t.Run("Screenshot", runTest(testScreenshot, c))
	t.Run("Log", runTest(testLog, c))
	t.Run("IsSelected", runTest(testIsSelected, c))
	t.Run("IsDisplayed", runTest(testIsDisplayed, c))
	t.Run("GetAttributeNotFound", runTest(testGetAttributeNotFound, c))
	t.Run("KeyDownUp", runTest(testKeyDownUp, c))
	t.Run("CSSProperty", runTest(testCSSProperty, c))
	t.Run("Proxy", runTest(testProxy, c))
	t.Run("SwitchFrame", runTest(testSwitchFrame, c))
	t.Run("Wait", runTest(testWait, c))
	t.Run("ActiveElement", runTest(testActiveElement, c))
	t.Run("Extension", runTest(testChromeExtension, c))
}

func testStatus(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	status, err := wd.Status()
	if err != nil {
		t.Fatalf("wd.Status() returned error: %v", err)
	}

	if len(status.OS.Name) == 0 && status.Message == "" {
		t.Fatalf("OS.Name or Message not provided: %+v", status)
	}
}

func testNewSession(t *testing.T, c config) {
	// Bypass NewRemote which itself calls NewSession internally.
	caps := newTestCapabilities(t, c)
	wd := &remoteWD{
		urlPrefix:    DefaultURLPrefix,
		capabilities: caps,
	}
	defer func() {
		if err := wd.Quit(); err != nil {
			t.Errorf("wd.Quit() returned error: %v", err)
		}
	}()

	sid, err := wd.NewSession()

	if err != nil {
		t.Fatalf("error in new session - %s", err)
	}

	if len(sid) == 0 {
		t.Fatal("Empty session id")
	}

	if wd.id != sid {
		t.Fatal("Session id mismatch")
	}

	if wd.SessionID() != sid {
		t.Fatalf("Got session id mismatch %s != %s", sid, wd.SessionID())
	}
}

func testError(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	_, err := wd.FindElement(ByID, "no-such-element")
	if err == nil {
		t.Fatal("wd.FindElement(ByID, 'no-such-element') did not return an error as expected")
	}

	e, ok := err.(*Error)
	if !ok {
		t.Fatalf("wd.FindElement(ByID, 'no-such-element') returned an error that is not an *Error: %v", err)
	}
	if want := "no such element"; e.Err != want {
		t.Errorf("wd.FindElement(ByID, 'no-such-element'); err.Err = %q, want %q", e.Err, want)
	}

	var wantCode, wantLegacyCode int
	switch c.browser {
	case "chrome":
		wantCode = 200
		wantLegacyCode = 7
	}
	if e.HTTPCode != wantCode {
		t.Errorf("wd.FindElement(ByID, 'no-such-element'); err.HTTPCode = %d, want %d", e.HTTPCode, wantCode)
	}
	if e.LegacyCode != wantLegacyCode {
		t.Errorf("wd.FindElement(ByID, 'no-such-element'); err.LegacyCode = %d, want %d", e.LegacyCode, wantLegacyCode)
	}
}

func testCapabilities(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	caps, err := wd.Capabilities()
	if err != nil {
		t.Fatalf("wd.Capabilities() returned error: %v", err)
	}

	if strings.ToLower(caps["browserName"].(string)) != c.browser {
		t.Fatalf("bad browser name - %s (should be %s)", caps["browserName"], c.browser)
	}
}

func testSetAsyncScriptTimeout(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.SetAsyncScriptTimeout(200); err != nil {
		t.Fatal(err)
	}
}

func testSetImplicitWaitTimeout(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.SetImplicitWaitTimeout(200); err != nil {
		t.Fatal(err)
	}
}

func testSetPageLoadTimeout(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.SetPageLoadTimeout(200); err != nil {
		t.Fatal(err)
	}
}

func testWindows(t *testing.T, c config) {
	if c.browser == "chrome" {
		t.Skip("Skipping due to bug: https://bugs.chromium.org/p/chromedriver/issues/detail?id=1918")
	}

	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}

	firstHandle, err := wd.CurrentWindowHandle()
	if err != nil {
		t.Fatal(err)
	}

	if len(firstHandle) == 0 {
		t.Fatal("Empty handle")
	}

	const linkText = "other page"
	link, err := wd.FindElement(ByLinkText, linkText)
	if err != nil {
		t.Fatalf("wd.FindElement(%q, %q) returned error: %v", ByLinkText, linkText, err)
	}
	newWindowModifier := ShiftKey
	if err := wd.SendModifier(newWindowModifier, true); err != nil {
		t.Fatalf("wd.SendModifer(ShiftKey) returned error: %v", err)
	}

	if err := link.Click(); err != nil {
		t.Fatalf("link.Click() returned error: %v", err)
	}

	if err := wd.SendModifier(newWindowModifier, false); err != nil {
		t.Fatalf("wd.SendKeys(ShiftKey) returned error: %v", err)
	}

	// Starting a new window can take a while. Try a few times before failing.
	var handles []string
	tries := 10
	for {
		handles, err = wd.WindowHandles()
		if err != nil {
			t.Fatalf("wd.WindowHandles() returned error: %v", err)
		}
		if len(handles) == 2 {
			break
		}
		tries--
		if tries > 0 {
			time.Sleep(time.Second)
		}
	}
	if len(handles) != 2 {
		t.Fatalf("len(wd.WindowHandles()) = %d, expected 2", len(handles))
	}
	var found bool
	var otherHandle string
	for _, h := range handles {
		if h == firstHandle {
			found = true
		} else {
			otherHandle = h
		}
	}
	if !found {
		t.Fatalf("wd.WindowHandles() returned %v, expected to include %q", handles, firstHandle)
	}

	t.Run("SwitchWindow", func(t *testing.T) {
		if err := wd.SwitchWindow(otherHandle); err != nil {
			t.Fatalf("wd.SwitchWindow(firstHandle) returned error: %v", err)
		}
		if _, err := wd.FindElement(ByLinkText, linkText); err == nil {
			t.Fatalf("wd.FindElement(%q, %q) (after opening a new window) returned nil, expected error", ByLinkText, linkText)
		}
		if err := wd.SwitchWindow(firstHandle); err != nil {
			t.Fatalf("wd.SwitchWindow(firstHandle) returned error: %v", err)
		}
		if _, err := wd.FindElement(ByLinkText, linkText); err != nil {
			t.Fatalf("wd.FindElement(%q, %q) (after switching to the original window) returned error: %v", ByLinkText, linkText, err)
		}
	})

	t.Run("MaximizeWindow", func(t *testing.T) {
		if err := wd.MaximizeWindow(otherHandle); err != nil {
			t.Fatalf("error maximizing window: %s", err)
		}
	})

	t.Run("ResizeWindow", func(t *testing.T) {
		if err := wd.ResizeWindow(otherHandle, 100, 100); err != nil {
			t.Fatalf("error resizing window: %s", err)
		}
	})

	t.Run("CloseWindow", func(t *testing.T) {
		if err := wd.CloseWindow(otherHandle); err != nil {
			t.Fatalf("wd.CloseWindow(otherHandle) returned error: %v", err)
		}
		handles, err := wd.WindowHandles()
		if err != nil {
			t.Fatalf("wd.WindowHandles() returned error: %v", err)
		}
		if len(handles) != 1 {
			t.Fatalf("len(wd.WindowHandles()) = %d, expected 1", len(handles))
		}
	})
}

func testGet(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatal(err)
	}

	newURL, err := wd.CurrentURL()
	if err != nil {
		t.Fatal(err)
	}

	if newURL != serverURL+"/" {
		t.Fatalf("%s != %s", newURL, serverURL)
	}
}

func testNavigation(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	url1 := serverURL
	if err := wd.Get(url1); err != nil {
		t.Fatal(err)
	}

	url2 := serverURL + "/other"
	if err := wd.Get(url2); err != nil {
		t.Fatal(err)
	}

	if err := wd.Back(); err != nil {
		t.Fatal(err)
	}
	url, err := wd.CurrentURL()
	if err != nil {
		t.Fatalf("wd.CurrentURL() returned error: %v", err)
	}
	if url != url1+"/" {
		t.Fatalf("back got me to %s (expected %s/)", url, url1)
	}
	if err := wd.Forward(); err != nil {
		t.Fatal(err)
	}
	url, err = wd.CurrentURL()
	if err != nil {
		t.Fatalf("wd.CurrentURL() returned error: %v", err)
	}
	if url != url2 {
		t.Fatalf("forward got me to %s (expected %s)", url, url2)
	}

	if err := wd.Refresh(); err != nil {
		t.Fatal(err)
	}
	url, err = wd.CurrentURL()
	if err != nil {
		t.Fatalf("wd.CurrentURL() returned error: %v", err)
	}
	if url != url2 {
		t.Fatalf("refresh got me to %s (expected %s)", url, url2)
	}
}

func testTitle(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}

	title, err := wd.Title()
	if err != nil {
		t.Fatal(err)
	}

	expectedTitle := "Go WebDriver Test Suite"
	if title != expectedTitle {
		t.Fatalf("Bad title %s, should be %s", title, expectedTitle)
	}
}

func testPageSource(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatal(err)
	}

	source, err := wd.PageSource()
	if err != nil {
		t.Fatal(err)
	}

	if !strings.Contains(source, "The home page.") {
		t.Fatalf("Bad source\n%s", source)
	}
}

func testFindElement(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}

	for _, tc := range []struct {
		by, query string
	}{
		{ByName, "q"},
		{ByCSSSelector, "input[name=q]"},
		{ByXPATH, "/html/body/form/input[1]"},
		{ByLinkText, "тест"},
	} {
		elem, err := wd.FindElement(tc.by, tc.query)
		if err != nil {
			t.Errorf("wd.FindElement(%q, %q) returned error: %v", tc.by, tc.query, err)
			continue
		}

		we, ok := elem.(*remoteWE)
		if !ok {
			t.Errorf("wd.FindElement(%q, %q) = %T, want a *remoteWE", tc.by, tc.query, elem)
			continue
		}

		if len(we.id) == 0 {
			t.Errorf("wd.FindElement(%q, %q) returned an empty element", tc.by, tc.query)
			continue
		}

		if we.parent != wd {
			t.Errorf("wd.FindElement(%q, %q) returned the wrong parent", tc.by, tc.query)
			continue
		}
	}
}

func testFindElements(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}
	elems, err := wd.FindElements(ByName, "q")
	if err != nil {
		t.Fatal(err)
	}

	if len(elems) != 1 {
		t.Fatalf("Wrong number of elements %d (should be 1)", len(elems))
	}

	we, ok := elems[0].(*remoteWE)
	if !ok {
		t.Fatal("Can't convert to *remoteWE")
	}

	if len(we.id) == 0 {
		t.Fatal("Empty element")
	}

	if we.parent != wd {
		t.Fatal("Bad parent")
	}
}

func testSendKeys(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}
	input, err := wd.FindElement(ByName, "q")
	if err != nil {
		t.Fatal(err)
	}
	const query = "golang"
	if err := input.SendKeys(query + EnterKey); err != nil {
		t.Fatal(err)
	}

	time.Sleep(500 * time.Millisecond)

	source, err := wd.PageSource()
	if err != nil {
		t.Fatalf("wd.PageSource() returned error: %v", err)
	}

	if !strings.Contains(source, searchContents) {
		t.Fatalf("Can't find %q on page after searching for %q", searchContents, query)
	}

	if !strings.Contains(source, query) {
		t.Fatalf("Can't find search query %q in source", query)
	}
}

func testClick(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}
	const searchBoxName = "q"
	input, err := wd.FindElement(ByName, searchBoxName)
	if err != nil {
		t.Fatalf("wd.FindElement(%q, %q) returned error: %v", ByName, searchBoxName, err)
	}
	const query = "golang"
	if err = input.SendKeys(query); err != nil {
		t.Fatalf("input.SendKeys(%q) returned error: %v", query, err)
	}

	const selectTag = "select"
	sel, err := wd.FindElement(ByCSSSelector, selectTag)
	if err != nil {
		t.Fatalf("wd.FindElement(%q, %q) returned error: %v", ByCSSSelector, selectTag, err)
	}
	if err = sel.Click(); err != nil {
		t.Fatalf("input.Click() returned error: %v", err)
	}
	time.Sleep(2 * time.Second)
	option, err := sel.FindElement(ByID, "secondValue")
	if err != nil {
		t.Fatalf("input.FindElement(%q, %q) returned error: %v", ByID, "secondValue", err)
	}
	if err = option.Click(); err != nil {
		t.Fatalf("option.Click() returned error: %v", err)
	}
	if c.browser == "firefox" {
		// Click anywhere else to de-focus the drop-down menu.
		if err = input.Click(); err != nil {
			t.Fatalf("wd.Click() returned error: %v", err)
		}
	}

	const buttonID = "submit"
	button, err := wd.FindElement(ByID, buttonID)
	if err != nil {
		t.Fatalf("wd.FindElement(%q, %q) returned error: %v", ByID, buttonID, err)
	}
	if err := wd.SetPageLoadTimeout(2 * time.Second); err != nil {
		t.Fatalf("wd.SetImplicitWaitTimeout() returned error: %v", err)
	}
	if err = button.Click(); err != nil {
		t.Fatalf("wd.Click() returned error: %v", err)
	}

	source, err := wd.PageSource()
	if err != nil {
		t.Fatalf("wd.PageSource() returned error: %v", err)
	}

	if !strings.Contains(source, searchContents) {
		t.Fatalf("Can't find %q on page after searching for %q", searchContents, query)
	}
}

func testGetCookie(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}
	cookies, err := wd.GetCookies()
	if err != nil {
		t.Fatalf("wd.GetCookies() returned error: %v", err)
	}

	if len(cookies) == 0 {
		t.Fatal("wd.GetCookies() returned no cookies")
	}

	if len(cookies[0].Name) == 0 {
		t.Fatalf("Empty cookie name: %+v", cookies[0])
	}

	got, err := wd.GetCookie(cookies[0].Name)
	if err != nil {
		t.Fatalf("wd.GetCookie(%q) returned error: %v", cookies[0].Name, err)
	}
	if !reflect.DeepEqual(got, cookies[0]) {
		t.Fatalf("wd.GetCookie(%q) = %+v, want %+v", cookies[0].Name, cookies[0], got)
	}
}

func testGetCookies(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}
	cookies, err := wd.GetCookies()
	if err != nil {
		t.Fatal(err)
	}

	if len(cookies) == 0 {
		t.Fatal("No cookies")
	}

	if len(cookies[0].Name) == 0 {
		t.Fatal("Empty cookie")
	}
}

func v(s string) semver.Version {
	return semver.MustParse(s)
}

func testAddCookie(t *testing.T, c config) {
	if c.browser == "chrome" {
		t.Skip("Skipping due to bug: https://bugs.chromium.org/p/chromedriver/issues/detail?id=1949")
	}

	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}
	want := &Cookie{
		Name:   "the nameless cookie",
		Value:  "I have nothing",
		Expiry: math.MaxUint32,
		Domain: "127.0.0.1", // Unlike real browsers, htmlunit requires this to be set.
	}
	if err := wd.AddCookie(want); err != nil {
		t.Fatal(err)
	}

	// These fields are added implicitly by the browser.
	want.Domain = "127.0.0.1"
	want.Path = "/"

	cookies, err := wd.GetCookies()
	if err != nil {
		t.Fatal(err)
	}
	var got *Cookie
	for _, cookie := range cookies {
		if cookie.Name == want.Name {
			got = &cookie
			break
		}
	}
	if got == nil {
		t.Fatalf("wd.GetCookies() = %v, missing cookie %q", cookies, want.Name)
	}

	if diff := cmp.Diff(want, got); diff != "" {
		t.Fatalf("wd.GetCookies() returned diff (-want/+got):\n%s", diff)
	}
}

func testDeleteCookie(t *testing.T, c config) {
	if c.browser == "chrome" {
		t.Skip("Skipping due to bug: https://bugs.chromium.org/p/chromedriver/issues/detail?id=1950")
	}

	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}
	cookies, err := wd.GetCookies()
	if err != nil {
		t.Fatal(err)
	}
	if len(cookies) == 0 {
		t.Fatal("No cookies")
	}
	if err := wd.DeleteCookie(cookies[0].Name); err != nil {
		t.Fatal(err)
	}
	newCookies, err := wd.GetCookies()
	if err != nil {
		t.Fatal(err)
	}
	if len(newCookies) != len(cookies)-1 {
		t.Fatal("Cookie not deleted")
	}

	for _, c := range newCookies {
		if c.Name == cookies[0].Name {
			t.Fatal("Deleted cookie found")
		}
	}
}

func testLocation(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}
	button, err := wd.FindElement(ByID, "submit")
	if err != nil {
		t.Fatal(err)
	}

	loc, err := button.Location()
	if err != nil {
		t.Fatal(err)
	}

	if loc.X == 0 || loc.Y == 0 {
		t.Fatalf("Bad location: %v\n", loc)
	}
}

func testLocationInView(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}
	button, err := wd.FindElement(ByID, "submit")
	if err != nil {
		t.Fatal(err)
	}

	loc, err := button.LocationInView()
	if err != nil {
		t.Fatal(err)
	}

	if loc.X == 0 || loc.Y == 0 {
		t.Fatalf("Bad location: %v\n", loc)
	}
}

func testSize(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}
	button, err := wd.FindElement(ByID, "submit")
	if err != nil {
		t.Fatal(err)
	}

	size, err := button.Size()
	if err != nil {
		t.Fatal(err)
	}

	if size.Width == 0 || size.Height == 0 {
		t.Fatalf("Bad size: %v\n", size)
	}
}

func testExecuteScript(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}
	script := "return arguments[0] + arguments[1]"
	args := []interface{}{1, 2}
	reply, err := wd.ExecuteScript(script, args)
	if err != nil {
		t.Fatal(err)
	}

	result, ok := reply.(float64)
	if !ok {
		t.Fatal("Not an int reply")
	}

	if result != 3 {
		t.Fatalf("Bad result %d (expected 3)", int(result))
	}
}

func testExecuteScriptWithNilArgs(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}

	script := "return document.readyState"
	if _, err := wd.ExecuteScript(script, nil); err != nil {
		t.Fatal(err)
	}
}

func testExecuteScriptOnElement(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}

	input, err := wd.FindElement(ByName, "q")
	if err != nil {
		t.Fatal(err)
	}

	const query = "golang"
	if err := input.SendKeys(query); err != nil {
		t.Fatal(err)
	}

	we, err := wd.FindElement(ByXPATH, "//input[@type='submit']")
	if err != nil {
		t.Fatal(err)
	}

	script := "arguments[0].click()"
	args := []interface{}{we}

	if _, err = wd.ExecuteScript(script, args); err != nil {
		t.Fatal(err)
	}

	time.Sleep(500 * time.Millisecond)

	source, err := wd.PageSource()
	if err != nil {
		t.Fatal(err)
	}

	if !strings.Contains(source, searchContents) {
		t.Fatalf("Can't find %q on page after searching for %q", searchContents, query)
	}
}

func testScreenshot(t *testing.T, c config) {
	if c.browser == "htmlunit" {
		t.Skip("Skipping on htmlunit")
	}
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}
	data, err := wd.Screenshot()
	if err != nil {
		t.Fatal(err)
	}

	if len(data) == 0 {
		t.Fatal("Empty reply")
	}
}

func testLog(t *testing.T, c config) {
	caps := newTestCapabilities(t, c)
	caps.SetLogLevel(log.Browser, log.All)
	if c.browser == "chrome" {
		caps.SetLogLevel(log.Performance, log.All)
	}
	wd := &remoteWD{
		urlPrefix:    DefaultURLPrefix,
		capabilities: caps,
	}
	if _, err := wd.NewSession(); err != nil {
		t.Fatalf("wd.NewSession() returned error: %v", err)
	}
	defer quitRemote(t, wd)

	url := serverURL + "/log"
	if err := wd.Get(url); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", url, err)
	}
	logs, err := wd.Log(log.Browser)
	if err != nil {
		t.Fatalf("wd.Log(Browser) returned error: %v", err)
	}
	if len(logs) == 0 {
		t.Fatalf("empty reply from wd.Log(Browser)")
	} else {
		for _, l := range logs {
			if len(l.Level) == 0 || l.Timestamp.Unix() == 0 || len(l.Message) == 0 {
				t.Errorf("wd.Log(Browser) returned malformed message: %+v", l)
			}
		}
	}

	if c.browser == "chrome" {
		logs, err = wd.Log(log.Performance)
		if err != nil {
			t.Fatalf("wd.Log(Performance) returned error: %v", err)
		}
		if len(logs) == 0 {
			t.Fatal("empty reply from wd.Log(Performance)")
		} else {
			for _, l := range logs {
				if len(l.Level) == 0 || l.Timestamp.Unix() == 0 || len(l.Message) == 0 {
					t.Errorf("wd.Log(Browser) returned malformed message: %+v", l)
				}
			}
		}
	}
}

func testIsSelected(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}
	elem, err := wd.FindElement(ByID, "chuk")
	if err != nil {
		t.Fatal("Can't find element")
	}
	selected, err := elem.IsSelected()
	if err != nil {
		t.Fatal("Can't get selection")
	}

	if selected {
		t.Fatal("Already selected")
	}

	if err := elem.Click(); err != nil {
		t.Fatal("Can't click")
	}

	selected, err = elem.IsSelected()
	if err != nil {
		t.Fatal("Can't get selection")
	}

	if !selected {
		t.Fatal("Not selected")
	}
}

func testIsDisplayed(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}
	elem, err := wd.FindElement(ByID, "chuk")
	if err != nil {
		t.Fatal("Can't find element")
	}
	displayed, err := elem.IsDisplayed()
	if err != nil {
		t.Fatal("Can't check for displayed")
	}

	if !displayed {
		t.Fatal("Not displayed")
	}
}

func testGetAttributeNotFound(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}
	elem, err := wd.FindElement(ByID, "chuk")
	if err != nil {
		t.Fatal("Can't find element")
	}

	if _, err = elem.GetAttribute("no-such-attribute"); err == nil {
		t.Fatal("Got non existing attribute")
	}
}

func testActiveElement(t *testing.T, c config) {
	if c.browser == "htmlunit" {
		// TODO(minusnine): figure out why ActiveElement doesn't work in HTMLUnit.
		t.Skip("ActiveElement does not work in HTMLUnit")
	}
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}

	e, err := wd.ActiveElement()
	if err != nil {
		t.Fatalf("wd.ActiveElement() returned error: %v", err)
	}
	name, err := e.GetAttribute("name")
	if err != nil {
		t.Fatalf("wd.ActiveElement().GetAttribute() returned error: %v", err)
	}
	if name != "q" {
		t.Fatalf("wd.ActiveElement().GetAttribute() returned element wht name = %q, expected name = 'q'", name)
	}
}

func testKeyDownUp(t *testing.T, c config) {
	t.SkipNow()
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}

	e, err := wd.FindElement(ByLinkText, "other page")
	if err != nil {
		t.Fatalf("error finding other page link: %v", err)
	}

	if err := wd.KeyDown(ControlKey); err != nil {
		t.Errorf("error pressing control key down: %v", err)
	}

	if err := e.Click(); err != nil {
		t.Fatalf("error clicking the other page link: %v", err)
	}
	if err := wd.KeyUp(ControlKey); err != nil {
		t.Fatalf("error releasing control key: %v", err)
	}
}

func testCSSProperty(t *testing.T, c config) {
	if c.browser == "htmlunit" {
		t.Skip("Skipping on htmlunit")
	}
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}

	e, err := wd.FindElement(ByLinkText, "other page")
	if err != nil {
		t.Fatalf("error finding other page link: %v", err)
	}

	color, err := e.CSSProperty("color")
	if err != nil {
		t.Fatalf(`e.CSSProperty("color") returned error: %v`, err)
	}

	// Later versions of Firefox and HTMLUnit return the "rgb" version.
	wantColors := []string{"rgba(0, 0, 238, 1)", "rgb(0, 0, 238)"}
	for _, wantColor := range wantColors {
		if color == wantColor {
			return
		}
	}
	t.Fatalf(`e.CSSProperty("color") = %q, want one of %q`, color, wantColors)
}

func testProxy(t *testing.T, c config) {
	const pageContents = "You are viewing a proxied page"
	s := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		fmt.Fprintf(w, pageContents)
	}))
	defer s.Close()

	u, err := url.Parse(s.URL)
	if err != nil {
		t.Fatalf("url.Parse(%q) returned error: %v", s.URL, err)
	}

	caps := newTestCapabilities(t, c)
	proxy := Proxy{Type: Manual}
	switch c.browser {
	case "chrome":
		proxy.HTTP = u.Host
	}
	caps.AddProxy(proxy)

	wd := &remoteWD{
		urlPrefix:    DefaultURLPrefix,
		capabilities: caps,
	}
	defer func() {
		if err := wd.Quit(); err != nil {
			t.Fatalf("wd.Quit() returned error: %v", err)
		}
	}()
	if _, err := wd.NewSession(); err != nil {
		t.Fatalf("wd.NewSession() returned error: %v", err)
	}

	if err := wd.Get(serverURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}
	source, err := wd.PageSource()
	if err != nil {
		t.Fatalf("wd.PageSource() returned error: %v", err)
	}

	if !strings.Contains(source, pageContents) {
		if strings.Contains(source, "Go WebDriver Test Suite") {
			t.Fatal("Got non-proxied page.")
		}
		t.Fatalf("Got page: %s\n\nExpected: %q", source, pageContents)
	}
}

func testSwitchFrame(t *testing.T, c config) {
	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	if err := wd.Get(serverURL + "/frame"); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", serverURL, err)
	}

	const (
		iframeID      = "iframeID"
		insideFrameID = "chuk"
		outsideDivID  = "outsideOfFrame"
	)

	// Test with the ID of the iframe.
	if err := wd.SwitchFrame(iframeID); err != nil {
		t.Fatalf("wd.SwitchToFrame(%q) returned error: %v", iframeID, err)
	}
	if _, err := wd.FindElement(ByID, insideFrameID); err != nil {
		t.Fatalf("After switching frames using an ID, wd.FindElement(ByID, %q) returned error: %v", insideFrameID, err)
	}
	if _, err := wd.FindElement(ByID, outsideDivID); err == nil {
		t.Fatalf("After switching frames using an ID, wd.FindElement(ByID, %q) returned nil, expected an error", outsideDivID)
	}

	// Test with nil, to return to the top-level context.
	if err := wd.SwitchFrame(nil); err != nil {
		t.Fatalf("wd.SwitchToFrame(nil) returned error: %v", err)
	}
	if _, err := wd.FindElement(ByID, outsideDivID); err != nil {
		t.Fatalf("After switching frames using nil, wd.FindElement(ByID, %q) returned error: %v", outsideDivID, err)
	}

	// Test with a WebElement.
	iframe, err := wd.FindElement(ByID, iframeID)
	if err != nil {
		t.Fatalf("error finding iframe: %v", err)
	}
	if err := wd.SwitchFrame(iframe); err != nil {
		t.Fatalf("wd.SwitchToFrame(nil) returned error: %v", err)
	}
	if _, err := wd.FindElement(ByID, insideFrameID); err != nil {
		t.Fatalf("After switching frames using a WebElement, wd.FindElement(ByID, %q) returned error: %v", insideFrameID, err)
	}
	if _, err := wd.FindElement(ByID, outsideDivID); err == nil {
		t.Fatalf("After switching frames using a WebElement, wd.FindElement(ByID, %q) returned nil, expected an error", outsideDivID)
	}

	// Test with the empty string, to return to the top-level context.
	if err := wd.SwitchFrame(""); err != nil {
		t.Fatalf(`wd.SwitchToFrame("") returned error: %v`, err)
	}
	if _, err := wd.FindElement(ByID, outsideDivID); err != nil {
		t.Fatalf(`After switching frames using "", wd.FindElement(ByID, %q) returned error: %v`, outsideDivID, err)
	}
}

func testWait(t *testing.T, c config) {
	const newTitle = "Title changed."
	titleChangeCondition := func(wd WebDriver) (bool, error) {
		title, err := wd.Title()
		if err != nil {
			return false, err
		}

		return title == newTitle, nil
	}

	wd := newRemote(t, c)
	defer quitRemote(t, wd)

	titleURL := serverURL + "/title"

	if err := wd.Get(titleURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", titleURL, err)
	}

	// Testing when the title should change.
	if err := wd.Wait(titleChangeCondition); err != nil {
		t.Fatalf("wd.Wait(titleChangeCondition) returned error: %v", err)
	}

	// Reloading the page.
	if err := wd.Get(titleURL); err != nil {
		t.Fatalf("wd.Get(%q) returned error: %v", titleURL, err)
	}

	// Testing when the Wait() should error the timeout..
	if err := wd.WaitWithTimeout(titleChangeCondition, 500*time.Millisecond); err == nil {
		t.Fatalf("wd.Wait(titleChangeCondition) should returned error, but it didn't.")
	}
}

var homePage = `
<html>
<head>
	<title>Go WebDriver Test Suite</title>
</head>
<body>
	The home page. <br />
	<form action="/search">
		<input name="q" autofocus />
		<input type="submit" id="submit" /> <br />
		<input id="chuk" type="checkbox" /> A checkbox.
		<select name="s">
			<option value="first_value">First Value</option>
			<option id="secondValue" value="second_value">Second Value</option>
		</select>
	</form>
	Link to the <a href="/other">other page</a>.

	<a href="/log">тест</a>
</body>
</html>
`

var otherPage = `
<html>
<head>
	<title>Go WebDriver Test Suite - Other Page</title>
</head>
<body>
	The other page.
</body>
</html>
`

const searchContents = "The Go Proramming Language"

var searchPage = `
<html>
<head>
	<title>Go WebDriver Test Suite - Search Page</title>
</head>
<body>
	You searched for "%s". I'll pretend I've found:
	<p>
	"` + searchContents + `"
	</p>
	Select value is: %s
</body>
</html>
`

var logPage = `
<html>
<head>
	<title>Go WebDriver Test Suite - Log Page</title>
	<script>
		console.log("console log");
		throw "exception log";
	</script>
</head>
<body>
	Log test page.
</body>
</html>
`

var framePage = `
<html>
<head>
	<title>Go WebDriver Test Suite - Frame Page</title>
</head>
<body>
	This page contains a frame.

	<iframe id="iframeID" name="iframeName" src="/"></iframe>
	<div id="outsideOfFrame"></div>
</body>
</html>
`

var titleChangePage = `
<html>
<head>
	<title>Go WebDriver Test Suite - Title Change Page</title>
</head>
<body>
	This page will change a title after 1 second.

	<script>
		setTimeout(function() { document.title = 'Title changed.' }, 1000);
	</script>
</body>
</html>
`

func handler(w http.ResponseWriter, r *http.Request) {
	path := r.URL.Path
	page, ok := map[string]string{
		"/":       homePage,
		"/other":  otherPage,
		"/search": searchPage,
		"/log":    logPage,
		"/frame":  framePage,
		"/title":  titleChangePage,
	}[path]
	if !ok {
		http.NotFound(w, r)
		return
	}

	if path == "/search" {
		r.ParseForm()
		page = fmt.Sprintf(page, r.Form["q"][0], r.Form["s"][0])
	}
	// Some cookies for the tests
	for i := 0; i < 3; i++ {
		http.SetCookie(w, &http.Cookie{
			Name:  fmt.Sprintf("cookie-%d", i),
			Value: fmt.Sprintf("value-%d", i),
		})
	}
	fmt.Fprintf(w, page)
}