symbiont 0.1.9 → 0.2.0

data/spec/symbiont/evaluators_spec.rb

@@ -1,75 +1,95 @@
-require 'spec_helper'
-
-describe Symbiont::Enclosers do
-  let(:watir_browser) { mock_browser_for_watir }
-  let(:watir_definition) { DefinitionTest.new(watir_browser) }
-  
-  describe "browser-level actions" do
-    context "a definition using watir-webdriver" do
-      it "should visit a page" do
-        watir_browser.should_receive(:goto).with("http://localhost:4567")
-        watir_definition.visit("http://localhost:4567")
-      end
-      
-      it "should get the active url" do
-        watir_browser.should_receive(:url).and_return("http://localhost:4567")
-        watir_definition.url.should == "http://localhost:4567"
-      end
-      
-      it "should get a screenshot" do
-        watir_browser.should_receive(:wd).and_return(watir_browser)
-        watir_browser.should_receive(:save_screenshot)
-        watir_definition.screenshot("testing.png")
-      end
-      
-      it "should run a script against the browser" do
-        watir_browser.should_receive(:execute_script).twice.and_return("input")
-        watir_definition.run_script("return document.activeElement").should == "input"
-        watir_definition.execute_script("return document.activeElement").should == "input"
-      end
-    end
-  end
-  
-  describe "page-level actions" do
-    context "a definition using watir-webdriver" do
-      it "should return all the text on a page" do
-        watir_browser.should_receive(:text).and_return("page text")
-        watir_definition.text.should == "page text"
-      end
-      
-      it "should return all the markup on a page" do
-        watir_browser.should_receive(:html).twice.and_return("<h1>Page Title</h1>")
-        watir_definition.markup.should == "<h1>Page Title</h1>"
-        watir_definition.html.should == "<h1>Page Title</h1>"
-      end
-      
-      it "should return the title of a page" do
-        watir_browser.should_receive(:title).and_return("Page Title")
-        watir_definition.title.should == "Page Title"
-      end
-      
-      it "should return the web object that has focus" do
-        watir_browser.should_receive(:execute_script).and_return(watir_browser)
-        watir_browser.should_receive(:tag_name).twice.and_return(:input)
-        watir_browser.should_receive(:type).and_return(:submit)
-        watir_definition.focus.class.should == Symbiont::WebObjects::Button
-      end
-      
-      it "should wait for jquery pending requests to finish" do
-        watir_browser.should_receive(:execute_script).with('return jQuery.active').and_return(0)
-        watir_definition.wait_for_pending_requests
-      end
-      
-      it "should return an exception if pending requests did not finish" do
-        watir_browser.should_receive(:execute_script).with('return jQuery.active')
-        watir_browser.should_receive(:execute_script).with('return jQuery.active').and_return(1)
-        expect { watir_definition.wait_for_pending_requests(1) }.to raise_error
-      end
-
-      it "should be able to go back to a previous page" do
-        watir_browser.should_receive(:back)
-        watir_definition.back
-      end
-    end
-  end
-end
+require "spec_helper"
+
+describe Symbiont::Evaluators do
+  let(:watir_browser)    { mock_browser_for_watir }
+  let(:watir_definition) { DefinitionTest.new(watir_browser) }
+
+  describe "browser-level actions" do
+    context "a definition using watir-webdriver" do
+      it "should visit a page" do
+        watir_browser.should_receive(:goto).twice.with("http://localhost:9292")
+        watir_definition.visit("http://localhost:9292")
+        watir_definition.navigate_to("http://localhost:9292")
+      end
+
+      it "should get the active url" do
+        watir_browser.should_receive(:url).twice.and_return("http://localhost:9292")
+        watir_definition.url.should == "http://localhost:9292"
+        watir_definition.current_url.should == "http://localhost:9292"
+      end
+
+      it "should get a screenshot" do
+        watir_browser.should_receive(:wd).twice.and_return(watir_browser)
+        watir_browser.should_receive(:save_screenshot).twice
+        watir_definition.screenshot("testing.png")
+        watir_definition.save_screenshot("testing.png")
+      end
+
+      it "should run a script against the browser" do
+        watir_browser.should_receive(:execute_script).twice.and_return("input")
+        watir_definition.run_script("return document.activeElement").should == "input"
+        watir_definition.execute_script("return document.activeElement").should == "input"
+      end
+
+      it "should be able to go back to a previous page" do
+        watir_browser.should_receive(:back)
+        watir_definition.back
+      end
+
+      it "should be able to go forward to an already visited page" do
+        watir_browser.should_receive(:forward)
+        watir_definition.forward
+      end
+
+      it "should be able to refresh the page contents" do
+        watir_browser.should_receive(:refresh)
+        watir_definition.refresh
+      end
+
+      it "should be able to clear all of the cookies from the browser" do
+        watir_browser.should_receive(:cookies).twice.and_return(watir_browser)
+        watir_browser.should_receive(:clear).twice
+        watir_definition.remove_cookies
+        watir_definition.clear_cookies
+      end
+    end
+  end
+
+  describe "page-level actions" do
+    context "a definition using watir-webdriver" do
+      it "should return all the text on a page" do
+        watir_browser.should_receive(:text).and_return("page text")
+        watir_definition.text.should == "page text"
+      end
+
+      it "should return all the markup on a page" do
+        watir_browser.should_receive(:html).twice.and_return("<h1>Page Title</h1>")
+        watir_definition.markup.should == "<h1>Page Title</h1>"
+        watir_definition.html.should == "<h1>Page Title</h1>"
+      end
+
+      it "should return the title of a page" do
+        watir_browser.should_receive(:title).and_return("Page Title")
+        watir_definition.title.should == "Page Title"
+      end
+
+      it "should return the web object that has focus" do
+        watir_browser.should_receive(:execute_script).and_return(watir_browser)
+        watir_browser.should_receive(:tag_name).twice.and_return(:input)
+        watir_browser.should_receive(:type).and_return(:submit)
+        watir_definition.focus.class.should == Symbiont::WebObjects::Button
+      end
+
+      it "should wait for jquery pending requests to finish" do
+        watir_browser.should_receive(:execute_script).with('return jQuery.active').and_return(0)
+        watir_definition.wait_for_pending_requests
+      end
+
+      it "should return an exception if pending requests did not finish" do
+        watir_browser.should_receive(:execute_script).with('return jQuery.active')
+        watir_browser.should_receive(:execute_script).with('return jQuery.active').and_return(1)
+        expect { watir_definition.wait_for_pending_requests(1) }.to raise_error
+      end
+    end
+  end
+end

data/spec/symbiont/factory_spec.rb

@@ -1,122 +1,174 @@
-require 'spec_helper'
-require 'symbiont/factory'
-
-class TestFactory
-  include Symbiont::Factory
-  
-  attr_accessor :browser
-  attr_accessor :active
-end
-
-class TestFactorySecond
-  include Symbiont
-end
-
-class TestFactoryThird
-  include Symbiont
-end
-
-describe Symbiont::Factory do
-  #let(:watir_browser) { mock_browser_for_watir }
-  #let(:factory) { TestFactory.new(watir_browser) }
-  
-  before(:each) do
-    @factory = TestFactory.new
-    @factory.browser = mock_browser_for_watir
-  end
-  
-  it "should create a new definition object, using on" do
-    @factory.on DefinitionTest do |page|
-      page.should be_instance_of DefinitionTest
-    end
-  end
-  
-  it "should create a new definition object, using during" do
-    @factory.during DefinitionTest do |page|
-      page.should be_instance_of DefinitionTest
-    end
-  end
-  
-  it "should create a new definition object and view it, using on_view" do
-    @factory.browser.should_receive(:goto).twice
-    @factory.on_view DefinitionTest do |page|
-      page.should be_instance_of DefinitionTest
-    end
-  end
-  
-  it "should create a new definition object and view it, using start_activity" do
-    @factory.browser.should_receive(:goto).twice
-    @factory.start_activity DefinitionTest do |page|
-      page.should be_instance_of DefinitionTest
-    end
-  end
-  
-  it "should set a reference to be used outside the factory" do
-    active = @factory.on DefinitionTest
-    current = @factory.instance_variable_get "@active"
-    current.should === active
-  end
-  
-  it "should use an existing definition when that definition is already active" do
-    @factory.instance_variable_set "@active", TestFactorySecond.new(@factory.browser)
-    @factory.on(TestFactorySecond) do |page|
-      page.should be_instance_of TestFactorySecond
-    end
-  end
-  
-  it "should not execute block if definition is not the active definition" do
-    @factory.instance_variable_set "@active", TestFactorySecond.new(@factory.browser)
-    @factory.on(TestFactoryThird) do |page|
-      page.should_not be_instance_of TestFactorySecond
-      page.should be_instance_of TestFactoryThird
-    end
-  end
-  
-  it "should store a workflow path" do
-    workflow = ['stage1', 'stage2', 'stage3']
-    Symbiont::Factory.workflow = {default: workflow}
-    Symbiont::Factory.symbiont_workflow[:default].should == workflow
-  end
-  
-  it "should be unable to work without a default worfklow path" do
-    expect { Symbiont::Factory.workflow = {another: []} }.to raise_error
-  end
-  
-  it "should start a workflow path by using the default path" do
-    paths = [[TestFactory, :first_action], [TestFactorySecond, :second_action]]
-    Symbiont::Factory.workflow = {:default => paths}
-    mock_page = double("mock_page")
-    TestFactory.should_receive(:new).and_return(mock_page)
-    mock_page.should_receive(:first_action)
-    @factory.start_workflow(TestFactorySecond).class.should == TestFactorySecond
-  end
-  
-  it "should not start a workflow when there is no proper path" do
-    Symbiont::Factory.workflow = {:default => ['default'], :standard => ['standard']}
-    expect { @factory.start_workflow(TestFactory, :using => :invalid_path) }.to raise_error
-  end
-  
-  it "should not use a workflow when an action is not specified" do
-    Symbiont::Factory.workflow = {:default => [[TestFactory, :action_1], [TestFactorySecond, :action_2]]}
-    mock_page = double("mock_page")
-    TestFactory.should_receive(:new).and_return(mock_page)
-    mock_page.should_receive(:respond_to?).with(:action_1).and_return(false)
-    expect { @factory.start_workflow(TestFactorySecond) }.to raise_error
-  end
-  
-  it "should be able to continue along a workflow" do
-    Symbiont::Factory.workflow = {
-      :default => [[TestFactory, :action_1],
-                   [TestFactorySecond, :action_2],
-                   [TestFactoryThird, :action_3]]
-    }
-    mock_page = double("mock_page")
-    TestFactorySecond.should_receive(:new).and_return(mock_page)
-    mock_page.should_receive(:respond_to?).with(:action_2).and_return(true)
-    mock_page.should_receive(:action_2)
-    @factory.active = TestFactory.new()
-    TestFactory.should_not_receive(:new)
-    @factory.continue_workflow(TestFactoryThird).class.should == TestFactoryThird
-  end
-  
-end
+require 'spec_helper'
+require 'symbiont/factory'
+
+module AppModule
+  class TestDefinitionInModule
+    include Symbiont
+    url_is "http://localhost:9292"
+  end
+end
+
+class TestFactory
+  include Symbiont::Factory
+
+  attr_accessor :browser
+  attr_accessor :active
+end
+
+class TestFactoryPage
+  include Symbiont
+
+  url_is "http://localhost:9292"
+end
+
+class TestFactoryWithURL
+  include Symbiont
+
+  url_is "http://localhost:9292"
+end
+
+class TestFactorySecond
+  include Symbiont
+end
+
+class TestFactoryThird
+  include Symbiont
+end
+
+describe Symbiont::Factory do
+  before(:each) do
+    @factory = TestFactory.new
+    @factory.browser = mock_browser_for_watir
+  end
+
+  it "should create a new definition object, using on" do
+    @factory.browser.should_not_receive(:goto)
+    @factory.on DefinitionTest do |page|
+      page.should be_instance_of DefinitionTest
+    end
+
+    @factory.on "DefinitionTest" do |page|
+      page.should be_instance_of DefinitionTest
+    end
+
+    @factory.on "AppModule::TestDefinitionInModule" do |page|
+      page.should be_instance_of AppModule::TestDefinitionInModule
+    end
+  end
+
+  it "should create a new definition object, using during" do
+    @factory.browser.should_not_receive(:goto)
+    @factory.during DefinitionTest do |page|
+      page.should be_instance_of DefinitionTest
+    end
+
+    @factory.during "DefinitionTest" do |page|
+      page.should be_instance_of DefinitionTest
+    end
+
+    @factory.during "AppModule::TestDefinitionInModule" do |page|
+      page.should be_instance_of AppModule::TestDefinitionInModule
+    end
+  end
+
+  it "should create a new definition object and view it, using on_view" do
+    @factory.browser.should_receive(:goto).exactly(5).times
+    @factory.on_view DefinitionTest do |page|
+      page.should be_instance_of DefinitionTest
+    end
+
+    @factory.on_view "DefinitionTest" do |page|
+      page.should be_instance_of DefinitionTest
+    end
+
+    @factory.on_view "AppModule::TestDefinitionInModule" do |page|
+      page.should be_instance_of AppModule::TestDefinitionInModule
+    end
+  end
+
+  it "should create a new definition object and view it, using start_activity" do
+    @factory.browser.should_receive(:goto).exactly(5).times
+    @factory.start_activity DefinitionTest do |page|
+      page.should be_instance_of DefinitionTest
+    end
+
+    @factory.start_activity "DefinitionTest" do |page|
+      page.should be_instance_of DefinitionTest
+    end
+
+    @factory.start_activity "AppModule::TestDefinitionInModule" do |page|
+      page.should be_instance_of AppModule::TestDefinitionInModule
+    end
+  end
+
+  it "should create a new definition object and view it, using start_on" do
+    @factory.browser.should_receive(:goto).exactly(5).times
+    @factory.start_on DefinitionTest do |page|
+      page.should be_instance_of DefinitionTest
+    end
+
+    @factory.start_on "DefinitionTest" do |page|
+      page.should be_instance_of DefinitionTest
+    end
+
+    @factory.start_on "AppModule::TestDefinitionInModule" do |page|
+      page.should be_instance_of AppModule::TestDefinitionInModule
+    end
+  end
+
+  it "should set a reference to be used outside the factory" do
+    active = @factory.on DefinitionTest
+    current = @factory.instance_variable_get "@active"
+    current.should === active
+  end
+
+  it "should use an existing definition when that definition is already active" do
+    @factory.instance_variable_set "@active", TestFactorySecond.new(@factory.browser)
+
+    used = false
+    @factory.if_on(TestFactorySecond) do |page|
+      page.should be_instance_of TestFactorySecond
+      used = true
+    end
+    used.should be true
+
+    used = false
+    @factory.if_on("TestFactorySecond") do |page|
+      page.should be_instance_of TestFactorySecond
+      used = true
+    end
+    used.should be true
+
+    used = false
+    @factory.instance_variable_set "@active", AppModule::TestDefinitionInModule.new(@factory.browser)
+    @factory.if_on("AppModule::TestDefinitionInModule") do |page|
+      page.should be_instance_of AppModule::TestDefinitionInModule
+      used = true
+    end
+    used.should be true
+  end
+
+  it "should not execute block if definition is not the active definition" do
+    @factory.instance_variable_set "@active", TestFactorySecond.new(@factory.browser)
+    @factory.if_on(TestFactoryThird) do |page|
+      fail
+    end
+
+    @factory.if_on("TestFactoryThird") do |page|
+      fail
+    end
+
+    @factory.if_on("AppModule::TestDefinitionInModule") do |page|
+      fail
+    end
+  end
+
+  it "should return the @active instance if asking for another page" do
+    expected = TestFactoryWithURL.new(@factory.browser)
+    @factory.instance_variable_set "@active", expected
+    @factory.if_on(TestFactoryPage).should == expected
+    @factory.if_on("TestFactoryPage").should == expected
+    @factory.if_on("AppModule::TestDefinitionInModule").should == expected
+  end
+
+end

data/spec/symbiont/generators/button_generators_spec.rb

@@ -1,69 +1,72 @@
 require 'spec_helper'
 
 describe Symbiont::Generators do
-  let(:watir_browser) { mock_browser_for_watir }
+  let(:watir_browser)    { mock_browser_for_watir }
   let(:watir_definition) { DefinitionTest.new(watir_browser) }
 
-  describe "button web objects" do
-    context "when declared in a definition" do
+  describe "button generators" do
+    context "when declared on a page definition" do
       it "should generate methods for referencing the button" do
-        watir_definition.should respond_to(:submit_object)
-        watir_definition.should respond_to(:submit_button)
+        watir_definition.should respond_to(:login_object)
+        watir_definition.should respond_to(:login_button)
       end
 
-      it "should generate methods for interacting with the link" do
-        watir_definition.should respond_to(:submit)
-        watir_definition.should respond_to(:submit_text)
-        watir_definition.should respond_to(:submit_exists?)
-        watir_definition.should respond_to(:submit_visible?)
-        watir_definition.should respond_to(:submit_enabled?)
-        watir_definition.should respond_to(:submit?)
-        watir_definition.should respond_to(:submit_?)
-        watir_definition.should respond_to(:submit!)
+      it "should generate methods for interacting with the button" do
+        watir_definition.should respond_to(:login)
+        watir_definition.should respond_to(:login_text)
+        watir_definition.should respond_to(:login_exists?)
+        watir_definition.should respond_to(:login_visible?)
+        watir_definition.should respond_to(:login_enabled?)
+        watir_definition.should respond_to(:login?)
+        watir_definition.should respond_to(:login_?)
+        watir_definition.should respond_to(:login!)
       end
     end
 
-    context "used by the watir platform" do
+    context "when used by the watir platform" do
       it "should locate the button" do
         watir_browser.should_receive(:button).and_return(watir_browser)
-        web_object = watir_definition.submit_object
+        web_object = watir_definition.login_object
         web_object.should_not be_nil
         web_object.should be_instance_of Symbiont::WebObjects::Button
       end
-      
+
       it "should return the text of the button" do
         watir_browser.should_receive(:button).and_return(watir_browser)
-        watir_browser.should_receive(:text).and_return('Submit')
-        watir_definition.submit_text.should == "Submit"
+        watir_browser.should_receive(:text).and_return('Login')
+        watir_definition.login_text.should == "Login"
       end
-      
+
       it "should click the button" do
         watir_browser.should_receive(:button).and_return(watir_browser)
         watir_browser.should_receive(:click)
-        watir_definition.submit
+        watir_definition.login
       end
 
       it "should determine if a button exists" do
         watir_browser.should_receive(:button).twice.and_return(watir_browser)
         watir_browser.should_receive(:exists?).twice.and_return(watir_browser)
-        watir_definition.submit?.should be_true
-        watir_definition.submit_exists?.should be_true
+        watir_definition.login?.should be_true
+        watir_definition.login_exists?.should be_true
       end
-      
+
       it "should determine if a button is visible" do
         watir_browser.should_receive(:button).twice.and_return(watir_browser)
         watir_browser.should_receive(:present?).twice.and_return(watir_browser)
-        watir_definition.submit_?.should be_true
-        watir_definition.submit_visible?.should be_true
+        watir_definition.login_?.should be_true
+        watir_definition.login_visible?.should be_true
       end
-      
+
       it "should determine if a button is enabled" do
         watir_browser.should_receive(:button).twice.and_return(watir_browser)
         watir_browser.should_receive(:enabled?).twice.and_return(watir_browser)
-        watir_definition.submit_enabled?.should be_true
-        watir_definition.submit!.should be_true
+        watir_definition.login_enabled?.should be_true
+        watir_definition.login!.should be_true
       end
-    end
 
+      it "should call a block on the button if specified" do
+        watir_definition.logout_object.should == "logout"
+      end
+    end
   end
-end
+end