puppet7 0.2.0.beta1

data/lib/puppet7/selenium_locator_actions.rb

@@ -0,0 +1,302 @@
+# coding: utf-8
+
+module Puppet7
+  module SeleniumLocatorActions
+    def get_attribute attrname
+      selenium {|s| s.get_attribute("#{@xpath}@#{attrname}")}
+    end
+    alias_method :attr, :get_attribute
+    
+    def add_selection
+      selenium {|s| s.add_selection @xpath}
+    end
+
+    def assign_id id
+      selenium {|s| s.assign_id @xpath, id}
+    end
+
+
+    def attach_file fileLocator
+      selenium {|s| s.attach_file @xpath, fileLocator}
+    end
+
+    def check
+      selenium {|s| s.check @xpath}
+    end
+
+    def click
+      selenium {|s| s.click @xpath}
+    end
+
+    def click_n_wait what=:page, *args
+      selenium do |s|
+        s.click @xpath
+        case what
+        when :page then s.wait_for_page_to_load
+        when :element then s.wait_for_element *args
+        end
+      end
+    end
+
+    def click_at coordString
+      selenium {|s| s.click_at @xpath, coordString}
+    end
+
+    def context_menu
+      selenium {|s| s.context_menu @xpath}
+    end
+
+    def context_menu_at coordString
+      selenium {|s| s.context_menu @xpath, coordString}
+    end
+
+    def double_click
+      selenium {|s| s.double_click @xpath}
+    end
+
+    def double_click_at coordString
+      selenium {|s| s.double_click @xpath, coordString}
+    end
+
+    def drag_and_drop movementsString
+      selenium {|s| s.drag_and_drop @xpath, movementsString}
+    end
+
+    def drag_and_drop_to_object destLocator
+      selenium {|s| s.drag_and_drop_to_object @xpath, get_locator(destLocator)}
+    end
+
+    def fire_event eventName
+      selenium {|s| s.fire_event(@xpath, eventName)}
+    end
+
+    def focus
+      selenium {|s| s.focus @xpath}
+    end
+
+    def get_element_height
+      selenium {|s| s.get_element_height(@xpath).to_i}
+    end
+    alias_method :height, :get_element_height
+
+    def get_element_index
+      selenium {|s| s.get_element_index(@xpath).to_i}
+    end
+    alias_method :index, :get_element_index
+
+    def get_element_position_left
+      selenium {|s| s.get_element_position_left(@xpath).to_i}
+    end
+    alias_method :left, :get_element_position_left
+
+    def get_element_position_top
+      selenium {|s| s.get_element_position_top(@xpath).to_i}
+    end
+    alias_method :top, :get_element_position_top
+
+    def get_element_width
+      selenium {|s| s.get_element_width(@xpath).to_i}
+    end
+    alias_method :width, :get_element_width
+
+    def get_select_options
+      selenium {|s| s.get_select_options @xpath}
+    end
+    alias_method :select_options, :get_select_options
+
+    def get_selected_id
+      selenium {|s| s.get_selected_id @xpath}
+    end
+    alias_method :selected_id, :get_selected_id
+
+    def get_selected_ids
+      selenium {|s| s.get_selected_ids @xpath}
+    end
+    alias_method :selected_ids, :get_selected_ids
+
+    def get_selected_index
+      selenium {|s| s.get_selected_index @xpath}
+    end
+    alias_method :selected_index, :get_selected_index
+
+    def get_selected_indexes
+      selenium {|s| s.get_selected_indexes @xpath}
+    end
+    alias_method :selected_indexes, :get_selected_indexes
+    
+    def get_selected_label
+      selenium {|s| s.get_selected_label @xpath}
+    end
+    alias_method :selected_label, :get_selected_label
+
+    def get_selected_labels
+      selenium {|s| s.get_selected_labels @xpath}
+    end
+    alias_method :selected_labels, :get_selected_labels
+
+    def get_selected_value
+      selenium {|s| s.get_selected_value @xpath}
+    end
+    alias_method :selected_value, :get_selected_value
+    
+    def get_selected_values
+      selenium {|s| s.get_selected_values @xpath}
+    end
+    alias_method :selected_values, :get_selected_values
+
+    def get_text
+      selenium {|s| s.get_text(@xpath).force_encoding(@parent.page.encoding)}
+    end
+
+    alias_method :text, :get_text
+
+    def get_value
+      selenium {|s| s.get_value @xpath}
+    end
+    alias_method :value, :get_value
+
+    def get_xpath_count
+      selenium {|s| s.get_xpath_count(@xpath).to_i}
+    end
+    alias_method :count, :get_xpath_count
+    alias_method :length, :get_xpath_count
+
+    def highlight
+      selenium {|s| s.highlight @xpath}
+    end
+
+    def is_checked
+      selenium {|s| s.is_checked(@xpath)}
+    end
+
+    alias_method :checked?, :is_checked
+
+    def is_editable
+      selenium {|s| s.is_editable(@xpath)}
+    end
+    alias_method :editable?, :is_editable
+
+    def is_element_present
+      selenium {|s| s.is_element_present @xpath}
+    end
+
+    alias_method :element?, :is_element_present
+
+    def is_ordered otherLocator
+      selenium {|s| s.is_ordered @xpath, get_locator(otherLocator)}
+    end
+
+    alias_method :ordered?, :is_ordered
+
+    def is_something_selected
+      selenium {|s| s.is_something_selected(@xpath)}
+    end
+
+    def is_visible
+      selenium {|s| s.is_visible @xpath}
+    end
+
+    alias_method :visible?, :is_visible
+
+    def key_down keySequence
+      selenium {|s| s.key_down(@xpath, keySequence)}
+    end
+
+    def key_press keySequence
+      selenium {|s| s.key_press(@xpath, keySequence)}
+    end
+
+    def key_up keySequence
+      selenium {|s| s.key_up(@xpath, keySequence)}
+    end
+
+    def mouse_down
+      selenium {|s| s.mouse_down @xpath}
+    end
+
+    def mouse_down_at coordString
+      selenium {|s| s.mouse_down_at(@xpath, coordString)}
+    end
+
+    def mouse_down_right
+      selenium {|s| s.mouse_down_right @xpath}
+    end
+
+    def mouse_down_right_at coordString
+      selenium {|s| s.mouse_down_right_at @xpath, coordString}
+    end
+
+    def mouse_move
+      selenium {|s| s.mouse_move @xpath}
+    end
+
+    def mouse_move_at coordString
+      selenium {|s| s.mouse_move_at @xpath, coordString}
+    end
+
+    def mouse_out
+      selenium {|s| s.mouse_out @xpath}
+    end
+
+    def mouse_over
+      selenium {|s| s.mouse_over @xpath}
+    end
+
+    def mouse_up
+      selenium {|s| s.mouse_up @xpath}
+    end
+
+    def mouse_up_at coordString
+      selenium {|s| s.mouse_up_at @xpath, coordString}
+    end
+
+    def mouse_up_right
+      selenium {|s| s.mouse_up_right @xpath}
+    end
+
+    def mouse_up_right_at coordString
+      selenium {|s| s.mouse_up_right_at @xpath, coordString}
+    end
+
+    def remove_all_selections
+      selenium {|s| s.remove_all_selections @xpath}
+    end
+
+    def remove_selection optionLocator
+      selenium {|s| s.remove_selection @xpath, get_locator(optionLocator)}
+    end
+
+    def select optionLocator
+      selenium {|s| s.select @xpath, get_locator(optionLocator)}
+    end
+
+    def select_frame
+      selenium {|s| s.select_frame @xpath}
+    end
+
+    def submit
+      selenium {|s| s.submit @xpath}
+    end
+
+    def type value
+      selenium {|s| s.type @xpath, value}
+    end
+    
+    def type_keys value
+      selenium {|s| s.type_keys @xpath, value}
+    end
+
+    def uncheck
+      selenium {|s| s.uncheck @xpath}
+    end
+    
+    private
+    def get_locator locator
+      if locator === Puppet7::Element
+        locator.xpath
+      else
+        locator.to_s
+      end
+    end
+  end
+end

data/lib/puppet7/selenium_support.rb

@@ -0,0 +1,56 @@
+# coding: utf-8
+
+require "selenium/client"
+
+module Puppet7
+    
+  # Selenium Client Configure
+  #
+  # default is ...
+  #  {
+  #    :host => 'localhost',
+  #    :port => 4444,
+  #    :browser => '*firefox',
+  #    :timeout_in_seconds => 15,
+  #    :highlight_located_element => true
+  #  }
+  #
+  class SeleniumSupport
+    def self.init_selenium user_configs={}
+      begin
+        selenium_config = Puppet7.configuration.selenium_configs.merge(user_configs)
+        selenium = Selenium::Client::Driver.new selenium_config
+        selenium.javascript_extension = extension_script
+        selenium.start
+        selenium.window_maximize
+        #selenium.set_speed 100
+        selenium
+      rescue => err
+        raise SeleniumInitError.new("Fail to initialize selenium : #{err}")
+      end
+    end
+
+    def self.javascript_dir
+      File.join File.dirname(__FILE__), "javascript"
+    end
+    
+    def self.extension_script
+      line_buff = []
+      File.open(File.join(javascript_dir, "json.js")).each_line do |line|
+        line_buff << line
+      end
+      File.open(File.join(javascript_dir, "on_page_loading.js")).each_line do |line|
+        line_buff << line
+      end
+      Puppet7.configuration.js_ext_files.each do |file|
+        if File.exist?(file)
+          File.open(file).each_line {|line| line_buff << line}
+        end
+      end
+      File.open(File.join(javascript_dir, "selenium_extension.js")).each_line do |line|
+        line_buff << line
+      end
+      line_buff.join()
+    end
+  end
+end

data/lib/puppet7/sql_agent.rb

@@ -0,0 +1,98 @@
+# coding: utf-8
+
+
+require "puppet7/extend"
+require "puppet7/sql_exec"
+
+module Puppet7
+  class SQLAgent
+    attr_reader :files, :sqllist, :types, :dao
+    SqlInfo = Struct.new(:id, :type, :sql)
+
+    def initialize sqlexec, dir
+      if RUBY_VERSION < "1.9"
+        raise "#{self.class} support ruby1.9 or greater. but you have #{RUBY_VERSION} version of ruby"
+      end
+      @files = []
+      @sqllist = {}
+      @types = [:list, :row, :value, :execute]
+      @sqlexec = sqlexec
+      load_files dir
+    end
+
+    private
+    
+    def load_files dir
+      Dir.new(dir).each do |file|
+        next if file =~ /^\./
+        next unless file =~ /\.sqldef$/
+        path = File.join(dir,file)
+        if File.directory?(path)
+          load_files path
+        else
+          load_sql path
+        end
+      end
+    end
+
+    def load_sql file
+      sqlcnt = 0
+      sql_id = nil
+      type = nil
+      File.open(file).each_line do |line|
+        if sql_id
+          if line.strip =~ /^\// # end of sql
+            @sqllist[sql_id].sql = @sqllist[sql_id].sql.join("\n")
+            create_method @sqllist[sql_id]
+            sql_id= nil
+            type=nil
+            sqlcnt += 1
+          else
+            @sqllist[sql_id].sql << line.strip
+          end
+        else
+          next if line.strip =~/^\#/ # comment line
+          next if line.strip.eql?("")
+          if line =~ /@(.+):([^\s]+)/ # sql definition
+            sql_id = $1.to_sym
+            type = $2.to_sym
+            throw "Unknown Type : #{type.to_s} in line(#{$.})" unless @types.include?(type)
+            @sqllist[sql_id] = SqlInfo.new(sql_id,type,[])
+          else
+            throw "Wrong SQL Definition : line(#{$.})"
+          end
+        end
+      end
+      if sql_id
+        throw "Unexpected end of sql : line(#{$.})"
+      end
+      @files << file
+    end
+
+    def create_method sqlInfo
+      method_def = []
+      method_def << "def #{sqlInfo.id} params={}"
+      method_def <<   "sqlInfo = @sqllist['#{sqlInfo.id}'.to_sym]"
+      case sqlInfo.type
+      when :list
+        method_def << "if block_given?"
+        method_def << "  @sqlexec.select_all(sqlInfo.sql, params) {|row| yield row}"
+        method_def << "else"
+        method_def << "  @sqlexec.select_all(sqlInfo.sql, params)"
+        method_def << "end"
+      when :row
+        method_def << "@sqlexec.select_row(sqlInfo.sql, params)"
+      when :value
+        method_def << "@sqlexec.select_value(sqlInfo.sql, params)"
+      when :execute
+        method_def << "@sqlexec.execute(sqlInfo.sql, params)"
+      end
+      method_def << "end"
+      self.class.class_eval(method_def.join("\n"))
+    end
+
+    def method_missing sym, *args, &b
+      try_pending "Undefined Databaseaccess : #{sym}"
+    end
+  end
+end

data/lib/puppet7/sql_exec.rb

@@ -0,0 +1,148 @@
+# coding: utf-8
+
+require "dbi"
+
+module Puppet7
+  class SQLExec
+    attr_reader :db_url, :user, :password, :encoding
+
+    def initialize db_url, user, passwd, encoding = "utf8"
+      if RUBY_VERSION < "1.9"
+        raise "#{self.class} support ruby1.9 or greater. but you have #{RUBY_VERSION} version of ruby"
+      end
+      @db_url, @user, @password = db_url, user, passwd
+      @encoding = encoding
+    end
+
+    def select_all sql, params={}
+      result = []
+      connect do |dbh|
+        prep_sql, binds = parameterize(sql, params)
+        sth = dbh.prepare(prep_sql)
+        sth.execute(*binds)
+        record = self.class.record(sth.column_names)
+        sth.fetch do |row|
+          r = record.new(*row.to_a.collect{|c|
+              if String === c
+                c.force_encoding(encode_str)
+              else
+                c
+              end
+            })
+          if block_given?
+            yield r
+          else
+            result << r
+          end
+        end
+      end
+      return result
+    end
+
+    def select_row sql, params={}
+      connect do |dbh|
+        prep_sql, binds = parameterize(sql, params)
+        sth = dbh.prepare(prep_sql)
+        sth.execute(*binds)
+        record = self.class.record(sth.column_names)
+        return record.new(*sth.fetch.to_a)
+      end
+    end
+
+    def select_value sql, params={}
+      connect do |dbh|
+        prep_sql, binds = parameterize(sql, params)
+        sth = dbh.prepare(prep_sql)
+        sth.execute(*binds)
+        return sth.fetch[sth.column_names[0]]
+      end
+    end
+
+    def execute sql, params={}
+      connect do |dbh|
+        prep_sql, binds = parameterize(sql, params)
+        sth = dbh.prepare(prep_sql)
+        sth.execute(*binds)
+        return sth.rows
+      end
+    end
+
+    def tables
+      tables =nil
+      connect do |dbh|
+        tables = dbh.tables
+      end
+      return tables
+    end
+
+    def table_encoding table_name
+      sql = "select coll.character_set_name
+    from information_schema.tables tabs
+    join information_schema.collations coll
+    on tabs.table_collation = coll.collation_name
+    where table_name = &table
+    and table_schema = &db"
+      select_value(sql, {:table=>table_name, :db=>@database})
+    end
+
+    def connect
+      unless @dbh && @dbh.connected?
+        @dbh = DBI.connect @db_url, @user, @password
+        @dbh.execute("set names #{@encoding.to_s}") # for mysql
+      end
+      if block_given?
+        yield @dbh
+        #dbh.disconnect
+      else
+        @dbh
+      end
+    end
+
+    private
+    def parameterize sql, params={}
+      mod_sql = "#{sql}"
+      params.each_pair do |pname, pvalue|
+        mod_sql.gsub!(/\$#{pname}[^a-zA-Z0-9._-]?/, pvalue.to_s)
+      end
+      bindvars = []
+      sqlsplit = []
+      sqlsplit << mod_sql.gsub(/(.*?)(\&[a-zA-Z][a-zA-Z0-9._-]*)/m) do |param|
+        sqlsplit << $1
+        sqlsplit << $2
+        ""
+      end
+      sqlsplit.collect! do |token|
+        if token =~ /^\&(.+)/
+          raise "No Value for '#{$1}" unless params.member?($1.to_sym)
+          value = params[$1.to_sym]
+          value = _encode(value) if value.kind_of? String
+          bindvars << value
+          "?"
+        else
+          _encode token
+        end
+      end
+
+      [sqlsplit.join, bindvars]
+    end
+
+    def self.record columns
+      @__records ||= {}
+      colsyms = columns.collect{|a| a.downcase.force_encoding(__ENCODING__).to_sym}
+      @__records[colsyms] ||= Struct.new(*colsyms)
+      @__records[colsyms]
+    end
+
+    def _encode str
+      str.encode(encode_str)
+    end
+
+    def encode_str
+      case @encoding.to_sym
+      when :utf8 then "UTF-8"
+      when :euckr then "EUC-KR"
+      else @encoding.to_s
+      end
+    end
+  end
+end

data/lib/puppet7/utils.rb

@@ -0,0 +1,72 @@
+# coding: utf-8
+
+require "nokogiri/css"
+
+module Puppet7
+  module Utils
+    URLInfo = Struct.new :url, :protocol, :baseurl, :domain, :port, :path, :query, :query_str
+    def parse_url url
+      urlinfo = URLInfo.new
+      urlinfo.url = url
+      if url =~ /^(http|https):\/\/([\w\d\.\_\-]+)(:\d+)?(\/[^?]*)(\?.*)?$/
+        urlinfo.protocol = $1
+        urlinfo.domain = $2
+        urlinfo.baseurl = "#{$1}://#{$2}#{$3}"
+        urlinfo.port = $3 || ""
+        urlinfo.path = $4 || ""
+        urlinfo.query_str = $5 || ""
+      elsif url =~ /^(\/[^\?]*)(\?.*)?$/
+        urlinfo.protocol = nil
+        urlinfo.domain = nil
+        urlinfo.baseurl = nil
+        urlinfo.port = nil
+        urlinfo.path = $1 || ""
+        urlinfo.query_str = $2 || ""
+      elsif url =~ /^(http|https):\/\/([\w\d\.\_\-]+)(:\d+)?$/
+        urlinfo.protocol = $1
+        urlinfo.domain = $2
+        urlinfo.baseurl = "#{$1}://#{$2}#{$3}"
+        urlinfo.port = $3 || ""
+        urlinfo.path = nil
+        urlinfo.query_str = ""
+      else
+        raise "Unexpected URL : #{url}"
+      end
+
+      # process query string
+      urlinfo.query = {}
+      urlinfo.query_str.gsub(/^\?/, "").split(/&/).each do |qr|
+        name, value = qr.split("=")
+        next unless name
+        value = value || ""
+        if urlinfo.query[name.to_sym]
+          urlinfo.query[name.to_sym] = [] << urlinfo.query[name.to_sym]
+          urlinfo.query[name.to_sym] << value
+        else
+          urlinfo.query[name.to_sym] = value
+        end
+      end
+      urlinfo
+    end
+
+		def by_xpath str
+			str
+		end
+
+		def by_id id
+			"//*[@id='#{id}']"
+		end
+
+		def by_link link_text
+			"//a[text()='#{link_text}']"
+		end
+
+		def by_input input_name
+			"//input[@name='#{input_name}']"
+		end
+
+    def by_css css_selector
+      Nokogiri::CSS.xpath_for(css_selector).first
+    end
+  end
+end

data/lib/puppet7.rb

@@ -0,0 +1,28 @@
+# coding:utf-8
+
+require "puppet7/configuration"
+require 'puppet7/utils'
+require "puppet7/puppet"
+
+require 'puppet7/extend'
+require 'puppet7/selenium_actions'
+require 'puppet7/selenium_locator_actions'
+require 'puppet7/element'
+require 'puppet7/page_part'
+require 'puppet7/page'
+require 'puppet7/domain'
+require "puppet7/selenium_support"
+require "puppet7/puppet_formatter"
+require "puppet7/puppet_report"
+require "puppet7/exceptions"
+require "puppet7/configuration"
+
+begin
+  # optional loading...
+  gem "dbi"
+  require "puppet7/sql_exec"
+  require "puppet7/sql_agent"
+rescue GEM::LoadError
+end
+
+