kuality-coeus 0.0.1 → 0.0.2

data/lib/kuality-coeus/data_objects/user.rb

@@ -1,40 +1,317 @@
+class UserCollection < Hash
+
+  # Returns an array of all users with the specified role. Takes the role name as a string.
+  # The array is shuffled so that #have_role('role name')[0] will be a random selection
+  # from the list of matching users.
+  def have_role(role)
+    self.find_all{|user| user[1][:roles] != nil && user[1][:roles].include?(role)}.shuffle
+  end
+
+  # Returns an array of all users with the specified campus code. Takes the code as a string.
+  # The array is shuffled so that #with_campus_code('code')[0] will be a random selection
+  # from the list of matching users.
+  def with_campus_code(code)
+    self.find_all{|user| user[1][:campus_code]==code }.shuffle
+  end
+
+  # Returns an array of all users with the specified affiliation type. Takes the type name as a string.
+  # The array is shuffled so that #with_affiliation_type('type name')[0] will be a random selection
+  # from the list of matching users.
+  def with_affiliation_type(type)
+    self.find_all{|user| user[1][:affiliation_type]==type }.shuffle
+  end
+
+  def with_employee_type(type)
+    self.find_all{|user| user[1][:employee_type]==type }.shuffle
+  end
+
+  def with_primary_dept_code(code)
+    self.find_all{|user| user[1][:primary_dept_code]==code }.shuffle
+  end
+
+  # This is a short cut to "knowing" which user can be used as a PI for
+  # a Grants.gov proposal. At some point this should be eliminated--as in,
+  # when we know better what exactly a grants.gov PI requires.
+  def era_commons_user(username)
+    self.find{ |user| user[1][:era_commons_user_name]==username }[0]
+  end
+
+end
+
 class UserObject
 
   include Foundry
   include DataFactory
+  include Navigation
+
+  attr_accessor :user_name, :principal_id,
+                :first_name, :last_name,
+                :description, :affiliation_type, :campus_code,
+                :employee_id, :employee_status, :employee_type, :base_salary, :primary_dept_code,
+                :groups, :roles, :role_qualifiers, :addresses, :phones, :emails,
+                :primary_title, :directory_title, :citizenship_type,
+                :era_commons_user_name, :graduate_student_count, :billing_element,
+                :directory_department
 
-  attr_accessor :name, :username, :email, :password, :role
+  USERS = UserCollection[YAML.load_file("#{File.dirname(__FILE__)}/users.yml")]
+
+  ROLES = {
+      # Add roles here as needed for testing...
+      'Aggregator'                      => '110',
+      'approver'                        => '103',
+      'Award Budget Aggregator'         => '113',
+      'Award Budget Approver'           => '112',
+      'Award Budget Modifier'           => '102',
+      'Award Budget Viewer'             => '101',
+      'Award Viewer'                    => '123',
+      'Budget Creator'                  => '108',
+      'Create Proposal Log'             => '140',
+      'Departments Awards Viewer'       => '121',
+      'IACUC Protocol Aggregator'       => '1421',
+      'IACUC Protocol Approver'         => '1638',
+      'Institutional Proposal Viewer'   => '118',
+      'IRB Administrator'               => '128',
+      'IRB Approver'                    => '99',
+      'IRB Reviewer'                    => '127',
+      'KC Super User'                   => '177',
+      'Maintain IRB Questionnaire'      => '161',
+      'Maintain Proposal Questionnaire' => '162',
+      'Manager'                         =>  '98',
+      'Narrative Writer'                => '109',
+      'Negotiation Creator'             => '1382',
+      'OSP Administrator'               => '131',
+      'OSPApprover'                     => '100',
+      'Protocol Aggregator'             => '105',
+      'Proposal Creator'                => '111',
+      'System User'                     => '90',
+      'Unassigned'                      => '106',
+      'Viewer'                          => '107',
+      'View Subaward'                   => '1409',
+      'View Proposal Log'               => '142'
+  }
 
   def initialize(browser, opts={})
     @browser = browser
-    defaults = {
-        #name:     "Tester Ten",
-        username: "admin",
-        #email:    "test10@customer1.herokuapp.com",
-        #password: "test10"
-    }
-    set_options defaults.merge(opts)
+    @user_name=case
+      when opts.empty?
+        'admin'
+      when opts.key?(:user)
+        opts[:user]
+      when opts.key?(:role)
+        USERS.have_role(ROLES[opts[:role]])[0][0]
+    end
+    defaults = USERS[@user_name]
+    defaults.nil? ? options=opts : options=defaults.merge(opts)
+    set_options options
   end
 
-  def edit opts={}
-
+  def create
+    # First we have to make sure we're logged in with
+    # a user that has permissions to create other users...
+    if login_info_div.text =~ /admin$/
+      visit(SystemAdmin).person unless PersonLookup.new(@browser).principal_id.present?
+    else
+      @logged_in_user_name = login_info_div.text[/\w+$/]
+      visit Login do |log_in|
+        log_in.close_parents
+        log_in.username.set 'admin'
+        log_in.login
+      end
+      visit(SystemAdmin).person
+    end
+    # Now we're certain the create button will be there, so...
+    on(PersonLookup).create
+    on Person do |add|
+      add.expand_all
+      add.principal_name.set @user_name
+      fill_out add, :description, :affiliation_type, :campus_code, :first_name, :last_name
+      # TODO: These "default" checkboxes will need to be reworked if and when
+      # a test is going to require multiple affiliations, names, addresses, etc.
+      # Until then, there's no need to do anything other than set the necessary single values
+      # as "default"...
+      add.affiliation_default.set
+      add.name_default.set
+      add.add_name
+      add.add_affiliation
+      # TODO: Another thing that will need to be changed if ever there's a need to test multiple
+      # lines of employment:
+      unless @employee_id.nil?
+        fill_out add, :employee_id, :employee_status, :employee_type, :base_salary, :primary_dept_code
+        add.primary_employment.set
+        add.add_employment_information
+      end
+      unless @roles.nil?
+        @roles.each do |role|
+          add.role_id.set role
+          add.add_role
+        end
+      end
+      unless @role_qualifiers.nil?
+        @role_qualifiers.each do |role, unit|
+          add.unit_number(role).set unit
+          add.add_role_qualifier role
+        end
+      end
+      unless @groups.nil?
+        @groups.each do |group|
+          add.group_id.set group
+          add.add_group
+        end
+      end
+      unless @addresses.nil?
+        @addresses.each do |address|
+          add.address_type.fit address[:type]
+          add.line_1.fit address[:line_1]
+          add.city.fit address[:city]
+          add.state.pick! address[:state]
+          add.country.pick! address[:country]
+          add.zip.fit address[:zip]
+          add.address_default.fit address[:default]
+          add.add_address
+        end
+      end
+      unless @phones.nil?
+        @phones.each do |phone|
+          add.phone_type.fit phone[:type]
+          add.phone_number.fit phone[:number]
+          add.phone_default.fit phone[:default]
+          add.add_phone
+        end
+      end
+      unless @emails.nil?
+        @emails.each do |email|
+          add.email.fit email[:email]
+          add.email_type.pick! email[:type]
+          add.email_default.fit email[:default]
+          add.add_email
+        end
+      end
+      # A breaking of the design pattern, but there's no other
+      # way to obtain this number:
+      @principal_id = add.principal_id
+      add.blanket_approve
+    end
+    visit(SystemAdmin).person_extended_attributes
+    on(PersonExtendedAttributesLookup).create
+    on PersonExtendedAttributes do |page|
+      page.expand_all
+      fill_out page, :description, :primary_title, :directory_title, :citizenship_type,
+               :era_commons_user_name, :graduate_student_count, :billing_element,
+               :principal_id, :directory_department
+      page.blanket_approve
+    end
+    # Now that we're done with the user creation, we can log back in
+    # with the other user, if necessary...
+    unless @logged_in_user_name.nil?
+      s_o.click
+      on Login do |log_in|
+        log_in.username.set @logged_in_user_name
+        log_in.login
+      end
+    end
   end
 
+  # Keep in mind...
+  # - This method does nothing if the user
+  #   is already logged in
+  # - If some other user is logged in, they
+  #   will be automatically logged out
+  # - This method will close all child
+  #   tabs/windows and return to the window
+  #   with the header frame, so it can see
+  #   who is currently logged in
   def sign_in
-    if logged_out?
-      user_login
-    else # Log the current user out, then log in
-      log_out
-      user_login
+    unless logged_in?
+      if username_field.present?
+        # Do nothing because we're already there
+      else
+        visit Researcher do |page|
+          page.return_to_portal
+          page.close_children
+          page.logout
+        end
+      end
+      on Login do |log_in|
+        log_in.username.set @user_name
+        log_in.login
+      end
+      on(Researcher).logout_button.wait_until_present
     end
   end
   alias_method :log_in, :sign_in
 
-  def logged_in?
-    if login_info.present?
-      login_info.text=~/#{@name}/ ? true : false
+  def sign_out
+  # This _might_ cause an infinite loop, but I'm
+  # hoping not...
+    on(Researcher) do |page|
+      page.return_to_portal
+      page.close_children
+    end
+    if s_o.present?
+      s_o.click
     else
+      visit Login do |page|
+        if page.username.present?
+          # do nothing because we're already logged out...
+        else
+          sign_out
+        end
+      end
+    end
+  end
+  alias_method :log_out, :sign_out
+
+  def exist?
+    visit SystemAdmin do |page|
+      if username_field.present?
+        UserObject.new(@browser).log_in
+      end
+      page.person
+    end
+    on PersonLookup do |search|
+      search.principal_name.set @user_name
+      search.search
+      begin
+        if search.item_row(@user_name).present?
+          # FIXME!
+          # This is a coding abomination to include
+          # this here, but it's here until I can come
+          # up with a better solution...
+          @principal_id = search.item_row(@user_name).link(title: /^Person Principal ID=\d+/).text
+          return true
+        else
+          return false
+        end
+      rescue
+        return false
+      end
+    end
+  end
+  alias_method :exists?, :exist?
+
+  def logged_in?
+    # Are we on the login page already?
+    if username_field.present?
+      # Yes! So, we're not logged in...
       false
+    # No, the Kuali header is showing...
+    elsif login_info_div.present?
+      # So, is the user currently listed as logged in?
+      return login_info_div.text.include? @user_name
+    else # We're on some page that has no Kuali header, so...
+      begin
+        # We'll assume that the portal window exists, and go to it.
+        on(Researcher).return_to_portal
+      # Oops. Apparently there's no portal window, so...
+      rescue
+        # We'll close any extra tabs/windows
+        visit(Login).close_children if @browser.windows.size > 1
+        # And make sure that we're using the "parent" window
+        @browser.windows[0].use
+      end
+      # Now that things are hopefully in a clean state, we'll start
+      # the process again...
+      logged_in?
     end
   end
 
@@ -42,28 +319,21 @@ class UserObject
     !logged_in?
   end
 
-  def log_out
-    s_o.click if s_o.present?
-  end
-  alias_method :sign_out, :log_out
-
   #========
   private
   #========
 
-  def user_login
-    visit Login do |log_in|
-      log_in.username.set @name
-      log_in.login
-    end
+  def s_o
+    @browser.button(value: 'Logout')
   end
 
-  def s_o
-    @browser.button(value: "Logout")
+  def login_info_div
+    @browser.div(id: 'login-info')
   end
 
-  def login_info
-    @browser.div(id: "login-info")
+  def username_field
+    Login.new(@browser).username
   end
 
-end
+end
+

data/lib/kuality-coeus/gem_extensions.rb

@@ -0,0 +1,26 @@
+module Watir
+  module Container
+    def frm
+      case
+        when frame(id: 'iframeportlet').exist?
+          frame(id: 'iframeportlet')
+        when frame(id: /easyXDM_default\d+_provider/).frame(id: 'iframeportlet').exist?
+          frame(id: /easyXDM_default\d+_provider/).frame(id: 'iframeportlet')
+        when frame(id: /easyXDM_default\d+_provider/).exist?
+          frame(id: /easyXDM_default\d+_provider/)
+        else
+          self
+      end
+    end
+  end
+
+  # Because of the unique way we
+  # set up radio buttons in Coeus,
+  # we can use this method in our
+  # radio button definitions.
+  class Radio
+    def fit answer
+      set unless answer==nil
+    end
+  end
+end

data/lib/kuality-coeus/page_objects/000_base_page.rb

@@ -1,35 +1,217 @@
 class BasePage < PageFactory
 
+  action(:use_new_tab) { |b| b.windows.last.use }
+  action(:return_to_portal) { |b| b.portal_window.use }
+  action(:close_children) { |b| b.windows[1..-1].each{ |w| w.close} }
+  action(:close_parents) { |b| b.windows[0..-2].each{ |w| w.close} }
+  action(:loading) { |b| b.frm.image(alt: 'working...').wait_while_present }
+  element(:logout_button) { |b| b.button(title: 'Click to logout.') }
+  action(:logout) { |b| b.logout_button.click }
+
+  element(:portal_window) { |b| b.windows(title: 'Kuali Portal Index')[0] }
+
+  action(:form_tab) { |name, b| b.frm.h2(text: /#{name}/) }
+  action(:form_status) { |name, b| b.form_tab(name).text[/(?<=\()\w+/] }
+
   class << self
 
-    def frame_element
-      element(:frm) { |b| b.frame(id: "iframeportlet") }
+    def glbl(*titles)
+      titles.each do |title|
+        action(damballa(title)) { |b| b.frm.button(class: 'globalbuttons', title: title).click; b.loading }
+      end
     end
 
     def document_header_elements
-      element(:headerinfo_table) { |b| b.div(class: "headerbox").table(class: "headerinfo") }
-
+      value(:doc_title) { |b| b.frm.div(id: 'headerarea').h1.text }
+      element(:headerinfo_table) { |b| b.frm.div(id: 'headerarea').table(class: 'headerinfo') }
       value(:document_id) { |p| p.headerinfo_table[0][1].text }
       alias_method :doc_nbr, :document_id
-      value(:status) { |p| p.headerinfo_table[0][3].text }
+      value(:document_status) { |p| p.headerinfo_table[0][3].text }
       value(:initiator) { |p| p.headerinfo_table[1][1].text }
+      alias_method :disposition, :initiator
       value(:last_updated) {|p| p.headerinfo_table[1][3].text }
       alias_method :created, :last_updated
       value(:committee_id) { |p| p.headerinfo_table[2][1].text }
       alias_method :sponsor_name, :committee_id
+      alias_method :budget_name, :committee_id
       value(:committee_name) { |p| p.headerinfo_table[2][3].text }
       alias_method :pi, :committee_name
     end
 
+    # Included here because this is such a common field in KC
+    def description_field
+      element(:description) { |b| b.frm.text_field(name: 'document.documentHeader.documentDescription') }
+    end
+
     def global_buttons
-      action(:expand_all) { |b| b.image(name: "methodToCall.showAllTabs").click } # TODO: Think about moving this into its own element group
-      action(:submit) { |b| b.image(class: "globalbuttons", title: "submit").click }
-      action(:save) { |b| b.image(class: "globalbuttons", title: "save").click }
-      action(:blanket_approve) { |b| b.image(class: "globalbuttons", title: "blanket approve").click }
-      action(:close) { |b| b.image(class: "globalbuttons", title: "close").click }
-      action(:cancel) { |b| b.image(class: "globalbuttons", title: "cancel").click }
+      glbl 'save', 'Reject', 'blanket approve', 'close', 'cancel', 'reload',
+           'Delete Proposal', 'approve', 'disapprove',
+           'Generate All Periods', 'Calculate All Periods', 'Default Periods',
+           'Calculate Current Period', 'submit', 'Send Notification'
+      # Explicitly defining the "recall" button to keep the method name at "recall" instead of "recall_current_document"...
+      element(:recall_button) { |b| b.frm.button(class: 'globalbuttons', title: 'Recall current document') }
+      action(:recall) { |b| b.recall_button.click; b.loading }
+      action(:edit) { |b| b.frm.button(name: 'methodToCall.editOrVersion').click; b.loading }
+      action(:delete_selected) { |b| b.frm.button(class: 'globalbuttons', name: 'methodToCall.deletePerson').click; b.loading }
+      element(:send_button) { |b| b.frm.button(class: 'globalbuttons', name: 'methodToCall.sendNotification', title: 'send') }
+      action(:send_fyi) { |b| b.send_button.click; b.loading }
+    end
+
+    def tab_buttons
+      action(:expand_all) { |b| b.frm.button(name: 'methodToCall.showAllTabs').click; b.loading }
+    end
+
+    def tiny_buttons
+      action(:search) { |b| b.frm.button(title: 'search', value: 'search').click; b.loading }
+      action(:clear) { |b| b.frm.button(name: 'methodToCall.clearValues').click; b.loading }
+      action(:cancel_button) { |b| b.frm.link(title: 'cancel').click; b.loading }
+      action(:yes) { |b| b.frm.button(name: 'methodToCall.rejectYes').click; b.loading }
+      action(:no) {|b| b.frm.button(name: 'methodToCall.rejectNo').click; b.loading }
+      action(:add) { |b| b.frm.button(name: 'methodToCall.addNotificationRecipient.anchor').click; b.loading }
+    end
+
+    def search_results_table
+      element(:results_table) { |b| b.frm.table(id: 'row') }
+
+      action(:edit_item) { |match, p| p.results_table.row(text: /#{match}/m).link(text: 'edit').click; b.use_new_tab; b.close_parents }
+      alias_method :edit_person, :edit_item
+
+      action(:item_row) { |match, b| b.results_table.row(text: /#{match}/m) }
+      action(:open_item) { |match, b| b.item_row(match).link(text: /#{match}/).click; b.use_new_tab; b.close_parents }
+      action(:delete_item) { |match, p| p.item_row(match).link(text: 'delete').click; p.use_new_tab; p.close_parents }
+
+      action(:return_value) { |match, p| p.item_row(match).link(text: 'return value').click }
+      action(:return_random) { |b| b.return_value_links[rand(b.return_value_links.length)].click }
+      element(:return_value_links) { |b| b.results_table.links(text: 'return value') }
+    end
+
+    def budget_header_elements
+      action(:return_to_proposal) { |b| b.frm.button(name: 'methodToCall.returnToProposal').click; b.loading }
+      buttons 'Budget Version', 'Parameters', 'Rates', 'Summary', 'Personnel', 'Non-Personnel',
+              'Distribution & Income', 'Budget Actions'
+      # Need the _tab suffix because of method collisions
+      action(:modular_budget_tab) { |b| b.frm.button(value: 'Modular Budget').click }
+    end
+
+    def budget_versions_elements
+      element(:name) { |b| b.frm.text_field(name: 'newBudgetVersionName') }
+      action(:add) { |b| b.frm.button(name: 'methodToCall.addBudgetVersion').click }
+      action(:version) { |budget, p| p.budgetline(budget).td(class: 'tab-subhead', index: 2).text }
+      action(:direct_cost) { |budget, p| p.budgetline(budget).td(class: 'tab-subhead', index: 3).text }
+      action(:f_and_a) { |budget, p| p.budgetline(budget).td(class: 'tab-subhead', index: 4).text }
+      action(:total) { |budget, p| p.budgetline(budget).td(class: 'tab-subhead', index: 5).text }
+      # Called "budget status" to avoid method collision...
+      action(:budget_status) { |budget, p| p.budgetline(budget).select(title: 'Budget Status') }
+      action(:open) { |budget, p| p.budgetline(budget).button(alt: 'open budget').click }
+      action(:copy) { |budget, p| p.budgetline(budget).button(alt: 'copy budget').click }
+      action(:f_and_a_rate_type) { |budget, p| p.budget_table(budget)[0][3].text }
+      action(:cost_sharing) { |budget, p| p.budget_table(budget)[1][1].text }
+      action(:budget_last_updated) { |budget, p| p.budget_table(budget)[1][3].text }
+      action(:unrecovered_f_and_a) { |budget, p| p.budget_table(budget)[2][1].text }
+      action(:last_updated_by) { |budget, p| p.budget_table(budget)[2][3].text }
+      action(:comments) { |budget, p| p.budget_table(budget)[3][1].text }
+
+      private
+      element(:b_v_table) { |b| b.frm.table(id: 'budget-versions-table') }
+      action(:budgetline) { |budget, p| p.b_v_table.td(class: 'tab-subhead', text: budget).parent }
+      action(:budget_table) { |budget, p| p.b_v_table.tbodys[p.target_index(budget)].table }
+      action(:target_index) do |budget, p|
+        i=p.b_v_table.tbodys.find_index { |tbody| tbody.td(class: 'tab-subhead', index: 1).text==budget }
+        i+1
+      end
+    end
+
+    def special_review
+      element(:add_type) { |b| b.frm.select(id: 'specialReviewHelper.newSpecialReview.specialReviewTypeCode') }
+      element(:add_approval_status) { |b| b.frm.select(id: 'specialReviewHelper.newSpecialReview.approvalTypeCode') }
+      element(:add_protocol_number) { |b| b.frm.text_field(id: 'specialReviewHelper.newSpecialReview.protocolNumber') }
+      element(:add_application_date) { |b| b.frm.text_field(id: 'specialReviewHelper.newSpecialReview.applicationDate') }
+      element(:add_approval_date) { |b| b.frm.text_field(id: 'specialReviewHelper.newSpecialReview.approvalDate') }
+      element(:add_expiration_date) { |b| b.frm.text_field(id: 'specialReviewHelper.newSpecialReview.expirationDate') }
+      element(:add_exemption_number) { |b| b.frm.select(id: 'specialReviewHelper.newSpecialReview.exemptionTypeCodes') }
+
+      action(:add) { |b| b.frm.button(name: 'methodToCall.addSpecialReview.anchorSpecialReview').click }
+
+      element(:save_button) { |b| b.frm.button(name: 'methodToCall.save') }
+    end
+
+    def custom_data
+      element(:graduate_student_count) { |b| b.target_row('Graduate Student Count').text_field }
+      element(:billing_element) { |b| b.target_row('Billing Element').text_field }
+      element(:save_button) { |b| b.frm.button(name: 'methodToCall.save') }
+      element(:asdf_tab) { |b| b.frm.div(id: 'tab-asdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdf-div') }
+      action(:target_row) { |text, b| b.frm.trs(class: 'datatable').find { |row| row.text.include? text } }
+    end
+
+    def route_log
+      element(:route_log_iframe) { |b| b.frm.frame(name: 'routeLogIFrame') }
+      element(:actions_taken_table) { |b| b.route_log_iframe.div(id: 'tab-ActionsTaken-div').table }
+      value(:actions_taken) { |b| (b.actions_taken_table.rows.collect{ |row| row[1].text }.compact.uniq).reject{ |action| action==''} }
+      element(:pnd_act_req_table) { |b| b.route_log_iframe.div(id: 'tab-PendingActionRequests-div').table }
+      value(:action_requests) { |b| (b.pnd_act_req_table.rows.collect{ |row| row[1].text}).reject{ |action| action==''} }
+      action(:show_future_action_requests) { |b| b.route_log_iframe.h2(text: 'Future Action Requests').parent.parent.image(title: 'show').click }
+      element(:future_actions_table) { |b| b.route_log_iframe.div(id: 'tab-FutureActionRequests-div').table }
+      action(:requested_action_for) { |name, b| b.future_actions_table.tr(text: /#{name}/).td(index: 2).text }
+    end
+
+    # Gathers all errors on the page and puts them in an array called "errors"
+    def error_messages
+      element(:errors) do |b|
+        errs = []
+        b.left_errmsg_tabs.each do |div|
+          if div.div.div.exist?
+            errs << div.div.divs.collect{ |div| div.text }
+          elsif div.li.exist?
+            errs << div.lis.collect{ |li| li.text }
+          end
+        end
+        b.left_errmsg.each do |div|
+          if div.div.div.exist?
+            errs << div.div.divs.collect{ |div| div.text }
+          elsif div.li.exist?
+            errs << div.lis.collect{ |li| li.text }
+          end
+        end
+        errs.flatten
+      end
+      element(:left_errmsg_tabs) { |b| b.frm.divs(class: 'left-errmsg-tab') }
+      element(:left_errmsg) { |b| b.frm.divs(class: 'left-errmsg') }
+      element(:error_messages_div) { |b| b.frm.div(class: 'error') }
+    end
+
+    def validation_elements
+      element(:validation_button) { |b| b.frm.button(name: 'methodToCall.activate') }
+      action(:show_data_validation) { |b| b.frm.button(id: 'tab-DataValidation-imageToggle').click; b.validation_button.wait_until_present }
+      action(:turn_on_validation) { |b| b.validation_button.click; b.special_review_button.wait_until_present }
+      element(:validation_errors_and_warnings) { |b| errs = []; b.validation_err_war_fields.each { |field| errs << field.html[/(?<=>).*(?=<)/] }; errs }
+      element(:validation_err_war_fields) { |b| b.frm.tds(width: '94%') }
     end
-    
-  end
 
-end
+    def links(*links_text)
+      links_text.each { |link| elementate(:link, link) }
+    end
+
+    def buttons(*buttons_text)
+     buttons_text.each { |button| elementate(:button, button) }
+    end
+
+    private
+
+    # A helper method that converts the passed string into snake case. See the StringFactory
+    # module for more info.
+    #
+    def damballa(text)
+      StringFactory::damballa(text)
+    end
+
+    def elementate(type, text)
+      identifiers={:link=>:text, :button=>:value}
+      el_name=damballa("#{text}_#{type}")
+      act_name=damballa(text)
+      element(el_name) { |b| b.frm.send(type, identifiers[type]=>text) }
+      action(act_name) { |b| b.frm.send(type, identifiers[type]=>text).click }
+    end
+
+  end # self
+
+end # BasePage