Ruby Feature Request: execute_script/execute_async_script accept hash/objects as arguments

[jasonkarns]

The execute_script and execute_async_script methods already accept most primitives (string, integer, array, nil). It would fully complete the set if we could pass hashes directly to selenium as arguments. I'm assuming they would be serialized to JSON by the selenium bridge, and then parsed on the JS side before being passed into the script as arguments.

With Ruby's built-in support for JSON serialization, it would be even better if selenium just serialized any unknown object to JSON (duck-typing on #to_json) and then parsing on the JS side.

hash example:

driver.execute_async_script("foo.apply(null, arguments)", {a: 1})

or via duck-typing

class Foo
  def to_json
    ...
  end
end

driver.execute_async_script("foo.apply(null, arguments)", Foo.new)

[titusfortner]

Because JSON does not support symbols when we pass it over the JSON Wire Protocol, there is no way to know if the keys are symbols or strings or a combination of both.
So, the Selenium project is not going to make assumptions or guesses in order to support this.

For your needs, though:

If your hash has keys with only strings, you can just use JSON like:

hash = {'a' => 1}

JSON.parse(driver.execute_script("return arguments[0];", hash.to_json)).should == hash


If your hashes has only symbols as keys, you can implement something like rails #symbolize_keys:

hash = {a: 1}

JSON.parse(driver.execute_script("return arguments[0];", hash.to_json)).symbolize_keys.should == hash


If your hash includes keys with both symbols and strings, there is no easy solution.

[jasonkarns]

I don't understand why the selenium project would care about the keys at all. Any object that supports the #to_json protocol should be serializable as json. The fact that Hashes already have a defined mechanism for serializing to JSON means that selenium would neither be assuming nor guessing anything at all. Selenium should simply invoke #to_json and JSON.parse as necessary. Any other modifications are clearly outside the purview of selenium. But the JSON library being part of ruby's stdlib makes it pretty clear how the serialization/deserialization should be handled.

Even with your own example, serializing either symbols or string keys would be handled the exact same way by selenium, so it wouldn't make any difference in the slightest.

[titusfortner]

We actually went through this request as part of the Selenium Conference workshop this afternoon.

Because of JSON's limitations with interpreting symbols as strings in the deserialization, there is no way for Selenium to implement a solution that works for all 3 conditions of a hash with symbols as keys, a hash with strings as keys, and a mix of both. The way to do this is how I posted above, and passing it into #execute_script as a JSON string and then choosing how to deserialize the result based on your knowledge of what kind of hash you have.

That being said, if you can implement a solution that works for hashes that have strings as keys, symbols as keys and a combination of both, please write the specs and create a pull request...

[p0deje]

I don't understand, why not just perform serialization by client code:

driver.execute_async_script("foo.apply(null, arguments[0])", {a: 1}.to_json)

[jasonkarns]

Ruby (via StdLib's JSON library) already handles symbols and strings as keys. Selenium literally has to do nothing except invoke .to_json on the hash.

And deserialization is a moot point as well. JavaScript only has strings as keys, so parsing from a JSON string will always and only ever result in strings as keys. On the deserialization side, selenium only has to invoke JSON.parse and return back the resulting hash.

I'm completely unfamiliar with the selenium codebase. Could @titusfortner provide a pointer as to where to start a PR with this?

[titusfortner]

But if the hash has symbols as keys the resulting hash is different from the input hash, which is the point of this feature request. It returns the resulting hash with keys as strings. And that already works:
driver.execute_script("return arguments[0]", {“a” => 1}) # ==> {"a"=>1}

If you are using symbols as keys it doesn't work:
driver.execute_script("return arguments[0]", {:a => 1) # ==> {"a"=>1}

The code is here:

selenium/rb/lib/selenium/webdriver/remote/bridge.rb

Line 357 in d552c47

def executeScript(script, *args)

The existing specs for returns with execute_script are here:

selenium/rb/spec/integration/selenium/webdriver/driver_spec.rb

Line 222 in 36d7f5c

it "should return booleans" do

[jasonkarns]

The point of this feature request is to allow sending hashes (or any json-serializeable object) as an argument; and to allow returning any js-object back to ruby as a hash. I've never meant to suggest that one should be able to round-trip a hash. I think we can all agree that converting ruby hashes to JSON is lossy. So I don't see when anyone would ever expect to send a hash as an argument, and return that same object back.

However, you stated that is already supports hashes, and I was under the impression this did not work. So I need to revisit my work to see why it failed when I attempted this very thing.

If this works:

driver.execute_script("return arguments[0].a === 1", {"a" => 1}) # ==> true

and this works:

driver.execute_script("return {a:1}") # ==> {"a"=>1}

then that's exactly (or darn close) to what I want.

[twalpole]

@jasonkarns Yes, passing hashes as args is already supported - All the arguments passed end up becoming the :args key of command_hash which is then converted to json here -

selenium/rb/lib/selenium/webdriver/remote/http/common.rb

Line 46 in d552c47

payload = WebDriver.json_dump(command_hash)