symbiont 0.10.0 → 0.11.0

data/spec/fixtures/element_definitions.rb

@@ -1,71 +0,0 @@
-shared_examples_for 'element generator for' do |elements|
-  elements.each do |element|
-
-    context "#{element} on the watir-webdriver platform" do
-      it "will locate a specific #{element} with a single locator" do
-        expect(watir_browser).to receive(element).with(id: element).and_return(watir_element)
-        expect(watir_definition.send "#{element}").to eq(watir_element)
-      end
-
-      it "will locate a specific #{element} with a proc" do
-        expect(watir_browser).to receive(element).with(id: element).and_return(watir_element)
-        expect(watir_definition.send "#{element}_proc").to eq(watir_element)
-      end
-
-      it "will locate a specific #{element} with a lambda" do
-        expect(watir_browser).to receive(element).with(id: element).and_return(watir_element)
-        expect(watir_definition.send "#{element}_lambda").to eq(watir_element)
-      end
-
-      it "will locate a specific #{element} with a block" do
-        expect(watir_browser).to receive(element).with(id: element).and_return(watir_element)
-        expect(watir_definition.send "#{element}_block", element).to eq(watir_element)
-      end
-
-      it "will locate a specific #{element} with a block and argument" do
-        expect(watir_browser).to receive(element).with(id: element).and_return(watir_element)
-        expect(watir_definition.send "#{element}_block_arg", element).to eq(watir_element)
-      end
-    end
-
-  end
-end
-
-shared_examples_for 'element set generator for' do |elements|
-  elements.each do |element|
-    it "will set a value on a specific #{element} with a single locator" do
-      expect(watir_browser).to receive(element).with(id: element).and_return(watir_element)
-      expect(watir_element).to receive(:set).with('value')
-      watir_definition.send "#{element}=", 'value'
-    end
-
-    it "will attempt to send keypresses if a #{element} cannot be set" do
-      expect(watir_browser).to receive(element).with(id: element).and_return(watir_element)
-      allow(watir_element).to receive(:respond_to?).with(:set).and_return(false)
-      expect(watir_element).to receive(:send_keys).with('value')
-      watir_definition.send "#{element}=", 'value'
-    end
-
-    it "will set a value on a specific #{element} with a proc" do
-      expect(watir_browser).to receive(element).with(id: element).and_return(watir_element)
-      expect(watir_element).to receive(:set).with('value')
-      watir_definition.send "#{element}_proc=", 'value'
-    end
-  end
-end
-
-shared_examples_for 'element select generator for' do |elements|
-  elements.each do |element|
-    it "will set a value on a specific #{element} with a single locator" do
-      expect(watir_browser).to receive(element).with(id: element).and_return(watir_element)
-      expect(watir_element).to receive(:select).with('value')
-      watir_definition.send "#{element}=", 'value'
-    end
-
-    it "will set a value on a specific #{element} with a proc" do
-      expect(watir_browser).to receive(element).with(id: element).and_return(watir_element)
-      expect(watir_element).to receive(:select).with('value')
-      watir_definition.send "#{element}_proc=", 'value'
-    end
-  end
-end

data/spec/fixtures/mock_data.yml

@@ -1,3 +0,0 @@
-valid:
-  bank: BankCo
-  name: Jeff

data/spec/fixtures/mock_drivers.rb

@@ -1,8 +0,0 @@
-require 'watir-webdriver'
-
-def mock_browser_for_watir
-  watir_browser = double('watir')
-  allow(watir_browser).to receive(:is_a?).with(Watir::Browser).and_return(true)
-  allow(watir_browser).to receive(:is_a?).with(Selenium::WebDriver::Driver).and_return(false)
-  watir_browser
-end

data/spec/fixtures/page_definitions.rb

@@ -1,36 +0,0 @@
-class PageWithMissingAssertions
-  attach Symbiont
-end
-
-class TestFactory
-  include Symbiont::Factory
-  attr_accessor :browser
-  attr_accessor :page
-end
-
-class ValidPageNewContext
-  attach Symbiont
-end
-
-class ValidPage
-  attach Symbiont
-  
-  url_is 'http://localhost:9292'
-  url_matches /:\d{4}/
-  title_is 'Dialogic'
-
-  %w(text_field button file_field textarea select_list checkbox).each do |element|
-    send element, :"#{element}", id: element
-
-    send element, :"#{element}_proc", proc { browser.send(element, id: element) }
-    send element, :"#{element}_lambda", -> { browser.send(element, id: element) }
-
-    send element, :"#{element}_block" do
-      browser.send(element, id: element)
-    end
-
-    send element, :"#{element}_block_arg" do |id|
-      browser.send(element, id: id)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,49 +0,0 @@
-require 'simplecov'
-require 'coveralls'
-
-Coveralls.wear!
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-]
-
-SimpleCov.start do
-  add_filter '/spec'
-  coverage_dir "#{SimpleCov.root}/spec/reports/coverage"
-  minimum_coverage 90
-  maximum_coverage_drop 5
-end
-
-require 'symbiont'
-
-RSpec.configure do |config|
-  original_stderr = $stderr
-  original_stdout = $stdout
-  config.before(:all) do
-    $stderr = File.new(File.join(File.dirname(__FILE__), 'reports/symbiont-output.txt'), 'w')
-    $stdout = File.new(File.join(File.dirname(__FILE__), 'reports/symbiont-output.txt'), 'w')
-  end
-  config.after(:all) do
-    $stderr = original_stderr
-    $stdout = original_stdout
-  end
-
-  config.alias_it_should_behave_like_to :provides_an, 'when providing an'
-
-  shared_context :page do
-    let(:watir_browser)        { mock_browser_for_watir }
-    let(:watir_definition)     { ValidPage.new(watir_browser) }
-
-    let(:empty_definition)     { PageWithMissingAssertions.new(watir_browser) }
-    let(:no_driver_definition) { ValidPage.new(:unknown) }
-  end
-
-  shared_context :element do
-    let(:watir_element) { double('element') }
-  end
-end
-
-Dir['spec/fixtures/**/*.rb'].each do |file|
-  require file.sub(/spec\//, '')
-end

data/spec/symbiont/assertion_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::Assertion do
-  context 'a definition with valid assertions' do
-    it 'will allow a url to be asserted' do
-      expect {
-        class PageWithUrl
-          attach Symbiont
-          url_is 'http://localhost:9292'
-        end
-      }.not_to raise_error
-    end
-
-    it 'will allow a url match pattern to be asserted' do
-      expect {
-        class PageWithUrlMatches
-          attach Symbiont
-          url_matches /localhost/
-        end
-      }.not_to raise_error
-    end
-
-    it 'will allow a title to be asserted' do
-      expect {
-        class PageWithTitle
-          attach Symbiont
-          title_is 'Dialogic'
-        end
-      }.not_to raise_error
-    end
-  end
-
-  context 'a definition with missing assertion values' do
-    it 'will indicate a missing url_is assertion value' do
-      expect {
-        class PageWithMissingUrl
-          attach Symbiont
-          url_is
-        end
-      }.to raise_error Symbiont::Errors::NoUrlForDefinition
-    end
-
-    it 'will indicate an empty url_is assertion value' do
-      expect {
-        class PageWithEmptyUrl
-          attach Symbiont
-          url_is ''
-        end
-      }.to raise_error Symbiont::Errors::NoUrlForDefinition
-    end
-
-    it 'will indicate a missing url_matches assertion value' do
-      expect {
-        class PageWithMissingUrlMatch
-          attach Symbiont
-          url_matches
-        end
-      }.to raise_error Symbiont::Errors::NoUrlMatchForDefinition
-    end
-
-    it 'will indicate an empty url_matches assertion value' do
-      expect {
-        class PageWithEmptyUrlMatch
-          attach Symbiont
-          url_matches ''
-        end
-      }.to raise_error Symbiont::Errors::NoUrlMatchForDefinition
-    end
-
-    it 'will indicate a missing title_is assertion value' do
-      expect {
-        class PageWithMissingTitle
-          attach Symbiont
-          title_is
-        end
-      }.to raise_error Symbiont::Errors::NoTitleForDefinition
-    end
-
-    it 'will indicate an empty title_is assertion value' do
-      expect {
-        class PageWithEmptyTitle
-          attach Symbiont
-          title_is ''
-        end
-      }.to raise_error Symbiont::Errors::NoTitleForDefinition
-    end
-  end
-end

data/spec/symbiont/data_builder_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::DataBuilder do
-  include_context :page
-
-  context 'when configuring the data path' do
-    it 'will default to a directory named data' do
-      expect(Symbiont::DataBuilder.data_path).to eq('data')
-    end
-
-    it 'will store a data source directory' do
-      Symbiont::DataBuilder.data_path = 'config/data'
-      expect(Symbiont::DataBuilder.data_path).to eq('config/data')
-    end
-  end
-
-  context 'when reading data files' do
-    it 'will read files from the data path directory' do
-      Symbiont::DataBuilder.data_path = 'config/data'
-      expect(YAML).to receive(:load_file).with('config/data/test_data_file').and_return({})
-      Symbiont::DataBuilder.load('test_data_file')
-    end
-
-    it 'will load the correct data file from the default' do
-      Symbiont::DataBuilder.data_path = 'spec/fixtures'
-      data = watir_definition.data_about 'valid'
-      expect(data.keys.sort).to eq(['bank','name'])
-    end
-  end
-
-  context 'when provided a file' do
-    it 'will load the correct data file and retrieve data' do
-      Symbiont::DataBuilder.data_path = 'spec/fixtures'
-      data = watir_definition.data_about 'mock_data/valid'
-      expect(data.keys.sort).to eq(['bank','name'])
-    end
-  end
-end

data/spec/symbiont/data_setter_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::DataSetter do
-  include_context :page
-  include_context :element
-
-  it 'will attempt to utilize data' do
-    expect(watir_element).to receive(:visible?).and_return(true)
-    expect(watir_element).to receive(:enabled?).and_return(true)
-    expect(watir_browser).to receive(:text_field).with({:id => 'text_field'}).exactly(2).times.and_return(watir_element)
-    watir_definition.using(:text_field => 'works')
-  end
-
-  it 'will allow methods to be chained' do
-    expect('testing'.call_method_chain("reverse.capitalize")).to eq('Gnitset')
-    expect('testing'.call_method_chain("start_with?", 't')).to be_truthy
-  end
-
-end

data/spec/symbiont/driver_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-describe 'Symbiont Driver' do
-  include_context :page
-
-  context 'a symbiont driver is requested' do
-    it 'will provide the default browser' do
-      allow(Watir::Browser).to receive(:new).and_return(Symbiont.driver)
-      symbiont_browser
-    end
-  end
-end
-
-describe 'Page Definitions' do
-  include_context :page
-
-  context 'a definition using watir-webdriver' do
-    context 'with a url_is assertion' do
-      it 'will call the driver navigation method when viewed' do
-        expect(watir_browser).to receive(:goto).twice
-        expect { watir_definition.view }.not_to raise_error
-        watir_definition.view
-      end
-    end
-
-    context 'with a url_matches assertion' do
-      it 'will verify a url if the url_matches assertion has been set' do
-        expect(watir_browser).to receive(:url).twice.and_return('http://localhost:9292')
-        expect { watir_definition.has_correct_url? }.not_to raise_error
-        expect(watir_definition.has_correct_url?).to be_truthy
-      end
-
-      it 'will not verify a url if the url does not match the url_matches assertion' do
-        expect(watir_browser).to receive(:url).and_return('http://127.0.0.1')
-        expect(watir_definition.has_correct_url?).to be_falsey
-      end
-    end
-
-    context 'with a title_is assertion' do
-      it 'will verify a title if the title_is assertion has been set' do
-        expect(watir_browser).to receive(:title).twice.and_return 'Dialogic'
-        expect { watir_definition.has_correct_title? }.not_to raise_error
-        expect(watir_definition.has_correct_title?).to be_truthy
-      end
-
-      it 'will not verify a title if the title does not match the title_is assertion' do
-        expect(watir_browser).to receive(:title).and_return('Page Title')
-        expect(watir_definition.has_correct_title?).to be_falsey
-      end
-    end
-  end
-end

data/spec/symbiont/element_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::Element do
-  include_context :page
-  include_context :element
-
-  provides_an 'element generator for', %w{text_field button}
-  provides_an 'element set generator for', %w{text_field file_field textarea}
-  provides_an 'element select generator for', %w{select_list}
-end

data/spec/symbiont/factory_spec.rb

@@ -1,117 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::Factory do
-  before(:each) do
-    @factory = TestFactory.new
-    @factory.browser = mock_browser_for_watir
-  end
-
-  it 'will create a new definition and view it, using on_view' do
-    expect(@factory.browser).to receive(:goto)
-    @factory.on_view(ValidPage)
-  end
-
-  it 'will create a new definition and view it, using on_view and a block' do
-    expect(@factory.browser).to receive(:goto)
-    @factory.on_view ValidPage do |page|
-      expect(page).to be_instance_of ValidPage
-    end
-  end
-
-  it 'will create a new definition, using on and a block with a parameter' do
-    expect(@factory.browser).not_to receive(:goto)
-    @factory.on ValidPage do |page|
-      expect(page).to be_instance_of ValidPage
-    end
-  end
-
-  it 'will create a new definition, using on and a block without a parameter' do
-    expect(@factory.browser).not_to receive(:goto)
-    @factory.on ValidPage do
-      expect(@factory.page).to be_instance_of ValidPage
-    end
-  end
-
-  it 'will use an existing object reference with on' do
-    expect(@factory.browser).to receive(:goto)
-    obj1 = @factory.on_view ValidPage
-    obj2 = @factory.on ValidPage
-    expect(obj1).to be(obj2)
-  end
-
-  it 'will not use an existing object reference with on_new' do
-    expect(@factory.browser).to receive(:goto)
-    obj1 = @factory.on_view ValidPage
-    obj2 = @factory.on_new ValidPage
-    expect(obj1).not_to be(obj2)
-  end
-
-  it 'will create a new definition, using on_set' do
-    expect(@factory.browser).not_to receive(:goto)
-    @factory.on_set ValidPage do |page|
-      expect(page).to be_instance_of ValidPage
-    end
-  end
-
-  it 'will set a reference to be used outside the factory' do
-    page = @factory.on ValidPage
-    current = @factory.instance_variable_get '@page'
-    expect(current).to be(page)
-
-    current = @factory.instance_variable_get '@model'
-    expect(current).to be(page)
-  end
-
-  it 'will use an existing object reference with on_set' do
-    expect(@factory.browser).to receive(:goto)
-    obj1 = @factory.on_view ValidPage
-    obj2 = @factory.on_set ValidPage
-    expect(obj1).to be(obj2)
-  end
-
-  it 'will use an existing context using on after using on_set' do
-    @factory.on_set ValidPage do |page|
-      @obj1 = page  # obj1 is CONTEXT, ACTIVE
-    end
-
-    @factory.on ValidPageNewContext do |page|
-      @obj2 = page  # obj2 is ACTIVE
-    end
-
-    @factory.on ValidPage do |page|
-      @obj3 = page  # obj1 CONTEXT is still set
-    end
-
-    expect(@obj1).not_to be(@obj2)
-    expect(@obj1).to be(@obj3)
-  end
-
-  it 'will use an existing context using on_new of a different class after using on_set' do
-    @factory.on_set ValidPage do |page|
-      @obj1 = page  # obj1 is CONTEXT, ACTIVE
-    end
-
-    @factory.on_new ValidPageNewContext do |page|
-      @obj2 = page  # ACTIVE nil, obj1 no longer ACTIVE, but is CONTEXT
-    end
-
-    @factory.on ValidPage do |page|
-      @obj3 = page  # CONTEXT is set to obj1
-    end
-
-    expect(@obj1).not_to be(@obj2)
-    expect(@obj1).to be (@obj3)
-  end
-
-  it 'will clear existing context using on_new after using on_set' do
-    @factory.on_set ValidPage do |page|
-      @obj1 = page   # obj1 is CONTEXT, ACTIVE
-    end
-
-    @factory.on_new ValidPage do |page|
-      @obj2 = page   # ACTIVE nil; since page is same, CONTEXT is nil
-    end
-
-    expect(@obj1).not_to be(@obj2)
-  end
-end

data/spec/symbiont/page_spec.rb

@@ -1,177 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::Page do
-  include_context :page
-  include_context :element
-  
-  context 'a page definition being used - url' do
-    it 'will establish no default url' do
-      expect(empty_definition.asserted_url).to be_nil
-    end
-
-    it 'will establish a page url with the url_is assertion' do
-      expect(watir_definition).to respond_to :asserted_url
-      expect(watir_definition.asserted_url).to eq('http://localhost:9292')
-    end
-
-    it 'will not view a page if the url_is assertion has not been set' do
-      expect { empty_definition.view }.to raise_error Symbiont::Errors::NoUrlForDefinition
-    end
-  end
-
-  context 'a page definition being used - url match' do    
-    it 'will establish no default url matcher' do
-      expect(empty_definition.url_match).to be_nil
-    end
-
-    it 'will establish a url matcher with the url_matches assertion' do
-      expect(watir_definition).to respond_to :url_match
-      expect(watir_definition.url_match).to eq(/:\d{4}/)
-    end
-
-    it 'will not verify a url if the url_matches assertion has not been set' do
-      expect { empty_definition.has_correct_url? }.to raise_error Symbiont::Errors::NoUrlMatchForDefinition
-    end
-  end
-
-  context 'a page definition being used - title' do
-    it 'will establish no default title' do
-      expect(empty_definition.asserted_title).to be_nil
-    end
-
-    it 'will establish a page title with the title_is assertion' do
-      expect(watir_definition).to respond_to :asserted_title
-      expect(watir_definition.asserted_title).to eq('Dialogic')
-    end
-
-    it 'will not verify a title if the title_is assertion has not been set' do
-      expect { empty_definition.has_correct_title? }.to raise_error Symbiont::Errors::NoTitleForDefinition
-    end
-  end
-
-  context 'an instance of a page definition' do
-    it 'will be able to verify a page' do
-      expect(watir_browser).to receive(:title).and_return('Dialogic')
-      expect(watir_browser).to receive(:url).and_return('http://localhost:9292')
-      watir_definition.verified?
-    end
-
-    it 'will be able to get the active url' do
-      expect(watir_browser).to receive(:url).exactly(3).times.and_return('http://localhost:9292')
-      expect(watir_definition).to respond_to :url
-      expect(watir_definition.current_url).to eq('http://localhost:9292')
-      expect(watir_definition.page_url).to eq('http://localhost:9292')
-      expect(watir_definition.url).to eq('http://localhost:9292')
-    end
-
-    it 'will be able to get the markup of a page' do
-      expect(watir_browser).to receive(:html).exactly(3).times.and_return('<h1>Page Section</h1>')
-      expect(watir_definition.markup).to eq('<h1>Page Section</h1>')
-      expect(watir_definition.html).to eq('<h1>Page Section</h1>')
-      expect(watir_definition.html).to include('<h1>Page')
-    end
-
-    it 'will be able to get the text of a page' do
-      expect(watir_browser).to receive(:text).exactly(3).times.and_return('some page text')
-      expect(watir_definition.page_text).to eq('some page text')
-      expect(watir_definition.text).to eq('some page text')
-      expect(watir_definition.text).to include('page text')
-    end
-
-    it 'will be able to get the title of a page' do
-      expect(watir_browser).to receive(:title).exactly(3).times.and_return('Page Title')
-      expect(watir_definition.page_title).to eq('Page Title')
-      expect(watir_definition.title).to eq('Page Title')
-      expect(watir_definition.title).to include('Title')
-    end
-
-    it 'will navigate to a specific url' do
-      expect(watir_browser).to receive(:goto).exactly(3).times.with('http://localhost:9292')
-      watir_definition.visit('http://localhost:9292')
-      watir_definition.navigate_to('http://localhost:9292')
-      watir_definition.goto('http://localhost:9292')
-    end
-
-    it 'will be able to get a screenshot of the current page' do
-      expect(watir_browser).to receive(:wd).twice.and_return(watir_browser)
-      expect(watir_browser).to receive(:save_screenshot).twice
-      watir_definition.screenshot('testing.png')
-      watir_definition.save_screenshot('testing.png')
-    end
-
-    it 'will run a script against the browser' do
-      expect(watir_browser).to receive(:execute_script).twice.and_return('input')
-      expect(watir_definition.run_script('return document.activeElement')).to eq('input')
-      expect(watir_definition.execute_script('return document.activeElement')).to eq('input')
-    end
-
-    it 'will run a script, with arguments, against the browser' do
-      expect(watir_browser).to receive(:execute_script).with('return arguments[0].innerHTML', watir_element).and_return('testing')
-      expect(watir_definition.execute_script('return arguments[0].innerHTML', watir_element)).to eq('testing')
-    end
-
-    it 'will be able to get a cookie value' do
-      cookie = [{:name => 'test', :value => 'cookie', :path => '/'}]
-      expect(watir_browser).to receive(:cookies).and_return(cookie)
-      expect(watir_definition.get_cookie('test')).to eq('cookie')
-    end
-
-    it 'will return nothing if a cookie value is not found' do
-      cookie = [{:name => 'test', :value =>'cookie', :path => '/'}]
-      expect(watir_browser).to receive(:cookies).and_return(nil)
-      expect(watir_definition.get_cookie('testing')).to be_nil
-    end
-
-    it 'will be able to clear all cookies from the browser' do
-      expect(watir_browser).to receive(:cookies).twice.and_return(watir_browser)
-      expect(watir_browser).to receive(:clear).twice
-      watir_definition.remove_cookies
-      watir_definition.clear_cookies
-    end
-
-    it 'will be able to refresh the page' do
-      expect(watir_browser).to receive(:refresh).twice.and_return(watir_browser)
-      watir_definition.refresh_page
-      watir_definition.refresh
-    end
-
-    it 'will be able to handle JavaScript alert dialogs' do
-      expect(watir_browser).to receive(:alert).exactly(3).times.and_return(watir_browser)
-      expect(watir_browser).to receive(:exists?).and_return(true)
-      expect(watir_browser).to receive(:text)
-      expect(watir_browser).to receive(:ok)
-      watir_definition.will_alert {}
-    end
-
-    it 'will be able to handle JavaScript confirmation dialogs' do
-      expect(watir_browser).to receive(:alert).exactly(3).times.and_return(watir_browser)
-      expect(watir_browser).to receive(:exists?).and_return(true)
-      expect(watir_browser).to receive(:text)
-      expect(watir_browser).to receive(:ok)
-      watir_definition.will_confirm(true) {}
-    end
-
-    it 'will be able to handle JavaScript prompt dialogs' do
-      expect(watir_browser).to receive(:wd).twice.and_return(watir_browser)
-      expect(watir_browser).to receive(:execute_script).twice
-      watir_definition.will_prompt('Testing') {}
-    end
-
-    it 'will be able to attach to a window by using the title' do
-      allow(watir_browser).to receive(:window).with(:title => /Display\ Results/).and_return(watir_browser)
-      allow(watir_browser).to receive(:use)
-      watir_definition.within_window(title: 'Display Results')
-    end
-
-    it 'will be able to attach to a window by using the url' do
-      allow(watir_browser).to receive(:window).with(:url => /results\.html/).and_return(watir_browser)
-      allow(watir_browser).to receive(:use)
-      watir_definition.within_window(url: 'results.html')
-    end
-
-    it 'will be able to convert a modal popup to a window' do
-      allow(watir_browser).to receive(:execute_script)
-      watir_definition.within_modal {}
-    end
-  end
-end