Behavior of present/absent

[jacob-carlborg]

This is more of a question than an issue. What is the intended behavior of the present? and absent? methods on an element proxy. The seem to only work with the sate the element was in when the proxy was created. That is, if you have an element object which was present when it was created. Then after performing some action it's removed from the DOM. Now, calling present? on the same object will still return true.

BTW, using these methods as RSpec predicate matchers [1] don't really work. They throw an exception instead of resulting in an assertion failure. Not sure if this is an issue with RSpec or AePageObjects.

[1] https://github.com/rspec/rspec-expectations#predicate-matchers

[ipmsteven]

Hi @jacob-carlborg

I think you can use absent? instead, the absent? will always query the current DOM each time instead of reusing the element object which was present when its was created, I am not sure if we should also do the same thing for present? @dtognazzini

For that rspec-expectations issue, could you provide more info, like the stacktrace?

[jacob-carlborg]

I think you can use absent? instead, the absent? will always query the current DOM each time instead of reusing the element object which was present when its was created,

Ok, I didn't noticed present? and absent? behaved differently. That might explain some weird behavior I've seen.

I am not sure if we should also do the same thing for present?

One could argue that logically absent? and present? should never return the same value.

For that rspec-expectations issue, could you provide more info, like the stacktrace?

I'll see if I can come up with an example and stracktrace.

[jacob-carlborg]

For that rspec-expectations issue, could you provide more info, like the stacktrace?

I tracked down the issue. Lets say there's a piece of code looking like this:

expect(foo).to be_absent

In this case foo is an instance of ElementProxy. The problem is that RSpec is checking if the method exists and is accessible on the expected value [1] [2]. It does that by calling private_methods on the expected value. Since all (most) methods are removed from ElementProxy [3] it will call method_missing [4]. Which will try to load the element [5] without any way to know if the element exists or not. When it doesn't, it raises an exception.

[1] https://github.com/rspec/rspec-expectations/blob/master/lib/rspec/matchers/built_in/be.rb#L188
[2] https://github.com/rspec/rspec-expectations/blob/master/lib/rspec/matchers/built_in/be.rb#L230
[3] https://github.com/appfolio/ae_page_objects/blob/master/lib/ae_page_objects/element_proxy.rb#L6-L10
[4] https://github.com/appfolio/ae_page_objects/blob/master/lib/ae_page_objects/element_proxy.rb#L123
[5] https://github.com/appfolio/ae_page_objects/blob/master/lib/ae_page_objects/element_proxy.rb#L142

[jacob-carlborg]

In the latest version of RSpec it doesn't call private_methods but it does call inspect which will have the same problem.

[dtognazzini]

What is the intended behavior of the present? and absent? methods on an element proxy.

The AePageObjects DSL generates methods that when called look up elements on the page. For example:

class SomePage < AePageObjects::Document
  element :the_form, locator: '.some_form'
end

some_page.the_form

The last line will look up the DOM element via the supplied locator. We wanted to support a feature where tests could ask if an element was present/absent on page. ElementProxy was introduced to provide the feature whereby:

some_page.the_form

...would return an instance of ElementProxy that implements present?/absent? and all other methods are forwarded to the underlying element, which is implicitly looked up and cached.

That was the original intention. Since then ElementProxy has evolved to host other checks that could made about an element regardless of whether it exists on the page:

• visible?/hidden? - use when you don't care about distinguishing between visible/present or hidden/absent.
• wait_unitl_* methods - use when you want to wait for the state of the element to change.

One could argue that logically absent? and present? should never return the same value.

I would argue this 👍

Generally, the presence checks should re-look up the element; basically the converse of #65.

Currently, ElementProxy caches the element after lookup for efficiency reasons. I think we can keep this behavior and have presence/absence checks invalidate the cache.

I'll file an issue for that change. Thanks, @jacob-carlborg !

[dtognazzini]

RE: RSpec matchers.

I think this only happens when the expectation fails:

1. The call to respond_to? in predicate_accessible? would be handled by ElementProxy#respond_to?.
2. predicate_matches? ends up calling respond_to?.
3. private_methods is only called in validity_message.

The proxying code is old and has always had issues. It might be worthwhile just to remove it altogether.

In version 2.0, we're dropping support for Ruby 1.8 (finally). Perhaps using BasicObject instead of Object would be a better implementation.

At minimum we should be testing against RSpec expectations. I'll add an enhancement for that.

[jacob-carlborg]

The call to respond_to? in predicate_accessible? would be handled by ElementProxy#respond_to?

I see that predicate_accessible? calls private_methods in RSpec 3.1, which I'm using. But I can upgrade to 3.2, removing one of the issues.

private_methods is only called in validity_message.

But inspect is called from here, via actual_formatted, which goes to rspec-support.

Thanks for all your replies.

[dtognazzini]

I'm going to close this issue for now since all the issues are covered by Issues. Let me know if I missed anything. Thanks!