This makes us not rely on try…catch logic to export MarionetteObj
properties and functions on the sandbox.
The patch also cleans up a few more details on
createExecuteContentSandbox.
r=dburns
When native JavaScript errors are thrown because of internal errors,
this will include the Error prototype's name in the message.
This is useful since the WebDriver protocol doesn't allow for arbitrary
JS error marshaling.
r=chmanchester
When the `frame' argument is None, which it is by default, we were setting
the `id' field of the packet regardless. This only works because of a
faulty == operator comparison in the server.
r=jgriffin
getElementSize and getElementLocation are getting removed from the
Marionette server (bug 1153911) and this is in preparation for that.
Fortunately getElementRect is backwards compatible and we can extract
the properties we need from that dictionary.
r=chmanchester
Brings Marionette closer to compliance with the W3C WebDriver standard
which prescribes that errors should be identified by a string rather
than a magic number.
r=dburns
Brings Marionette closer to compliance with the W3C WebDriver standard
which prescribes that errors should be identified by a string rather
than a magic number.
r=dburns
Adds `invalid selector' and `invalid session id' errors to the server,
and aligns the exceptions in the Python client with those in the server.
Some of the exceptions are not in use yet and consequently do not carry
a `code` property. This is fine because it makes us future-proof when
the server starts using them.
r=dburns
Takes advantage of the new dispatching technique introduced in bug
1107706 on the content side.
The patch introduces the framework to write simpler command handlers
in content space, but does not convert all commands in listener.js to
use this. This can be done gradually, as both techniques are still
compatible.
r=dburns
Adds `invalid selector' and `invalid session id' errors to the server,
and aligns the exceptions in the Python client with those in the server.
Some of the exceptions are not in use yet and consequently do not carry
a `code` property. This is fine because it makes us future-proof when
the server starts using them.
r=dburns
Adds `invalid selector' and `invalid session id' errors to the server,
and aligns the exceptions in the Python client with those in the server.
Some of the exceptions are not in use yet and consequently do not carry
a `code` property. This is fine because it makes us future-proof when
the server starts using them.
r=dburns
Takes advantage of the new dispatching technique introduced in bug
1107706 on the content side.
The patch introduces the framework to write simpler command handlers
in content space, but does not convert all commands in listener.js to
use this. This can be done gradually, as both techniques are still
compatible.
r=dburns
Takes advantage of the new dispatching technique introduced in bug
1107706 on the content side.
The patch introduces the framework to write simpler command handlers
in content space, but does not convert all commands in listener.js to
use this. This can be done gradually, as both techniques are still
compatible.
r=dburns
Adds `invalid selector' and `invalid session id' errors to the server,
and aligns the exceptions in the Python client with those in the server.
Some of the exceptions are not in use yet and consequently do not carry
a `code` property. This is fine because it makes us future-proof when
the server starts using them.
r=dburns
Takes advantage of the new dispatching technique introduced in bug
1107706 on the content side.
The patch introduces the framework to write simpler command handlers
in content space, but does not convert all commands in listener.js to
use this. This can be done gradually, as both techniques are still
compatible.
r=dburns
Cleans up navigation tests to use assertion routines that give us better
feedback if tests were to fail.
Also adds a test for setting location through executeScript, and a test
for getCurrentUrl returning the URL of the top-level browsing context
when inside an iframe.
r=dburns
Adds support for W3C WebDriver compatible file uploads, where additional
calls to sendKeys on <input type=file multiple> will append files,
rather than reset the field.
r=dburns
Adds string based statuses as defined by the W3C WebDriver protocol
to the Marionette Python client. Importantly, it does not remove the
ability to look up errors by their Selenium protocol number for backwards
compatibility reasons.
r=dburns
Adds support for W3C WebDriver compatible file uploads, where additional
calls to sendKeys on <input type=file multiple> will append files,
rather than reset the field.
r=dburns
Adds support for W3C WebDriver compatible file uploads, where additional
calls to sendKeys on <input type=file multiple> will append files,
rather than reset the field.
r=dburns
Rather than attempting to bind non-functions and catching the exception this
explicitly checks if it is a function. This helps reduce memory consumption
needed for the exception stack traces. Realistically that will go away when GC
is run, but it throws off memory measurments prior to that.
Add a `tags` attribute to a test or DEFAULT section in a manifest:
[test_foo]
tags = foo
Then run all tests with a given tag by passing in `--tag foo` to a supported test harness. So far mochitest, xpcshell and marionette are supported.
Add a `tags` attribute to a test or DEFAULT section in a manifest:
[test_foo]
tags = foo
Then run all tests with a given tag by passing in `--tag foo` to a supported test harness. So far mochitest, xpcshell and marionette are supported.
Emulator callbacks are now created dynamically upon request, and uses
a nicer data structure in chrome context. Each emulator callback is
encapsulated in EmulatorCallback, and stored on Emulator.
Emulator is stored on Dispatcher (as opposed to in marionette-server.js)
which bypasses some of the problems with circumventing the Marionette
protocol in GeckoDriver because of CommandProcessor.
Emulator callbacks to the client should be considered transparent, hence
they do not use the ListenerProxy. They are explicitly meant _not_
to be blocking.
The Marionette server handles requests separately with a global sense
of state which makes it hard to introduce generalised behaviour to many
commands. This effectively slows down protocol implementation because
each command request individually needs to do heavy lifting.
This patch introduces a series of abstractions that separates out the
WebDriver implementation to a new class, GeckoDriver. It also features
a new interface to mediate messages between the chrome- and content
processes.
This allows the code living in the chrome context to make direct calls
on the listener through a promise-based API:
let listener = new ListenerProxy(mm, sendCallback);
let res = yield listener.functionOnListener("arg1", "arg2");
The MarionetteServer class that used to live in marionette-server.js
has now been moved to server.js, while the WebDriver implementation
has moved to driver.js. By introducing more stringent separation,
MarionetteServer now properly encapsulates the server process allowing
us to unit tests for it in the future.
The patch is a refactor in the truest sense, in the meaning that no
input or output should have changed.
The dispatcher is analogous to the client socket connection, and handles
receiving packets and closing connections.
It also encompasses some of the functionality needed to establish the
devtools and Marionette connection, that previously used to live in
MarionetteServerConnection in marionette-server.js.
For each connection, recognised commands will be forwarded to the command
processor (command.js) unless a handler is defined in Dispatcher.requests.
The command processor receives messages, processes them, and wraps the
execution of the command implementations. This allows commands to throw
errors without worrying about the side effects.
This patch also introduces a Response object which correspondingly wraps
the replies to the client. This shifts the responsibility of managing
the correctness of the packets from the commands to this.
Adds the ability to throw error objects for WebDriver statuses, and an
error module with convenience functions for manipulation of these and
for handling other error related operations.
