Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
Selenium::Firefox(3)  User Contributed Perl Documentation Selenium::Firefox(3)

NAME
       Selenium::Firefox - Use FirefoxDriver without a Selenium	server

VERSION
       version 1.37

SYNOPSIS
	   # These two are the same, and will only work	with Firefox 48+
	   my $driver =	Selenium::Firefox->new;
	   $driver = Selenium::Firefox->new( marionette_enabled	=> 1 );

	   #Do stuff...

	   $driver->shutdown_binary;

	   # For Firefox 47 and	older, disable marionette:
	   $driver = Selenium::Firefox->new( marionette_enabled	=> 0 );
	   $driver->shutdown_binary;

DESCRIPTION
       Breaking	Changes: There are breaking changes in v1.0+ of	this module if
       you're using it to start	FF47; please see "BREAKING CHANGES". You can
       ignore this if you're using v1.0+ of this module	to start FF48.

       This class allows you to	use the	FirefoxDriver without needing the JRE
       or a selenium server running. Unlike starting up	an instance of
       S::R::D,	do not pass the	"remote_server_addr" and "port"	arguments, and
       we will search for the Firefox executable in your $PATH.	We'll try to
       start the binary, connect to it,	and shut it down at the	end of the
       test.

       If the Firefox application is not found in the expected places, we'll
       fall back to the	default	Selenium::Remote::Driver behavior of assuming
       defaults	of 127.0.0.1:4444 after	waiting	a few seconds.

       If you specify a	remote server address, or a port, our assumption is
       that you	are doing standard S::R::D behavior and	we will	not attempt
       any binary startup.

       If you're curious whether your Selenium::Firefox	instance is using a
       separate	Firefox	binary,	or through the selenium	server,	you can	check
       the value of the	"binary_mode" attr after instantiation.

ATTRIBUTES
   binary
       Optional: specify the path to the "geckodriver" binary -	this is	NOT
       the path	to the Firefox browser.	To specify the path to your Firefox
       browser binary, see the "firefox_binary"	attr.

       For Firefox 48 and greater, this	is the path to your "geckodriver"
       executable. If you don't	specify	anything, we'll	search for
       "geckodriver" in	your $PATH.

       For Firefox 47 and older, this attribute	does not apply,	because	the
       older FF	browsers do not	use the	separate driver	binary startup.

   binary_port
       Optional: specify the port that we should bind to. If you don't specify
       anything, we'll default to the driver's default port. Since there's no
       a priori	guarantee that this will be an open port, this is _not_
       necessarily the port that we end	up using - if the port here is already
       bound, we'll search above it until we find an open one.

       See "port" in Selenium::CanStartBinary for more details,	and "port" in
       Selenium::Remote::Driver	after instantiation to see what	the actual
       port turned out to be.

   firefox_profile
       Optional: Pass in an instance of	Selenium::Firefox::Profile pre-
       configured as you please. The preferences you specify will be merged
       with the	ones necessary for setting up webdriver, and as	a result some
       options may be overwritten or ignored.

	   my $profile = Selenium::Firefox::Profile->new;
	   my $firefox = Selenium::Firefox->new(
	       firefox_profile => $profile
	   );

   marionette_binary_port
       Optional: specify the port that we should bind marionette to. If	you
       don't specify anything, we'll default to	the marionette's default port.
       Since there's no	a priori guarantee that	this will be an	open port,
       this is _not_ necessarily the port that we end up using - if the	port
       here is already bound, we'll search above it until we find an open one.

	   Selenium::Firefox->new(
	       marionette_enabled     => 1,
	       marionette_binary_port => 12345,
	   );

       Attempting to specify a "marionette_binary_port"	in conjunction with
       setting "marionette_enabled" does not make sense	and will most likely
       not do anything useful.

   marionette_enabled
       Optional: specify whether marionette <https://developer.mozilla.org/en-
       US/docs/Mozilla/QA/Marionette> should be	enabled	or not.	By default,
       marionette is enabled, which assumes you	are running with Firefox 48 or
       newer. To use this module to start Firefox 47 or	older, you must	pass
       "marionette_enabled => 0".

	   my $ff48 = Selenium::Firefox->new( marionette_enabled => 1 ); # defaults to 1
	   my $ff47 = Selenium::Firefox->new( marionette_enabled => 0 );

   firefox_binary
       Optional: specify the path to the Firefox browser executable. Although
       we will attempt to locate this in your $PATH, you may specify it
       explicitly here.	Note that path here must point to a file that exists
       and is executable, or we	will croak.

       For Firefox 48 and newer, this will be passed to	"geckodriver" such
       that it will attempt to start up	the Firefox at the specified path. If
       you do not specify anything, we will look for the Firefox browser on
       our own in the normal places, but if the	browser	cannot be found, we'll
       probably	"die" during instantiation.

       For Firefox 47 and older, this browser path should be the file that we
       directly	start up.

   custom_args
       Optional: specify any additional	command	line arguments you'd like
       invoked during the binary startup. See "custom_args" in
       Selenium::CanStartBinary	for more information.

       For Firefox 48 and newer, these arguments will be passed	to geckodriver
       during start up.

       For Firefox 47 and older, these arguments will be passed	to the Firefox
       browser during start up.

   startup_timeout
       Optional: specify how long to wait for the binary to start itself and
       listen on its port. The default duration	is arbitrarily 10 seconds. It
       accepts an integer number of seconds to wait: the following will	wait
       up to 20	seconds:

	   Selenium::Firefox->new( startup_timeout => 20 );

       See "startup_timeout" in	Selenium::CanStartBinary for more information.

   fixed_ports
       Optional: Throw instead of searching for	additional ports; see
       "fixed_ports" in	Selenium::CanStartBinary for more info.

METHODS
   shutdown_binary
       Call this method	instead	of "quit" in Selenium::Remote::Driver to
       ensure that the binary executable is also closed, instead of simply
       closing the browser itself. If the browser is still around, it will
       call "quit" for you. After that,	it will	try to shutdown	the browser
       binary by making	a GET to /shutdown and on Windows, it will attempt to
       do a "taskkill" on the binary CMD window.

	   $self->shutdown_binary;

       It doesn't take any arguments, and it doesn't return anything.

       We do our best to call this when	the $driver option goes	out of scope,
       but if that happens during global destruction, there's nothing we can
       do.

BREAKING CHANGES
       In version v1.0+	and newer, the default behavior	is to enable
       marionette & geckodriver	mode. This means that an existing script that
       works with v0.2701 and Firefox v47 will require modification if you
       upgrade Selenium::Firefox to v1.0+. That	is,

	   # v0.2701 of	Selenium::Firefox works	with FF47 like such; this will not
	   # work for FF47 after upgrade:
	   my $fx47_old	= Selenium::Firefox->new;
	   ...
	   $fx47_old->shutdown_binary;

	   # v1.0 of Selenium::Firefox works with FF47 like this
	   my $fx47_new	= Selenium::Firefox->new( marionette_enabled =>	0);
	   ...
	   $fx47_new->shutdown_binary;

       We default to assuming FF48 and geckodriver mode	because	all
       forthcoming versions of the Firefox browser will	be using the
       geckodriver architecture, and also because that's consistent with the
       rest of the driver setups, which	all have separate driver binaries
       apart from the browser itself. This means that:

	   # v0.2701 of	Selenium::Firefox cannot start up FF48 at all

	   # v1.0+ of Selenium::Firefox	works with FF48+ like this:
	   my $fx48 = Selenium::Firefox->new;

       As with the other drivers, Selenium::Firefox in marionette/geckodriver
       mode requires a "geckodriver" executable	in the path or provided	during
       startup,	and it will also attempt to find the path to your Firefox
       browser.	During testing,	we found that it was necessary for us to pass
       the Firefox browser file	path to	the "geckodriver" executable during
       start up, or else "geckodriver" would have trouble finding Firefox.

   get_context
	Description:
	   Firefox extension: Retrieve browser's scope (chrome or content).
	   Chrome is a privileged scope	where you can access things like the
	   Firefox UI itself. Content scope is where things like webpages live.

	Output:
	   STRING - context {CHROME|CONTENT}

	Usage:
	   print $firefox_driver->get_context();

   set_context
	Description:
	   Firefox extension: Set browser's scope (chrome or content).
	   Chrome is a privileged scope	where you can access things like the
	   Firefox UI itself. Content scope is where things like webpages live.

	Input:
	   Required:
	       <STRING>	- context {CHROME|CONTENT}

	Usage:
	   $firefox_driver->set_context( $context );

	Output:
	   BOOLEAN - success or	failure

SEE ALSO
       Please see those	modules/websites for more information related to this
       module.

       o   Selenium::Remote::Driver

BUGS
       Please report any bugs or feature requests on the bugtracker website
       <https://github.com/teodesian/Selenium-Remote-Driver/issues>

       When submitting a bug or	request, please	include	a test-file or a patch
       to an existing test-file	that illustrates the bug or desired feature.

AUTHORS
       Current Maintainers:

       o   Daniel Gempesaw <gempesaw@gmail.com>
			       _
       o   Emmanuel PeroumalnaA	k <peroumalnaik.emmanuel@gmail.com>

       Previous	maintainers:

       o   Luke	Closs <cpan@5thplane.com>

       o   Mark	Stosberg <mark@stosberg.com>

       Original	authors:

       o   Aditya Ivaturi <ivaturi@gmail.com>

COPYRIGHT AND LICENSE
       Copyright (c) 2010-2011 Aditya Ivaturi, Gordon Child

       Copyright (c) 2014-2017 Daniel Gempesaw

       Licensed	under the Apache License, Version 2.0 (the "License"); you may
       not use this file except	in compliance with the License.	 You may
       obtain a	copy of	the License at

       http://www.apache.org/licenses/LICENSE-2.0

       Unless required by applicable law or agreed to in writing, software
       distributed under the License is	distributed on an "AS IS" BASIS,
       WITHOUT WARRANTIES OR CONDITIONS	OF ANY KIND, either express or
       implied.	 See the License for the specific language governing
       permissions and limitations under the License.

perl v5.32.0			  2020-02-18		  Selenium::Firefox(3)

NAME | VERSION | SYNOPSIS | DESCRIPTION | ATTRIBUTES | METHODS | BREAKING CHANGES | SEE ALSO | BUGS | AUTHORS | COPYRIGHT AND LICENSE

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=Selenium::Firefox&sektion=3&manpath=FreeBSD+12.2-RELEASE+and+Ports>

home | help