isomorfeus-puppetmaster 0.5.4 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3a4c981525c3a8381541a2c0d39e136912b48c806f3531e8fc154843df3d295
-  data.tar.gz: 660c1ba75a82c53d2dad7c1586b0630aca667daa9aab971172cbeed0faf657f3
+  metadata.gz: 80d9cce921986638a386996065b1a98eac3ce78d8b94aadec05f205cf48df5a2
+  data.tar.gz: e46bf120b12d46f9f966b104fc4b220a642c0c0ad6ac3bbbf519b2abcc48a669
 SHA512:
-  metadata.gz: 7f94f1072bce9043e6eff190c0665ce76891f59e05c23577fb47f963661b2c864faeced4038da8e66458490ebc101dfbc7ac564cdc0f64ac38f0eada78960426
-  data.tar.gz: 53654204b887af7778dc5239b9e9961b2fdb44ad4560491e81e2d688c453a30411292868d1eb4f1df41088b68361b79dec37520739f5ec33f8d56b85a2b994b1
+  metadata.gz: f3d3c7d5276df8e8efb6c72ba023829d13a6d210a81e6797994397f6134f908df11fab3a269bc47e50e666414fbddfb4b59c71540a2a9bb88e15b492392e321b
+  data.tar.gz: 17bf71299943c74bc6c6763c25502b1b9f26868b56bce21dcc55a10c89c903832fd08ff5e40911f1f046446ed28a7aa051369927314665e163cd5a4b3bf51373

data/README.md

@@ -1,206 +1,167 @@
-# isomorfeus-puppetmaster
-
-A framework for acceptance tests or simply running tests in a headless browser. 
-Comes with drivers for chrome headless.
-Allows for writing javascript browser tests in pure ruby.
-
-### Community and Support
-At the [Isomorfeus Framework Project](http://isomorfeus.com)
-
-## Running on:
-- [CircleCI](https://circleci.com): [![CircleCI](https://circleci.com/gh/isomorfeus/isomorfeus-puppetmaster/tree/master.svg?style=svg)](https://circleci.com/gh/isomorfeus/isomorfeus-puppetmaster/tree/master)
-- [SemaphoreCI 2.0](https://semaphoreci.com): (not yet available)
-- [TravisCI](https://travis-ci.org): [![Build Status](https://travis-ci.org/isomorfeus/isomorfeus-puppetmaster.svg?branch=master)](https://travis-ci.org/isomorfeus/isomorfeus-puppetmaster)
- 
-## Installation
-
-In Gemfile:
-`gem 'isomorfeus-puppetmaster'`, then `bundle install`
-
-Also requires the following npm modules with recommended versions:
-
-- [puppeteer 10.2.x](https://github.com/GoogleChrome/puppeteer#readme) - for the chrome driver
-
-Simply install them in your projects root. Puppetmaster also depends on isomorfeus-speednode, which will be installed automatically.
-Speednode will pickup the node modules then from the projects root node_modules directory.
-
-## Configuration
-
-Puppetmaster provides these drivers:
-- chromium - a real browser, headless, fast
-- chromium_debug - opens a chromium browser window with devtools enabled, useful for debugging tests
-
-Chrome is the default driver. Selecting another driver, for example firefox:
-```ruby
-Isomorfeus::Puppetmaster.driver = :chromium_debug
-```
-
-Puppetmaster provides support for this rack server:
-- [iodine](https://github.com/boazsegev/iodine)
-Iodine is the default rack server, automatically configured.
-
-Getting the app ready and running:
-1. Assign a rack app
-2. Boot the app
-
-For Example:
-````ruby
-Isomorfeus::Puppetmaster.app = TestApp
-Isomorfeus::Puppetmaster.boot_app
-````
-
-Include the Puppetmaster DSL in the spec_helper.rb:
-```ruby
-RSpec.configure do |config|
-  config.include Isomorfeus::Puppetmaster::DSL
-end
-```
-Ready to play!
-
-## Terminology
-
-There are Browsers which may have windows or tabs, which translate to targets or pages which may contain documents or frames which consist of elements or nodes.
-In Puppetmaster, which is focusing on headless testing, the main "thing" is **just a document**. Its possible to open many documents at once, but what exactly a document is contained in,
-a window or tab or browser or target or whatever, is not of interest.
-A document consists of nodes. Simply working with just documents and nodes makes testing a lot simpler.
-``` 
-document
-    |____head (is a node)
-    |      |
-    |      |___more nodes
-    |      |___...
-    | 
-    |____body (is a node)
-           |
-           |___more nodes
-           |___...
-```
-
-## Basic usage pattern
-
-1. Find something
-2. Interact with it
-
-## Documents
-The drivers open a empty default document, to use that and go to the apps root page:
-```ruby
-doc = visit('/')
-```
-This provides the document `doc` which can further be used to interact with.
-To go to another location, call visit or goto on that doc:
-```ruby
-doc.visit('/login') # or
-doc.goto('/login')
-```
-
-To open another document:
-```ruby
-doc2 = open_new_document('/play')
-```
-
-Both open documents can then be independently interacted with:
-```ruby
-doc.visit('/go')
-doc2.goto('/location')
-```
-### Documents and Ruby
-
-Ruby can be executed within documents by simply providing a block or a string:
-```ruby
-doc.evaluate_ruby do
-  $document['my_id'].class_names
-end
-
-# or
-
-doc.evaluate_ruby "$document['my_id'].class_names"
-```
-
-The complete API of [opal-browser](https://github.com/opal/opal-browser) is available.
-
-### Documents and Javascript
-
-Javascript can be be evaluated within documents by simply providing a string:
-```ruby
-doc.evaluate_javascript '1+1' # => 2
-```
-
-#### Executing Javascript
-
-TODO
-
-#### DOM changes by Javascript, Timing
-
-TODO
- 
-## Nodes
-
-### Finding Nodes ...
-
-Nodes can be found by CSS selectors or XPath queries.
-Node can be found from the document or or other nodes as root.
-
-#### ... with CSS selectors
-
-Documents and nodes provide methods for finding single nodes or a group of nodes with CSS selectors. Examples:
-Find a single node in a document:
-```ruby
-node1 = doc.find('div') # finds the first div in the document
-node2 = doc.find('#super') # find node with id="super"
-```
-Find a single from another node:
-```ruby
-node3 = node1.find('div') # find first div within the node
-```
-
-Find multiple nodes in a document or from a node:
-```ruby
-node_array1 = doc.find_all('div') # finds all div's in a document
-node_array2 = node2.find_all('div') # find all div's within node2
-```
-
-#### ... with XPath queries
-
-Documents and nodes provide methods for finding single nodes or a group of nodes with Xpath queries. Examples:
-Find a single node in a document:
-```ruby
-node1 = doc.find_xpath('//div') # finds the first div in the document
-node2 = doc.find_xpath("//div[contains(@id,'super')]") # find div with id="super"
-```
-Find a single from another node:
-```ruby
-node3 = node1.find_xpath('//div') # find first div within the node
-```
-
-Find multiple nodes in a document or from a node:
-```ruby
-node_array1 = doc.find_all_xpath('//div') # finds all div's in a document
-node_array2 = node2.find_all_xpath('//div') # find all div's within node2
-```
-
-### Interacting with nodes
-
-Puppetmaster provides methods for emulating user interactions with nodes or documents.
-
-### Mouse
-```ruby
-node1.click
-```
-TODO
-
-### Keyboard
-```ruby
-node4 = doc.find('input')
-node4.type_keys('Message')
-```
-TODO
-
-### Fingers
-TODO
-
-
-### Tests
-To run tests:
-- clone repo
-- `bundle install`
-- `bundle exec rake`
+<h1 align="center">
+  <img src="https://github.com/isomorfeus/isomorfeus-puppetmaster/blob/master/Logo.png?raw=true" align="center" width="234" height="453" />
+  <br/>
+Isomorfeus Puppetmaster<br/>
+</h1>
+A framework for acceptance tests or simply running tests in a headless browser.
+Allows for writing javascript browser tests in pure ruby.
+It is tailored for Isomorfeus and using [puppeteer-ruby](https://github.com/YusukeIwaki/puppeteer-ruby).
+
+### Community and Support
+At the [Isomorfeus Framework Project](http://isomorfeus.com)
+
+## Installation
+
+In Gemfile:
+`gem 'isomorfeus-puppetmaster'`, then `bundle install`
+
+## Configuration
+
+Chrome is the default browser used.
+
+Iodine is the default rack server, automatically configured.
+- [isomorfeus-iodine](https://github.com/isomorfeus/isomorfeus-iodine/tree/isomorfeus_iodine)
+
+
+Getting the app ready and running:
+1. Assign a rack app
+2. Boot the app
+
+For Example:
+````ruby
+Isomorfeus::Puppetmaster.app = TestApp
+Isomorfeus::Puppetmaster.boot_app
+````
+
+Include the Puppetmaster DSL in the spec_helper.rb:
+```ruby
+RSpec.configure do |config|
+  config.include Isomorfeus::Puppetmaster::DSL
+end
+```
+Ready to play!
+
+## Terminology
+
+There are Browsers which may have windows or tabs, which translate to targets or pages which may contain documents or frames which consist of elements or elements.
+In Puppetmaster, which is focusing on headless testing, the main "thing" is **just a page**. Its possible to open many pages at once.
+A document consists of elements. Simply working with just pages, documents and elements makes testing a lot simpler.
+
+## Basic usage pattern
+
+1. Find something
+2. Interact with it
+
+## Pages
+A page is a Puppeteer::Page and provides its complete API plus some additional convenience methods.
+The drivers opens a empty default page, to use that and go to the apps root page:
+```ruby
+page = visit('/')
+```
+This provides the page `page` which can further be used to interact with.
+To go to another location, call visit or goto on that doc:
+```ruby
+page.visit('/login') # or
+page.goto('/login')
+```
+
+To open another page:
+```ruby
+page2 = new_page('/play')
+```
+
+Both open pages can then be independently interacted with:
+```ruby
+page.visit('/go')
+page2.goto('/location')
+```
+### Pages and Ruby
+
+Ruby can be executed within pages by simply providing a block or a string:
+```ruby
+page.eval_ruby do
+  $document['my_id'].class_names
+end
+
+# or
+
+page.eval_ruby "$document['my_id'].class_names"
+```
+
+### Pages and Javascript
+
+Javascript can be be evaluated within pages by simply providing a string:
+```ruby
+page.eval '1+1' # => 2
+```
+
+## Elements
+
+### Finding Elements ...
+
+Elements can be found by CSS selectors or XPath queries.
+Element can be found from the page or or other elements as root.
+
+#### ... with CSS selectors
+
+Pages and elements provide methods for finding single elements or a group of elements with CSS selectors. Examples:
+Find a single element in a page:
+```ruby
+element1 = page.find('div') # finds the first div in the page
+element2 = page.find('#super') # find element with id="super"
+```
+Find a single element from another element:
+```ruby
+element3 = element1.find('div') # find first div within the element
+```
+
+Find multiple elements in a page or from a element:
+```ruby
+element_array1 = page.find_all('div') # finds all div's in a page
+element_array2 = element2.find_all('div') # find all div's within element2
+```
+
+#### ... with XPath queries
+
+Pages and elements provide methods for finding single elements or a group of elements with XPath queries. Examples:
+Find a single element in a page:
+```ruby
+element1 = page.find_xpath('//div') # finds the first div in the page
+element2 = page.find_xpath("//div[contains(@id,'super')]") # find div with id="super"
+```
+Find a single element from another element:
+```ruby
+element3 = element1.find_xpath('//div') # find first div within the element
+```
+
+Find multiple elements in a page or from a element:
+```ruby
+element_array1 = page.find_all_xpath('//div') # finds all div's in a page
+element_array2 = element2.find_all_xpath('//div') # find all div's within element2
+```
+
+### Interacting with elements
+
+Puppetmaster provides methods for emulating user interactions with elements or pages.
+
+### Mouse
+```ruby
+element1.click
+```
+
+### Keyboard
+```ruby
+element4 = page.find('input')
+element4.type_text('Message')
+```
+
+### Tests
+To run tests:
+- clone repo
+- `bundle install`
+- `bundle exec rake`
+
+
+### Usage examples
+
+There are alot of usage examples in the spec directory of the repo, see [https://github.com/isomorfeus/isomorfeus-puppetmaster/tree/master/spec/common](https://github.com/isomorfeus/isomorfeus-puppetmaster/tree/master/spec/common).

data/lib/isomorfeus/puppeteer/dom_world.rb

@@ -0,0 +1,13 @@
+class Puppeteer::DOMWorld
+  def eval_ruby(ruby_source = '', &block)
+    execution_context.eval_ruby(ruby_source, &block)
+  end
+
+  def eval_with_opal(ruby_source = '', &block)
+    execution_context.eval_with_opal(ruby_source, &block)
+  end
+
+  def await_ruby(ruby_source = '', &block)
+    execution_context.await_ruby(ruby_source, &block)
+  end
+end

data/lib/isomorfeus/puppeteer/element_handle.rb

@@ -0,0 +1,238 @@
+class Puppeteer::ElementHandle
+  def ==(o)
+    evaluate('(eh, oh) => { return (eh == oh); }', o) rescue false
+  end
+
+  def Sx1(x)
+    self.Sx(x).first
+  end
+
+  def attribute(a)
+    evaluate("(eh) => { return eh.getAttribute('#{a.to_s}'); }")
+  end
+
+  def checked?
+    evaluate("(eh) => { return eh.checked; }")
+  end
+
+  def check
+    return false if disabled? || !visible?
+    evaluate("(eh) => { eh.click(); eh.setAttribute('checked', ''); eh.checked = true; }")
+    true
+  end
+
+  def uncheck
+    return false if disabled? || !visible?
+    evaluate("(eh) => { eh.click(); eh.removeAttribute('checked'); eh.checked = false; }")
+    true
+  end
+
+  def computed_style
+    evaluate <<~JAVASCRIPT
+    (eh) => {
+      let cs = window.getComputedStyle(eh);
+      let ro = {};
+      let pr;
+      for (let i = 0; i<cs.length; i++) {
+        pr = cs[i];
+        ro[pr] = cs.getPropertyValue(pr);
+      }
+      return ro
+    }
+    JAVASCRIPT
+  end
+
+  def disabled?
+    d = attribute('disabled')
+    return true if d.is_a?(String)
+    o = evaluate('(eh) => { if (eh.closest("[disabled]")!=null) { return true; }; return false; }')
+    return true if o
+    return false if d.nil?
+    return d
+  end
+
+  def double_click(button: 'left', delay: nil, offset: nil)
+    click(button: button, click_count: 2, delay: delay, offset: offset)
+  end
+
+  def exec(j, *args)
+    js = <<~JAVASCRIPT
+    function(eh) {
+      let args = [];
+      for (let i=1; i<arguments.length; i++) {
+        args[i-1] = arguments[i];
+      }
+      let _f = function() {
+        #{j.strip}
+      }
+      _f.apply(eh, args);
+    }
+    JAVASCRIPT
+    evaluate(js, *args)
+  end
+
+  def eval(j, *args)
+    js = <<~JAVASCRIPT
+    function(eh) {
+      let args = [];
+      for (let i=1; i<arguments.length; i++) {
+        args[i-1] = arguments[i];
+      }
+      let _f = function() {
+        return #{j.strip}
+      }
+      return _f.apply(eh, args);
+    }
+    JAVASCRIPT
+    r = evaluate_handle(js, *args)
+    return r if r.is_a?(Puppeteer::ElementHandle)
+    r&.json_value
+  end
+
+  alias_method :find, :query_selector
+  alias_method :find_all, :query_selector_all
+  alias_method :find_xpath, :Sx1
+  alias_method :find_all_xpath, :Sx
+
+  def find_el(selector)
+    el = query_selector(selector) rescue nil
+    el = Sx1(selector) rescue nil if el.nil?
+    el = Sx1("//*[normalize-space(text())=\"#{selector}\"]") rescue nil if el.nil?
+    el = Sx1("//*[@name=\"#{selector}\"]") rescue nil if el.nil?
+    el = Sx1("//*[@title=\"#{selector}\"]") rescue nil if el.nil?
+    el = Sx1("//*[@value=\"#{selector}\"]") rescue nil if el.nil?
+    el
+  end
+
+  def id
+    evaluate('(eh) => { return eh.id; }')
+  end
+
+  def inner_html
+    evaluate('(eh) => { return eh.innerHTML; }')
+  end
+
+  def inner_text
+    evaluate('(eh) => { return eh.innerText; }')&.strip&.tr("\u00a0", ' ')
+  end
+  alias_method :text, :inner_text
+
+  def outer_html
+    evaluate('(eh) => { return eh.outerHTML; }')
+  end
+
+  def prop(p)
+    self[p.to_s].json_value
+  end
+
+  def right_click(click_count: 1, delay: nil, offset: nil)
+    click(button: 'right', click_count: click_count, delay: delay, offset: offset)
+  end
+
+  def save_screenshot(f, options = {})
+    raise "Invalid filename '#{f}'!" if f.include?('..')
+    raise "Invalid Isomorfeus::Puppetmaster.download_path!" unless Isomorfeus::Puppetmaster.download_path.is_a?(String)
+    options[:path] = File.join(Isomorfeus::Puppetmaster.download_path, f)
+    options[:type] = 'png' unless options.key?(:type)
+    screenshot(**options)
+  end
+
+  def selected?
+    c = attribute('selected')
+    return true if c.is_a?(String)
+    return false if c.nil?
+    return c
+  end
+
+  def selected_options
+    evaluate('(eh) => { let a=[]; let o = eh.selectedOptions; for (let i=0; i<o.length; i++) { a.push(o[i].value) }; return a; }')
+  end
+
+  def set_inner_html(c)
+    evaluate('(eh, c) => { if (eh.readOnly) {throw "Element is read only!" }; return eh.innerHTML = c; }', c)
+  end
+
+  def set_value(v)
+    evaluate('(eh, v) => { if (eh.readOnly) {throw "Element is read only!" }; return eh.value = v; }', v)
+  end
+  alias_method :value=, :set_value
+
+  def tag_name
+    evaluate('(eh) => { return eh.tagName; }').downcase
+  end
+
+  def value
+    evaluate('(eh) => { return eh.value; }')
+  end
+
+  def visible?
+    evaluate('(eh) => { return !!(( eh.offsetWidth || eh.offsetHeight || eh.getClientRects().length) && (window.getComputedStyle(eh).visibility !== "hidden" && window.getComputedStyle(eh).display !== "none" )); }')
+  end
+
+  # rspec matcher methods
+
+  def has_field?(s)
+    eh = query_selector(s)
+    return false unless eh.is_a?(Puppeteer::ElementHandle)
+    tu = eh.tag_name.upcase
+    return true if tu == 'INPUT' || tu == 'TEXTAREA'
+    false
+  end
+
+  def has_no_field?(s)
+    !has_field?(s)
+  end
+
+  def has_selected?(v)
+    selected_options.include?(v)
+  end
+
+  def has_selector?(s, count: nil)
+    return query_selector_all(s).size == count.to_i unless count.nil?
+    return true if query_selector(s).is_a?(Puppeteer::ElementHandle)
+    false
+  end
+
+  def has_no_selector?(s, count: nil)
+    !has_selector?(s, count: count)
+  end
+
+  def has_style?(sh)
+    s = computed_style
+    m = true
+    sh.each do |k,v|
+      if v.is_a?(Regexp)
+        m = false unless s[k.to_s].match?(v)
+      else
+        m = false unless s[k.to_s] == v
+      end
+    end
+    m
+  end
+
+  def has_text?(t, count: nil, between: nil, max: nil, min: nil)
+    c = inner_text
+    n = nil
+    n = c.scan(t).size if count || between || max || min
+    return n == count.to_i if count
+    return n <= max.to_i if max
+    return n >= min.to_i if min
+    return between.include?(n) if between
+    return c.match?(t) if t.is_a?(Regexp)
+    c.include?(t.to_s)
+  end
+
+  def has_no_text?(t, count: nil, between: nil, max: nil, min: nil)
+    !has_text?(t, count: count, between: between, max: max, min: min)
+  end
+
+  def has_xpath?(x, count: nil)
+    e = self.Sx(x)
+    return e.any? if count.nil?
+    return e.size == count
+  end
+
+  def has_no_xpath?(x, count: nil)
+    !has_xpath?(x, count: count)
+  end
+end