watirmark 5.14.16 → 5.27.2

data/spec/model_factory_spec.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 require_relative 'spec_helper'
 
 describe "factory" do
@@ -6,6 +7,14 @@ describe "factory" do
       class InitializeModel < Watirmark::Model::Factory
         keywords :username, :password
       end
+
+      class UniqueDefaultsModel < Watirmark::Model::Factory
+        keywords :test_name
+        defaults do
+          test_name { unique_instance_name }
+        end
+      end
+
     end
   end
 
@@ -37,6 +46,16 @@ describe "factory" do
     login = FactoryTest::InitializeModel.new(username: 'foo', password: 'bar')
     login.to_h.should == {:username=>"foo", :password=>"bar"}
   end
+
+  specify "should generate custom unique_instance_name given model_name" do
+     demo_model = FactoryTest::UniqueDefaultsModel.new({:model_name => "RspecUniqueName"})
+     demo_model.test_name.should =~ /^RspecUniqueName_[\dA-Za-z]+$/
+  end
+
+  specify "should generate default unique_instance_name given no model_name" do
+     demo_model = FactoryTest::UniqueDefaultsModel.new()
+     demo_model.test_name.should =~ /^uniquedefaults_[\dA-Za-z]+$/
+  end
 end
 
 describe "#update" do
@@ -68,16 +87,16 @@ describe "#update" do
     first = FactoryTest::UpdateModel.new
     first.update(:foobar=>1)
     second = FactoryTest::UpdateModel.new
-    second.respond_to?(:foobar).should be_false
-    second.respond_to?(:foobar).should be_false
+    second.respond_to?(:foobar).should == false
+    second.respond_to?(:foobar).should == false
   end
 
   specify "model update should remove empty keys" do
     keys = FactoryTest::UpdateModel.new
-    lambda{keys.update(':'=>'') }.should_not raise_error NameError
-    lambda{keys.update(nil=>'') }.should_not raise_error NameError
-    lambda{keys.update('   '=>'') }.should_not raise_error NameError
-    lambda{keys.update('   '.to_sym=>'') }.should_not raise_error NameError
+    lambda{keys.update(':'=>'') }.should_not raise_error
+    lambda{keys.update(nil=>'') }.should_not raise_error
+    lambda{keys.update('   '=>'') }.should_not raise_error
+    lambda{keys.update('   '.to_sym=>'') }.should_not raise_error
   end
 
 end
@@ -462,7 +481,7 @@ describe "methods in Enumerable should not collide with model defaults" do
         end
       end
     end
-    FactoryTest::NoZipModel.new.respond_to?(:zip).should_not be_true
+    FactoryTest::NoZipModel.new.respond_to?(:zip).should_not == true
   end
 
 end
@@ -533,10 +552,12 @@ describe "subclassing" do
     end
     module FactoryTest
       class BaseModel < Watirmark::Model::Factory
-        keywords :first_name, :last_name, :full_name
+        keywords :first_name, :last_name, :full_name, :attr_test, :base_attr
         defaults do
           first_name { 'base_first_name' }
           last_name { 'base_last_name' }
+          attr_test { 'I came from BaseModel' }
+          base_attr { 'This is a base attribute' }
         end
         traits :some_trait
       end
@@ -545,6 +566,7 @@ describe "subclassing" do
         defaults do
           first_name { 'sub_first_name' }
           last_name { 'sub_last_name' }
+          attr_test { 'I came from SubModel'}
         end
       end
 
@@ -564,5 +586,166 @@ describe "subclassing" do
   specify "submodel should be able to inherit defaults" do
     FactoryTest::NoDefaultModel.new.full_name.should == 'full_name'
   end
+
+  specify "submodel should be able to override defaults" do
+    FactoryTest::SubModel.new.first_name.should == 'sub_first_name'
+    FactoryTest::SubModel.new.last_name.should == 'sub_last_name'
+    FactoryTest::SubModel.new.attr_test.should == 'I came from SubModel'
+    FactoryTest::SubModel.new.base_attr.should == 'This is a base attribute'
+  end
+
 end
 
+describe "#hash_id" do
+  class HashIdModel < Watirmark::Model::Factory
+    keywords :first_name, :last_name
+    defaults do
+      first_name { "First" }
+      middle_name { "Middle" }
+      last_name { "Last #{hash_id}" }
+    end
+  end
+
+  let(:model1) { HashIdModel.new }
+  let(:model2) { HashIdModel.new }
+  let(:model3) { HashIdModel.new }
+
+  specify "HashIdModel should have a 8 digit hash_id and are always the same" do
+    [model1, model2].each{|x| x.last_name.should match(/^Last [a-f0-9]{8}$/)}
+    model1.last_name.should == model2.last_name
+  end
+
+  specify "HashIdModels should have a hash_id of '4033fe24' when using the default seed 'Watirmark Default Seed'" do
+    Watirmark::Configuration.instance.hash_id_seed = nil
+    hash_id = (RUBY_VERSION == '1.9.3') ? 'ca14e5fb' : '4033fe24'
+    model1.hash_id.should == hash_id
+  end
+
+  specify "HashIdModels should have a different 8 digit hash_id when they have different seeds" do
+    model_seed_1 = HashIdModel.new
+    Watirmark::Configuration.instance.hash_id_seed = "New Seed"
+    model_seed_2 = HashIdModel.new
+    Watirmark::Configuration.instance.hash_id_seed = "Newest Seed"
+    model_seed_3 = HashIdModel.new
+    Watirmark::Configuration.instance.hash_id_seed = nil
+
+    [model_seed_1, model_seed_2, model_seed_3].each do |x|
+      x.last_name.should match(/^Last [a-f0-9]{8}$/)
+    end
+    [model_seed_1.last_name, model_seed_2.last_name, model_seed_3.last_name].uniq.length.should == 3
+  end
+
+  specify "add a new attribute to a HashIdModel with the hash_id" do
+    model1.foo = "bar #{model1.hash_id}"
+    model2.zoo = "baz #{model1.hash_id}"
+
+    model1.foo.gsub("bar", "baz").should == model2.zoo
+    HashIdModel.new.hash_id.should == HashIdModel.new.hash_id
+  end
+
+  let(:test_strings) {
+    ["0",
+     "1",
+     "a",
+     "b",
+     "This is quite a long test string",
+     "This is quite a much longer test string that I'm going to use in my tests",
+     "And one test string I'll use with special characters ©å߃"
+    ]
+  }
+
+  specify "should generate a hash value with a length of 8 - the default" do
+    new_model = Watirmark::Model::Factory.new
+    keys = test_strings.map { |x| new_model.hash_id }
+    keys.each { |x| x.length.should == 8 }
+  end
+
+  specify "should generate a hash value with a length of 20" do
+    length = Watirmark::Configuration.instance.hash_id_length = 20
+    new_model = Watirmark::Model::Factory.new
+    keys = test_strings.map { |x| new_model.hash_id(length) }
+    keys.each { |x| x.length.should == 20 }
+  end
+
+  specify "should generate a hash value with a length of 1" do
+    length = Watirmark::Configuration.instance.hash_id_length = 1
+    new_model = Watirmark::Model::Factory.new
+    keys = test_strings.map { |x| new_model.hash_id(length) }
+    keys.each { |x| x.length.should == 1 }
+  end
+
+  specify "should generate keys with hex values" do
+    length = Watirmark::Configuration.instance.hash_id_length = 8
+    new_model = Watirmark::Model::Factory.new
+    keys = test_strings.map { |x| new_model.hash_id(length, :hex) }
+    keys.each do |key|
+      key.each_char do |char|
+        char[/[a-f0-9]/].should_not be_nil
+      end
+    end
+  end
+
+  specify "should generate keys with alphanumeric values" do
+    length = Watirmark::Configuration.instance.hash_id_length = 8
+    new_model = Watirmark::Model::Factory.new
+    keys = test_strings.map { |x| new_model.hash_id(length, :alpha) }
+    keys.each do |key|
+      key.each_char do |char|
+        char[/[A-Za-z0-9]/].should_not be_nil
+      end
+    end
+  end
+
+end
+
+describe "#uuid" do
+  class UUIDModel < Watirmark::Model::Factory
+    keywords :first_name, :last_name
+    defaults do
+      first_name { "First" }
+      middle_name { "Middle" }
+      last_name { "Last #{uuid}" }
+    end
+  end
+
+  let(:model1) {UUIDModel.new}
+  let(:model2) {UUIDModel.new}
+  let(:model3) {UUIDModel.new}
+
+  specify "UUIDModel should have a 10 digit uuid and are never the same" do
+    [model1, model2].each{|x| x.last_name.should match(/^Last [a-f0-9]{10}$/)}
+    model1.last_name.should_not == model2.last_name
+  end
+
+  specify "UUIDModels should have a different 10 digit uuid when they are initialized with a different UUID" do
+    model_seed_1 = UUIDModel.new
+    Watirmark::Configuration.instance.uuid = "1234567890"
+    model_seed_2 = UUIDModel.new
+    Watirmark::Configuration.instance.uuid = "0987654321"
+    model_seed_3 = UUIDModel.new
+
+    [model_seed_1, model_seed_2, model_seed_3].each do |x|
+      #puts x.last_name
+      x.last_name.should match(/^Last [a-f0-9]{10}$/)
+    end
+    [model_seed_1.last_name, model_seed_2.last_name, model_seed_3.last_name].uniq.length.should == 3
+  end
+
+  specify "UUIDModels should have different UUIDs if Watirmark::Configuration#uuid is not set" do
+    Watirmark::Configuration.instance.uuid = nil
+    Watirmark::Configuration.instance.uuid.should be_nil
+    UUIDModel.new.uuid.should_not == UUIDModel.new.uuid
+  end
+
+  specify "add a new attribute to a UUIDModel with the uuid" do
+    model1.foo = "bar #{model1.uuid}"
+    model2.zoo = "baz #{model1.uuid}"
+
+    model1.foo.gsub("bar", "baz").should == model2.zoo
+  end
+
+  after :all do
+    Watirmark::Configuration.instance.uuid = nil
+  end
+
+end

data/spec/model_traits_spec.rb

@@ -49,6 +49,11 @@ describe "Traits" do
     end
   end
 
+  before :all do
+    # guard against other tests setting UUID
+    Watirmark::Configuration.instance.uuid = nil
+  end
+
   specify "should have different last names" do
     a = FactoryTest::TraitsA.new
     b = FactoryTest::TraitsB.new

data/spec/page_spec.rb

@@ -22,12 +22,20 @@ describe 'Page' do
     class Page5 < Page1
       keyword(:i) { "i" }
     end
+    class Page6 < Page
+
+    end
 
     @page1 = Page1.new
     @page2 = Page2.new
     @page3 = Page3.new
     @page4 = Page4.new
     @page5 = Page5.new
+    @page6 = Page6.new
+  end
+
+  it "should handle empty keywords gracefully" do
+    @page6.keywords.should == []
   end
 
   it "should list its keywords" do
@@ -109,14 +117,14 @@ describe "keyword metadata inheritance" do
 
   it 'should allow child to override superclass' do
     child = Child.new
-    child.keywords.sort_by{|k| k.to_s}.should == [:a, :b, :c, :same]
+    child.keywords.sort_by { |k| k.to_s }.should == [:a, :b, :c, :same]
     child.a.should == "a"
     child.same.should == 'c1-child'
   end
 
   it 'should not bleed settings between children' do
     child2 = Child2.new
-    child2.keywords.sort_by{|k| k.to_s}.should == [:a, :b, :g, :same]
+    child2.keywords.sort_by { |k| k.to_s }.should == [:a, :b, :g, :same]
     child2.g.should == 'g'
     child2.same.should == 'c1'
   end

data/spec/process_page_spec.rb

@@ -8,7 +8,7 @@ describe 'ProcessPage' do
   
   it 'should support an activate method' do
     p = Watirmark::ProcessPage.new('pp')
-    lambda{p.activate}.should_not raise_error(NoMethodError)
+    lambda{p.activate}.should_not raise_error
   end
   
 end
@@ -118,9 +118,9 @@ describe 'Process Page Views' do
     custom_method_called = false
     Watirmark::ProcessPage.navigate_method_default = Proc.new { custom_method_called = true }
     @processpagetest.a.should == 'a'
-    custom_method_called.should be_false
+    custom_method_called.should == false
     @processpagetest.b.should == 'b'
-    custom_method_called.should be_true
+    custom_method_called.should == true
   end
 
   it 'should support defining the process page submit method' do

data/spec/session_spec.rb

@@ -0,0 +1,56 @@
+require_relative 'spec_helper'
+
+describe Watirmark::Session do
+  before :all do
+    @html = File.expand_path(File.dirname(__FILE__) + '/html/controller.html')
+    @config = Watirmark::Configuration.instance
+  end
+
+  before :each do
+    Watirmark::Session.instance.closebrowser
+    @config.reload
+  end
+
+  specify "check firefox to close the browser" do
+    session = Watirmark::Session.instance
+    b = session.openbrowser
+    b.goto "file://#{@html}"
+    session.closebrowser
+    b.instance_variable_get('@closed').should be true
+  end
+
+  specify 'does not run headless when headless set to false' do
+    @config.headless = false
+    session = Watirmark::Session.instance
+    b = session.openbrowser
+    b.goto "file://#{@html}"
+    b.title.should == "Controller Page"
+    b.instance_variable_get('@closed').should be false
+    session.instance_variable_get('@headless').should be_nil
+  end
+
+  # CI can not use chrome; must verify locally
+  context "when running with Chrome" do
+    xit "check chrome to close the browser" do
+      @config.webdriver = 'chrome'
+      session = Watirmark::Session.instance
+      b = session.newsession
+      b.goto "file://#{@html}"
+      session.closebrowser
+      b.instance_variable_get('@closed').should be true
+    end
+
+    # Have to use chrome; headless doesn't always play well with Firefox
+    xit 'can run headless on linux' do
+      @config.webdriver = 'chrome'
+      @config.headless = true
+      session = Watirmark::Session.instance
+      b = session.openbrowser
+      b.goto "file://#{@html}"
+      b.title.should == "Controller Page"
+      b.instance_variable_get('@closed').should be false
+      session.instance_variable_get('@headless').should_not be_nil
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -14,4 +14,4 @@ RSpec.configure do |config|
   config.mock_with :mocha
 end
 
-Watirmark.add_exit_task  { Page.browser.close if Page.browser_exists? }
+Watirmark.add_exit_task  { Watirmark::Session.instance.closebrowser }