File Coverage

blib/lib/Selenium/Remote/WebElement.pm

Criterion	Covered	Total	%
statement	70	147	47.6
branch	11	48	22.9
condition	8	35	22.8
subroutine	19	33	57.5
pod	28	28	100.0
total	136	291	46.7

package Selenium::Remote::WebElement;
$Selenium::Remote::WebElement::VERSION = '1.47';
# ABSTRACT: Representation of an HTML Element used by Selenium Remote Driver

use strict;
use warnings;

use Moo;
use Carp qw(carp croak);


has 'id' => (
    is       => 'ro',
    required => 1,
    coerce   => sub {
        my ($value) = @_;
        if ( ref($value) eq 'HASH' ) {
            if ( exists $value->{ELEMENT} ) {

                # The JSONWireProtocol web element object looks like
                #
                #     { "ELEMENT": $INTEGER_ID }
                return $value->{ELEMENT};
            }
            elsif ( exists $value->{'element-6066-11e4-a52e-4f735466cecf'} ) {

                # but the WebDriver spec web element uses a magic
                # string. See the spec for more information:
                #
                # https://www.w3.org/TR/webdriver/#elements
                return $value->{'element-6066-11e4-a52e-4f735466cecf'};
            }
            else {
                croak
'When passing in an object to the WebElement id attribute, it must have at least one of the ELEMENT or element-6066-11e4-a52e-4f735466cecf keys.';
            }
        }
        else {
            return $value;
        }
    }
);

has 'driver' => (
    is       => 'ro',
    required => 1,
    handles  => [qw(_execute_command)],
);


sub child {
    return $_[0]->{driver}->find_child_element(@_);
}

sub children {
    return $_[0]->{driver}->find_child_elements(@_);
}


sub click {
    my ($self) = @_;
    my $res = { 'command' => 'clickElement', 'id' => $self->id };
    return $self->_execute_command($res);
}


sub execute_script {
    my ($self, $script, @args) = @_;
    return $self->driver->execute_script(
        $script,
        { 'element-6066-11e4-a52e-4f735466cecf' => $self->{id} },
        @args );
}

sub execute_async_script {
    my ($self, $script, @args) = @_;
    return $self->driver->execute_async_script(
        $script,
        { 'element-6066-11e4-a52e-4f735466cecf' => $self->{id} },
        @args );
}



sub submit {
    my ($self) = @_;
    if (
        $self->driver->{is_wd3}
        && !(
            grep { $self->driver->browser_name eq $_ } qw{MicrosoftEdge}
        )
      )
    {
        if ( $self->get_tag_name() ne 'form' ) {
            return $self->driver->execute_script(
                "return arguments[0].form.submit();",
                { 'element-6066-11e4-a52e-4f735466cecf' => $self->{id} } );
        }
        else {
            return $self->driver->execute_script(
                "return arguments[0].submit();",
                { 'element-6066-11e4-a52e-4f735466cecf' => $self->{id} } );
        }
    }
    my $res = { 'command' => 'submitElement', 'id' => $self->id };
    return $self->_execute_command($res);
}


sub send_keys {
    my ( $self, @strings ) = @_;
    croak "no keys to send" unless scalar @strings >= 1;
    my $res = { 'command' => 'sendKeysToElement', 'id' => $self->id };

    # We need to send an array of single characters to be WebDriver
    # spec compatible. That is, for @strings = ('hel', 'lo'), the
    # corresponding value must be ('h', 'e', 'l', 'l', 'o' ). This
    # format conforms with the Spec AND works with the Selenium
    # standalone server.
    my $strings = join( '', map { $_ . "" } @strings );
    my $params = {
        'value' => [ split( '', $strings ) ],
        text    => $strings,
    };
    return $self->_execute_command( $res, $params );
}


sub is_selected {
    my ($self) = @_;

    my $to_check = $self->get_tag_name() eq 'option' ? 'selected' : 'checked';
    return $self->get_property($to_check)
      if $self->driver->{is_wd3}
      && !( grep { $self->driver->browser_name eq $_ }
        qw{chrome MicrosoftEdge} );
    my $res = { 'command' => 'isElementSelected', 'id' => $self->id };
    return $self->_execute_command($res);
}


sub set_selected {
    my ($self) = @_;
    if ( $self->driver->{is_wd3} ) {
        return if $self->is_selected();
        return $self->click();
    }
    my $res = { 'command' => 'setElementSelected', 'id' => $self->id };
    return $self->_execute_command($res);
}


sub toggle {
    my ($self) = @_;
    if ( $self->driver->{is_wd3} ) {
        return $self->click() unless $self->is_selected();
        return $self->driver->execute_script(
qq/ if (arguments[0].checked) { arguments[0].checked = 0 }; return arguments[0].checked; /,
            { 'element-6066-11e4-a52e-4f735466cecf' => $self->{id} }
        );
    }
    my $res = { 'command' => 'toggleElement', 'id' => $self->id };
    return $self->_execute_command($res);
}


sub is_enabled {
    my ($self) = @_;
    if (
        $self->driver->{is_wd3}
        && !(
            grep { $self->driver->browser_name eq $_ } qw{chrome MicrosoftEdge}
        )
      )
    {
        return 1 if $self->get_tag_name() ne 'input';
        return $self->get_property('disabled') ? 0 : 1;
    }
    my $res = { 'command' => 'isElementEnabled', 'id' => $self->id };
    return $self->_execute_command($res);
}


sub get_element_location {
    my ($self) = @_;
    if (
        $self->driver->{is_wd3}
        && !(
            grep { $self->driver->browser_name eq $_ } qw{chrome MicrosoftEdge}
        )
      )
    {
        my $data = $self->get_element_rect();
        delete $data->{height};
        delete $data->{width};
        return $data;
    }
    my $res = { 'command' => 'getElementLocation', 'id' => $self->id };
    return $self->_execute_command($res);
}


sub get_size {
    my ($self) = @_;
    if (
        $self->driver->{is_wd3}
        && !(
            grep { $self->driver->browser_name eq $_ } qw{chrome MicrosoftEdge}
        )
      )
    {
        my $data = $self->get_element_rect();
        delete $data->{x};
        delete $data->{y};
        return $data;
    }
    my $res = { 'command' => 'getElementSize', 'id' => $self->id };
    return $self->_execute_command($res);
}


sub get_element_rect {
    my ($self) = @_;
    my $res = { 'command' => 'getElementRect', 'id' => $self->id };
    return $self->_execute_command($res);
}


sub get_element_location_in_view {
    my ($self) = @_;

    #XXX chrome is dopey here
    return $self->driver->execute_script(
        qq{
        if (typeof(arguments[0]) !== 'undefined' && arguments[0].nodeType === Node.ELEMENT_NODE) {
            arguments[0].scrollIntoView();
            var pos = arguments[0].getBoundingClientRect();
            return {y:pos.top,x:pos.left};
        }
        return {};
    }, { 'element-6066-11e4-a52e-4f735466cecf' => $self->{id} }
      )
      if $self->driver->{is_wd3} && grep { $self->driver->browser_name eq $_ }
      ( 'firefox', 'internet explorer', 'chrome' );
    my $res = { 'command' => 'getElementLocationInView', 'id' => $self->id };
    return $self->_execute_command($res);
}


sub get_tag_name {
    my ($self) = @_;
    my $res = { 'command' => 'getElementTagName', 'id' => $self->id };
    return $self->_execute_command($res);
}


sub clear {
    my ($self) = @_;
    my $res = { 'command' => 'clearElement', 'id' => $self->id };
    return $self->_execute_command($res);
}


sub get_attribute {
    my ( $self, $attr_name, $no_i_really_mean_it ) = @_;
    if ( not defined $attr_name ) {
        croak 'Attribute name not provided';
    }

    #Handle global JSONWire emulation flag
    $no_i_really_mean_it = 1 unless $self->{driver}->{emulate_jsonwire};

    return $self->get_property($attr_name)
      if $self->driver->{is_wd3}
      && !( grep { $self->driver->browser_name eq $_ }
        qw{chrome MicrosoftEdge} )
      && !$no_i_really_mean_it;

    my $res = {
        'command' => 'getElementAttribute',
        'id'      => $self->id,
        'name'    => $attr_name,
    };
    return $self->_execute_command($res);
}


sub get_property {
    my ( $self, $prop ) = @_;
    return $self->get_attribute($prop)
      if $self->driver->{is_wd3}
      && ( grep { $self->driver->browser_name eq $_ }
        qw{chrome MicrosoftEdge} );
    my $res =
      { 'command' => 'getElementProperty', id => $self->id, name => $prop };
    return $self->_execute_command($res);
}


sub get_value {
    my ($self) = @_;
    return $self->get_attribute('value');
}


sub is_displayed {
    my ($self) = @_;
    if (
        $self->driver->{is_wd3}
        && !(
            grep { $self->driver->browser_name eq $_ } qw{chrome MicrosoftEdge}
        )
      )
    {
        return 0
          if $self->get_tag_name() eq 'input'
          && $self->get_property('type') eq 'hidden';    #hidden type inputs
        return 0 unless $self->_is_in_viewport();
        return int( $self->get_css_attribute('display') ne 'none' );
    }
    my $res = { 'command' => 'isElementDisplayed', 'id' => $self->id };
    return $self->_execute_command($res);
}

sub _is_in_viewport {
    my ($self) = @_;
    return $self->driver->execute_script(
        qq{
        var rect = arguments[0].getBoundingClientRect();
        return (
            rect.top >= 0 &&
            rect.left >= 0 &&
            rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) &&
            rect.right <= (window.innerWidth || document.documentElement.clientWidth)
        );
    }, { 'element-6066-11e4-a52e-4f735466cecf' => $self->{id} }
    );
}


sub is_hidden {
    my ($self) = @_;
    return !$self->is_displayed();
}


sub drag {
    my ( $self, $target ) = @_;
    require Selenium::ActionChains;
    my $chain = Selenium::ActionChains->new( driver => $self->driver );
    return $chain->drag_and_drop( $self, $target )->perform();
}


sub get_text {
    my ($self) = @_;
    my $res = { 'command' => 'getElementText', 'id' => $self->id };
    return $self->_execute_command($res);
}


sub get_css_attribute {
    my ( $self, $attr_name ) = @_;
    if ( not defined $attr_name ) {
        croak 'CSS attribute name not provided';
    }
    my $res = {
        'command'       => 'getElementValueOfCssProperty',
        'id'            => $self->id,
        'property_name' => $attr_name,
    };
    return $self->_execute_command($res);
}


sub describe {
    my ($self) = @_;
    my $res = { 'command' => 'describeElement', 'id' => $self->id };
    return $self->_execute_command($res);
}


sub screenshot {
    my ( $self, $scroll ) = @_;
    $scroll //= 1;
    my $res = { 'command' => 'elementScreenshot', id => $self->id };
    my $input = { scroll => int($scroll) };
    return $self->_execute_command( $res, $input );
}


sub capture_screenshot {
    my ( $self, $filename, $scroll ) = @_;
    croak '$filename is required' unless $filename;

    open( my $fh, '>', $filename );
    binmode $fh;
    print $fh MIME::Base64::decode_base64( $self->screenshot($scroll) );
    CORE::close $fh;
    return 1;
}

1;

__END__