testable 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ca79301e385c9f1457040532815cfe04632a4977
-  data.tar.gz: 315f37f4f0e4afe12e610e5d87d1b5e36194e80e
+  metadata.gz: 9fe925fea55efebca8a07a490fb639669355cecf
+  data.tar.gz: 750388f14ff7df442cba5c4abb60ea51125a70c6
 SHA512:
-  metadata.gz: 2132bbcc51ddbc97d9416c1e80c72e6b4b245bfadd2dd0179e1fac1c75f794080fe917ec59dfff3e3e424b057d007c984aa41eda885df1fc0748910ed69b6e18
-  data.tar.gz: 64f358af899249bed9b2eaa06936420090a0b209440d3ad63d81475903c02d7845792a3a1df33c983650e4f67c8dd48339d63ccf17d5924710e9bdcf0d2bde22
+  metadata.gz: 4ae956962245d4326c31028c59b96fb060d1e46765d8db56309eadfe8460bb308a79876bfcafaa57fdfde38ad9e2a9c676c83c10ce9f7eef8df231a3938d0c57
+  data.tar.gz: 2b986d69188ff6df56efe57e3dbb5724d83ed21bc6aefc0acb19198ad2e3f8b8da21dbf1c9aa31b7cdbbce156757528bed75d1f116c635c9f66b0cc736c19598

data/.gitignore

@@ -11,6 +11,7 @@
 /doc/
 /pkg/
 /spec/reports/
+/spec/examples.txt
 /tmp/
 *.log
 *.tmp

data/.hound.yml

@@ -49,6 +49,12 @@ Style/SingleLineBlockParams:
 Style/DotPosition:
   EnforcedStyle: leading
 
+# Allow methods with has_ for predicates.
+Style/PredicateName:
+  NameWhitelist:
+    - has_correct_url?
+    - has_correct_title?
+
 # Stop nesting so hard.
 Metrics/BlockNesting:
   Max: 2

data/.rspec

@@ -1,3 +1,3 @@
---color
 --format documentation
+--color
 --require spec_helper

data/README.md

@@ -1,16 +1,15 @@
 # Testable
 
+[![Build Status](https://circleci.com/gh/jeffnyman/testable.svg?style=shield)](https://circleci.com/gh/jeffnyman/testable)
 [![Gem Version](https://badge.fury.io/rb/testable.svg)](http://badge.fury.io/rb/testable)
 [![License](http://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/jeffnyman/testable/blob/master/LICENSE.txt)
 
 [![Dependency Status](https://gemnasium.com/jeffnyman/testable.png)](https://gemnasium.com/jeffnyman/testable)
 
-Testable provides a semantic DSL to construct a fluent interface for test execution libraries.
+The Testable gem aims to be a micro-framework that will provide a semantic DSL to construct a fluent interface for test execution libraries.
 
 This fluent interface promotes the idea of compressibility of your test logic, allowing for more factoring, more reuse, and less repetition. You can use Testable directly as an automated test library or you can use it with other tools such as RSpec, Cucumber, or anything else that allows you to delegate down to a different level of abstraction.
 
-Unlike many of my other tooling experiments with Ruby, Testable relies on [Capybara](https://github.com/jnicklas/capybara) as its execution library.
-
 ## Installation
 
 To get the latest stable release, add this line to your application's Gemfile:
@@ -36,14 +35,22 @@ You can also install Testable just as you would any other gem:
 ## Usage
 
 Probably the best way to get a feel for the current state of the code is to look at the test scripts:
- 
+
 * [Standard test script](https://github.com/jeffnyman/testable/blob/master/test/testable-standard.rb)
 * [Factory test script](https://github.com/jeffnyman/testable/blob/master/test/testable-factory.rb)
 
-If you clone the repository, you can see this script in action by running the command `rake scripts:standard` or `rake scripts:factory`.
+If you clone the repository, you can see this script in action by running the command `rake script:standard` or `rake script:factory`.
+
+You'll see references to "Veilus" and a localhost URL. I'm using my own [Veilus application](https://veilus.herokuapp.com/). The localhost refers to using the [Veilus repo](https://github.com/jeffnyman/veilus) locally.
 
 More details will be forthcoming as the project evolves.
 
+## Implementation Ideas
+
+I want to hide driver details (i.e., Selenium) as much as possible but still allow access to the full API. Ideally I'd like to avoid the low-level Selenium and use a wrapper around it while not inventing my own. Since both watir-webdriver and capybara delegate down to Selenium, it seems wise to use one of those. (Or maybe allow for both as Symbiont currently does.) An open question is whether I should proxy the driver library to my own implementation or not. Symbiont currently does exactly that, which is a very different model than [page-object](https://github.com/cheezy/page-object), which has to add an incredible amount of wasted code rather than just relying on delegation and a proxy pattern.
+
+I don't want to presume a particular modeling structure, such as the use of page objects. That being said, most such modeling structures are really just classes that are being utilized in a certain way, which means I really want to model the more generic notion of an interface. An interface could, theoretically, be an application (screens), a site (pages), or an API (services). An interface would be a Screen class, a Page class, or a Service class. These then become screen objects, page objects or service objects. An open question is how those distinctions are purely conceptual versus have specific implementations.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake spec:all` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/Rakefile

@@ -1,26 +1,27 @@
 #!/usr/bin/env rake
-
 require "bundler/gem_tasks"
 require "rdoc/task"
-require "rubocop/rake_task"
 require "rspec/core/rake_task"
+require "rubocop/rake_task"
 
 RuboCop::RakeTask.new
 
-namespace :scripts do
-  desc "Run the standard script."
+RSpec::Core::RakeTask.new(:spec)
+
+namespace :script do
+  desc "Run the Testable standard script"
   task :standard do
     system("ruby ./test/testable-standard.rb")
   end
 
-  desc "Run the script with a factory."
+  desc "Run the Testable factory script"
   task :factory do
     system("ruby ./test/testable-factory.rb")
   end
 end
 
 namespace :spec do
-  desc "Clean all generated reports."
+  desc 'Clean all generated reports'
   task :clean do
     system('rm -rf spec/reports')
   end

data/circle.yml

@@ -0,0 +1,3 @@
+checkout:
+  post:
+    - mkdir -p spec/reports

data/lib/testable/data_setter.rb

@@ -0,0 +1,51 @@
+class Object
+  def chain(method_chain, arg = nil)
+    return self if method_chain.empty?
+    method_chain.split('.').inject(self) do |o, m|
+      if arg.nil?
+        o.send(m.intern)
+      else
+        o.send(m.intern, arg)
+      end
+    end
+  end
+end
+
+module Testable
+  module DataSetter
+    def using(data)
+      data.each do |key, value|
+        use_data_with(key, value) if object_enabled_for(key)
+      end
+    end
+
+    alias using_data using
+    alias use_data using
+    alias using_values using
+    alias use_values using
+
+    private
+
+    def use_data_with(key, value)
+      element = send(key.to_s)
+      set_and_select(key, element, value)
+      check_and_uncheck(key, element, value)
+    end
+
+    def set_and_select(key, element, value)
+      chain("#{key}.set", value)    if element.class == Watir::TextField
+      chain("#{key}.set")           if element.class == Watir::Radio
+      chain("#{key}.select", value) if element.class == Watir::Select
+    end
+
+    def check_and_uncheck(key, element, value)
+      return chain("#{key}.check") if element.class == Watir::CheckBox && value
+      chain("#{key}.uncheck")      if element.class == Watir::CheckBox
+    end
+
+    def object_enabled_for(key)
+      web_element = send(key.to_s)
+      web_element.enabled? && web_element.visible?
+    end
+  end
+end

data/lib/testable/dom_update.rb

@@ -0,0 +1,19 @@
+module Watir
+  class Element
+    OBSERVER_FILE = "/extensions/dom_observer.js".freeze
+    DOM_OBSERVER = File.read("#{File.dirname(__FILE__)}#{OBSERVER_FILE}").freeze
+
+    def dom_updated?(delay: 1.1)
+      driver.manage.timeouts.script_timeout = delay + 1
+      driver.execute_async_script(DOM_OBSERVER, wd, delay)
+    ensure
+      driver.manage.timeouts.script_timeout = 1
+    end
+
+    alias dom_updated      dom_updated?
+    alias dom_is_updated   dom_updated?
+    alias dom_is_changed   dom_updated?
+    alias when_dom_updated dom_updated?
+    alias when_dom_changed dom_updated?
+  end
+end

data/lib/testable/element.rb

@@ -1,55 +1,56 @@
+require "watir"
+require "testable/situation"
+
 module Testable
-  module Element
-    def element(name, locator = nil)
-      no_locator(name) if locator.nil?
-      build(name, locator) do
-        define_method(name.to_s) do |*options|
-          find_first(locator, *options)
-        end
-      end
-    end
+  include Situation
+
+  module_function
+
+  def elements
+    @elements = Watir::Container.instance_methods unless @elements
+  end
+
+  def elements?
+    @elements
+  end
 
-    def elements(name, locator = nil)
-      no_locator(name) if locator.nil?
-      build(name, locator) do
-        define_method(name.to_s) do |*options|
-          find_all(locator, *options)
-        end
+  def recognizes?(method)
+    @elements.include? method.to_sym
+  end
+
+  module Element
+    Testable.elements.each do |element|
+      # This is what allows Watir-based elements to be defined
+      # on an element definition.
+      define_method(element) do |*signature|
+        identifier, locator = parse_signature(signature)
+        define_element_accessor(identifier, locator, element)
       end
     end
 
     private
 
-    def build(name, locator)
-      yield
-      add_element_methods(name, locator)
+    def define_element_accessor(identifier, *locator, element)
+      # This is what allows each identifier to be a method.
+      define_method(identifier.to_s.to_sym) do |*values|
+        no_locator(self.class, identifier) if empty_locator(locator, values)
+        locator = values if locator[0].nil?
+        reference_element(element, locator)
+      end
     end
 
-    def add_element_methods(name, locator)
-      existence_check(name, locator)
-      nonexistence_check(name, locator)
+    def parse_signature(signature)
+      [signature.shift, signature.shift]
     end
 
-    def existence_check(name, locator)
-      method_name = "has_#{name}?"
-      create_element_method(name, locator) do
-        define_method(method_name) do |*args|
-          element_exists?(locator, *args)
-        end
-      end
-    end
+    module Locator
+      private
 
-    def nonexistence_check(name, locator)
-      method_name = "has_no_#{name}?"
-      create_element_method(name, locator) do
-        define_method(method_name) do |*args|
-          element_does_not_exist?(locator, *args)
-        end
+      def reference_element(element, locator)
+        @browser.__send__(element, *locator).to_subtype
+      rescue NoMethodError
+        @browser.__send__(element, *locator)
       end
     end
-
-    def create_element_method(_name, _locator)
-      yield
-    end
   end
 end

data/lib/testable/errors.rb

@@ -1,7 +1,11 @@
 module Testable
   module Errors
     NoUrlForDefinition = Class.new(StandardError)
+    NoUrlMatchForDefinition = Class.new(StandardError)
+    NoUrlMatchPossible = Class.new(StandardError)
     NoTitleForDefinition = Class.new(StandardError)
     NoLocatorForDefinition = Class.new(StandardError)
+    PageNotValidatedError = Class.new(StandardError)
+    NoBlockForWhenReady = Class.new(StandardError)
   end
 end

data/lib/testable/extensions/dom_observer.js

@@ -0,0 +1,24 @@
+// WebDriver arguments
+var element = arguments[0];
+var delay = arguments[1] * 1000;
+var callback = arguments[2];
+
+var notStartedUpdating = function() {
+    return setTimeout(function() {
+        observer.disconnect();
+        callback(true);
+    }, 1000);
+};
+
+var startedUpdating = function() {
+    clearTimeout(notStartedUpdating);
+    observer.disconnect();
+    callback(false);
+};
+
+// Observer
+var observer = new MutationObserver(startedUpdating);
+var config = { attributes: true, childList: true, characterData: true, subtree: true };
+observer.observe(element, config);
+
+var notStartedUpdating = notStartedUpdating();

data/lib/testable/factory.rb

@@ -4,14 +4,18 @@ module Testable
     # exists, that context will be re-used.
     def on(definition, visit = false, &block)
       unless @context.is_a?(definition)
-        @context = definition.new
-        @context.view if visit
+        @context = definition.new(@browser) if @browser
+        @context = definition.new unless @browser
+        @context.visit if visit
       end
 
       yield @context if block
       @context
     end
 
+    alias on_page  on
+    alias while_on on
+
     # Creates a definition context for actions and establishes the
     # context for execution.
     def on_view(definition, &block)

data/lib/testable/interface.rb

@@ -1,22 +1,22 @@
-require "capybara/dsl"
 require "testable/situation"
-require "testable/element"
 
 module Testable
-  include Situation
   module Interface
     module Page
-      include Capybara::DSL
-
       module Attribute
         include Situation
-
         def url_is(url = nil)
           url_is_empty if url.nil? || url.empty?
           @url = url
         end
 
-        def title_is(title = nil)
+        def url_matches(pattern = nil)
+          url_match_is_empty if pattern.nil?
+          url_match_is_empty if pattern.is_a?(String) && pattern.empty?
+          @url_match = pattern
+        end
+
+        def title_is(title)
           title_is_empty if title.nil? || title.empty?
           @title = title
         end
@@ -25,48 +25,89 @@ module Testable
           @url
         end
 
+        def url_match_attribute
+          @url_match || url_attribute
+        end
+
         def title_attribute
           @title
         end
       end
 
-      def view
-        no_url_provided if (url.nil? || url == 'data:,') && url_attribute.nil?
-        visit(url_attribute)
+      def visit(url = nil)
+        no_url_provided if url.nil? && url_attribute.nil?
+        @browser.goto(url) unless url.nil?
+        @browser.goto(url_attribute) if url.nil?
+        self
       end
 
+      alias view        visit
+      alias navigate_to visit
+      alias goto        visit
+      alias perform     visit
+
       def url
-        current_url
+        @browser.url
       end
 
-      def url_attribute
-        self.class.url_attribute
+      alias page_url    url
+      alias current_url url
+
+      def title
+        @browser.title
       end
 
-      def title_attribute
-        self.class.title_attribute
+      alias page_title title
+
+      def markup
+        browser.html
       end
 
+      alias html markup
+
+      def text
+        browser.text
+      end
+
+      alias page_text text
+
+      def resize(width, height)
+        browser.window.resize_to(width, height)
+      end
+
+      alias resize_to resize
+
       def secure?
         !url.match(/^https/).nil?
       end
 
-      private
+      def url_match_attribute
+        value = self.class.url_match_attribute
+        return if value.nil?
+        value = Regexp.new(value) unless value.is_a?(Regexp)
+        value
+      end
 
-      def find_first(*locator)
-        find(*locator)
+      def has_correct_url?
+        if url_attribute.nil? && url_match_attribute.nil?
+          no_url_match_is_possible
+        end
+        !(url =~ url_match_attribute).nil?
       end
 
-      def find_all(*locator)
-        all(*locator)
+      alias displayed? has_correct_url?
+
+      def has_correct_title?
+        no_title_is_provided if title_attribute.nil?
+        !title.match(title_attribute).nil?
       end
 
-      def element_exists?(*locator)
-        has_selector?(*locator)
+      def url_attribute
+        self.class.url_attribute
       end
 
-      def element_does_not_exist?(*locator)
-        has_no_selector?(*locator)
+      def title_attribute
+        self.class.title_attribute
       end
     end
   end

data/lib/testable/ready.rb

@@ -0,0 +1,59 @@
+require "testable/situation"
+
+module Testable
+  module Ready
+    include Situation
+
+    module ClassMethods
+      def ready_validations
+        if superclass.respond_to?(:ready_validations)
+          superclass.ready_validations + _ready_validations
+        else
+          _ready_validations
+        end
+      end
+
+      def page_ready(&block)
+        _ready_validations << block
+      end
+
+      alias page_ready_when page_ready
+
+      def _ready_validations
+        @_ready_validations ||= []
+      end
+    end
+
+    attr_accessor :ready, :ready_error
+
+    def self.included(caller)
+      caller.extend(ClassMethods)
+    end
+
+    def when_ready(&_block)
+      already_marked_ready = ready
+
+      no_ready_check_possible unless block_given?
+
+      self.ready = ready?
+      not_ready_validation(ready_error || 'NO REASON PROVIDED') unless ready
+      yield self
+    ensure
+      self.ready = already_marked_ready
+    end
+
+    def ready?
+      self.ready_error = nil
+      return true if ready
+      ready_validations_pass?
+    end
+
+    def ready_validations_pass?
+      self.class.ready_validations.all? do |validation|
+        passed, message = instance_eval(&validation)
+        self.ready_error = message if message && !passed
+        passed
+      end
+    end
+  end
+end

data/lib/testable/situation.rb

@@ -11,6 +11,30 @@ module Testable
       raise Testable::Errors::NoUrlForDefinition
     end
 
+    def no_url_provided
+      puts "PROBLEM: no url provided.\n" \
+      "You called a '#{retrieve_method(caller)}' action but the " \
+      "definition '#{self.class}' does not have a url_is attribute.\n" \
+      "Either provide the url_is attribute or pass the url as an " \
+      "argument to the visit call.\n\n"
+      raise Testable::Errors::NoUrlForDefinition
+    end
+
+    def url_match_is_empty
+      puts "PROBLEM: url_matches attribute empty.\n" \
+      "The url_matches attribute is empty on the definition " \
+      "'#{retrieve_class(caller)}'.\n\n"
+      raise Testable::Errors::NoUrlMatchForDefinition
+    end
+
+    def no_url_match_is_possible
+      puts "PROBLEM: No url_is or url_matches attribute.\n" \
+      "You called a '#{retrieve_method(caller)}' action but the " \
+      "definition '#{self.class}' has no url_is attribute nor a " \
+      "url_matches attribute.\n\n"
+      raise Testable::Errors::NoUrlMatchPossible
+    end
+
     def title_is_empty
       puts "PROBLEM: title_is attribute empty.\n" \
       "The title_is attribute is empty on the definition " \
@@ -18,22 +42,37 @@ module Testable
       raise Testable::Errors::NoTitleForDefinition
     end
 
-    def no_url_provided
-      puts "PROBLEM: no url provided.\n" \
+    def no_title_is_provided
+      puts "PROBLEM: No title provided.\n" \
       "You called a '#{retrieve_method(caller)}' action but the " \
-      "definition '#{self.class}' does not have a url_is attribute.\n" \
-      "Either provide the url_is attribute or pass the url as an " \
-      "argument to the visit call.\n\n"
-      raise Testable::Errors::NoUrlForDefinition
+      "definition '#{self.class}' does not have a title_is attribute.\n\n"
+      raise Testable::Errors::NoTitleForDefinition
     end
 
-    def no_locator(name)
+    def no_locator(definition, identifier)
       puts "PROBLEM: No locator provided.\n" \
-      "You are using '#{name}' on '#{retrieve_class(caller)}'. " \
+      "You are using '#{identifier}' on '#{definition}'. " \
       "But there is no locator provided with it.\n\n"
       raise Testable::Errors::NoLocatorForDefinition
     end
 
+    def not_ready_validation(message)
+      puts "PROBLEM: A ready validation error was encountered.\n" \
+      "A ready validation failed to validate. The ready check was " \
+      "on the '#{self.class}' definition. " \
+      "The reason provided was:\n" \
+      "#{message}.\n\n"
+      raise Testable::Errors::PageNotValidatedError, message
+    end
+
+    def no_ready_check_possible
+      puts "PROBLEM: A when ready call has no action.\n" \
+      "You called a when_ready on a definition but did not provide " \
+      "any action for it. Add a block with logic that should be " \
+      "executed if the ready check passes.\n\n"
+      raise Testable::Errors::NoBlockForWhenReady
+    end
+
     def retrieve_class(caller)
       caller[1][/`.*'/][8..-3]
     end
@@ -41,5 +80,9 @@ module Testable
     def retrieve_method(caller)
       caller[0][/`.*'/][1..-2]
     end
+
+    def empty_locator(locator, values)
+      locator[0].nil? && values.empty? && !values[0].is_a?(Hash)
+    end
   end
 end

data/lib/testable/version.rb

@@ -1,18 +1,24 @@
 module Testable
-  VERSION = "0.2.0".freeze
-
   module_function
 
+  VERSION = "0.3.0".freeze
+
   def version
     """
 Testable v#{Testable::VERSION}
-Capybara: #{Gem.loaded_specs['capybara'].version}
-selenium-webdriver: #{Gem.loaded_specs['selenium-webdriver'].version}
+watir: #{gem_version('watir')}
+selenium-webdriver: #{gem_version('selenium-webdriver')}
     """
   end
 
   def dependencies
-    Gem.loaded_specs.values.map { |x| "#{x.name} #{x.version}\n" }
+    Gem.loaded_specs.values.map { |spec| "#{spec.name} #{spec.version}\n" }
        .uniq.sort.join(",").split(",")
   end
+
+  def gem_version(name)
+    Gem.loaded_specs[name].version
+  rescue NoMethodError
+    puts "No gem loaded for #{name}."
+  end
 end

data/lib/testable.rb

@@ -1,17 +1,43 @@
-require "capybara"
-require "selenium-webdriver"
-
 require "testable/version"
-require "testable/element"
+
+require "testable/ready"
 require "testable/factory"
+require "testable/element"
 require "testable/interface"
+require "testable/dom_update"
+require "testable/data_setter"
 
-module Testable
-  module_function
+require "watir"
+require "selenium-webdriver"
 
-  def included(caller)
+module Testable
+  def self.included(caller)
     caller.extend Testable::Element
     caller.extend Testable::Interface::Page::Attribute
+    caller.__send__ :include, Testable::Ready
+    caller.__send__ :include, Testable::DataSetter
     caller.__send__ :include, Testable::Interface::Page
+    caller.__send__ :include, Testable::Element::Locator
+  end
+
+  def initialize(browser = nil, &block)
+    @browser = Testable.browser unless Testable.browser.nil?
+    @browser = browser if Testable.browser.nil?
+    instance_eval(&block) if block
+  end
+
+  attr_accessor :browser
+
+  class << self
+    attr_accessor :browser
+
+    def set_browser(app = :chrome, *args)
+      @browser = Watir::Browser.new(app, *args)
+      Testable.browser = @browser
+    end
+
+    def quit_browser
+      @browser.quit
+    end
   end
 end

data/testable.gemspec

@@ -27,8 +27,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rubocop"
   spec.add_development_dependency "pry"
 
-  spec.add_runtime_dependency "capybara", [">= 2.10", "< 3.0"]
-  spec.add_runtime_dependency "selenium-webdriver", "~> 3.0"
+  spec.add_runtime_dependency "watir", "~> 6.0"
 
   spec.post_install_message = %{
 (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: testable
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Jeff Nyman
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-11-12 00:00:00.000000000 Z
+date: 2016-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -81,39 +81,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: capybara
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.10'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.10'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: selenium-webdriver
+  name: watir
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '6.0'
 description: Provides a semantic DSL to construct fluent interfaces for test execution
   logic.
 email:
@@ -126,7 +106,6 @@ files:
 - ".hound.yml"
 - ".rspec"
 - ".rubocop.yml"
-- ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -134,11 +113,16 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- circle.yml
 - lib/testable.rb
+- lib/testable/data_setter.rb
+- lib/testable/dom_update.rb
 - lib/testable/element.rb
 - lib/testable/errors.rb
+- lib/testable/extensions/dom_observer.js
 - lib/testable/factory.rb
 - lib/testable/interface.rb
+- lib/testable/ready.rb
 - lib/testable/situation.rb
 - lib/testable/version.rb
 - testable.gemspec
@@ -147,7 +131,7 @@ licenses:
 - MIT
 metadata: {}
 post_install_message: "\n(::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::)\n
-  \ Testable 0.2.0 has been installed.\n(::) (::) (::) (::) (::) (::) (::) (::) (::)
+  \ Testable 0.3.0 has been installed.\n(::) (::) (::) (::) (::) (::) (::) (::) (::)
   (::) (::) (::)\n  "
 rdoc_options: []
 require_paths:

data/.travis.yml

@@ -1,5 +0,0 @@
-sudo: false
-language: ruby
-rvm:
-  - 2.3.1
-before_install: gem install bundler -v 1.13.6