webtester 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 42dc7b520b4d46aa37845f7fa640ffd702f5d7f3
+  data.tar.gz: 15456b956f5951d26cfd613a59ed1f7b4b9cf65d
+SHA512:
+  metadata.gz: a2ea168e56940107ff533fe02e5bf33dcbc99e02016c4c17f190f6e1e1f849eeaa3f4596e1509321c67b9b5ac9f69073eb7c11ebb557f8c2eebf9928fe9f62c0
+  data.tar.gz: 84a63c6c4566423ea29e741850b8b3ecac266e53fe60a9d42e9f247844a393ade37d8a29eece7dedf137e381ce1299785ce6ec300c8fab35aa5c5485e4b10469

data/lib/cookie.rb

@@ -0,0 +1,60 @@
+module WT
+    class Cookie
+
+        attr_accessor :name
+        attr_accessor :value
+        attr_accessor :domain
+        attr_accessor :path
+        attr_accessor :secure
+        attr_accessor :expires
+        attr_accessor :http_only
+
+        def initialize
+            @domain     = nil
+            @expires    = nil
+            @path = ''
+            @http_only = false
+            @secure = false
+        end
+
+        def self.parse(str)
+            cookie = Cookie.new
+
+            parts = str.split ';'
+
+            parts.each do |part|
+                part.strip!
+
+                if part.match /^HttpOnly$/i
+                    cookie.http_only = true
+                elsif part.downcase == 'secure'
+                    cookie.secure = true
+                elsif part.match /^Domain=(.*)$/i
+                    cookie.domain = "#{$1}"
+                elsif part.match /^Path=(.*)$/i
+                    cookie.path = "#{$1}"
+                elsif part.match /^Expires=(.*)$/i
+                    cookie.expires = "#{$1}"
+                elsif part.match /^(.*)=(.*)$/i
+                    cookie.name  = "#{$1}"
+                    cookie.value = "#{$2}"
+                end
+            end
+
+            return cookie
+        end
+
+        def to_s
+            attrs = []
+
+            attrs << "#{@name}=#{@value}; "
+            attrs << "Path=#{@path}; "
+            attrs << "Expires=#{@expires}; " if @expires
+            attrs << "Domain=#{@domain}; " if @domain
+            attrs << "secure; " if @secure
+            attrs << "HttpOnly" if @http_only
+
+            attrs.join
+        end
+    end
+end

data/lib/request.rb

@@ -0,0 +1,81 @@
+require 'net/http'
+require 'uri'
+
+require 'result'
+require 'cookie'
+
+module WT
+    class Request
+
+        attr_accessor :request_type
+        attr_accessor :request_url
+        attr_accessor :request_data
+        attr_accessor :follow_redirect
+        attr_accessor :headers
+
+        def initialize(request_type, request_url, request_data = {})
+            @request_type = request_type
+            @request_url  = request_url
+            @request_data = request_data
+            @follow_redirect = true
+            @headers = {}
+        end
+
+        def exec
+            if @request_type == "GET" 
+                self.get
+            elsif @request_type == "POST"
+                self.post
+            end
+        end
+
+        def get
+            url = URI.parse @request_url
+            req = Net::HTTP::Get.new(url.to_s)
+
+            return self.send_request url.host, url.port, req
+        end
+
+        def post
+            url = URI.parse @request_url
+            req = Net::HTTP::Post.new(url.to_s)
+
+            return send_request url.host, url.port, req
+        end
+
+        def send_request(host, port, req)
+            begin
+                req['Cookie'] = @headers['Cookie'].to_s if @headers['Cookie']
+                req.body = URI.encode_www_form @request_data if @request_data.length > 0
+
+                http = Net::HTTP.new host, port
+
+                response = http.request req
+
+                if not response
+                    raise "Could not connect to host: #{host}:#{port}"
+                end
+
+                result = WT::Result.new response
+                result.request_type = @request_type
+                result.request_url  = @request_url
+
+                if @follow_redirect and (response.code == '301' or response.code == '302')
+                    @request_data = {}
+                    @request_url = response['Location']
+                    return self.get
+                end
+
+                return result
+            rescue Exception => e
+                result = WT::Result.new '0', 'empty', nil
+                result.request_type = @request_type
+                result.request_url  = @request_url
+                result.message      = e
+
+                return result
+            end
+        end
+    end
+
+end

data/lib/result.rb

@@ -0,0 +1,12 @@
+module WT
+    class Result
+        attr_accessor :content_type
+        attr_accessor :request_type
+        attr_accessor :request_url
+        attr_accessor :response
+
+        def initialize(response)
+            @response = response
+        end
+    end
+end

data/lib/test.rb

@@ -0,0 +1,139 @@
+require 'request'
+require 'cookie'
+
+# = Example
+#
+#  #!/usr/bin/env ruby
+#
+#  require 'webtester'
+#  
+#  # 
+#  # create a new test called "Login Test"
+#  #
+#  
+#  loginTest = WT::Test.new "Login Test"
+#  
+#  #
+#  # create 2 requests. The first one will access login page through a GET
+#  # request page to receive the session token and a View State
+#  # obtained from the body of the result.
+#  # The second will send the POST request with all the parameters.
+#  #
+#  
+#  req1 = WT::Request.new "GET", "http://example.com/login.jsf"
+#  req2 = WT::Request.new "POST", "http://example/login.jsf", 
+#                                        { 'form' => 'form',
+#                                          'form:login' => 'user1',
+#                                          'form:senha' => 'passwd',
+#                                          'form:logar.x' => '0',
+#                                          'form:logar.y' => '0',
+#                                          'javax.faces.ViewState' => "$?" }
+#  
+#  #
+#  # if the HTTP Response code be 301 or 302 (Redirect), it will not
+#  # follow the 'Location' HTTP Header. If follow_redirect be 'true',
+#  # it would send another GET request to the address contained on
+#  # the HTTP Header and would return the response of the second
+#  # Request.
+#  #
+#  
+#  req2.follow_redirect = false
+#  
+#  #
+#  # Add the requests req1 and req2 to the "Login Test"
+#  #
+#  
+#  loginTest.add_request(req1)
+#  loginTest.add_request(req2)
+#  
+#  #
+#  # Execute the test. The requests will be sent in the insertion
+#  # order (add_request).
+#  #
+#  
+#  loginTest.exec do |result|
+#    puts "#{result.request_type} #{result.request_url} #{result.response.code} [#{result.response.message}]"
+#  end
+#
+
+module WT
+    class Test
+        attr_accessor :name
+        attr_accessor :requests
+        attr_accessor :cookie
+        attr_accessor :form_fields
+
+        def initialize(name)
+            @name = name
+            @requests = []
+            @cookie = nil
+            @form_fields = {}
+        end
+
+        def add_request(request)
+            @requests << request
+        end
+
+        def exec
+            @requests.each do |req|
+                req.headers['Cookie'] = @cookie if @cookie
+
+                @form_fields.each do |name, value|
+                    req.request_data[name].gsub! "$?", "#{value}" if req.request_data and req.request_data[name]
+                end
+
+                result = req.exec
+
+                @cookie = WT::Cookie.parse result.response['Set-Cookie'] if result.response['Set-Cookie']
+                @form_fields = find_form_fields(result.response.body)
+
+                yield result
+
+                break if result.response.code != '200'
+            end
+        end
+
+        private
+
+        def find_form_fields(content)
+
+            form_fields = {}
+
+            str = content
+
+            while true
+                sidx = str.index('<input')
+
+                break if !sidx
+
+                str = str[sidx,str.length]
+
+                eidx = str.index('>')
+
+                break if !eidx
+
+                attrs = extract_form_field_attrs "#{str[0, eidx+1]}"
+
+                if attrs['name'] && attrs['value']
+                    form_fields[attrs['name']] = attrs['value']
+                end
+
+                str = str[eidx, str.length]
+            end
+
+            return form_fields
+        end
+
+        def extract_form_field_attrs(str)
+            attrs = {}
+            regexp=/<input\s+.*(name|value)="([^"]*)".*\s+(name|value)="([^"]*)"\s*.*\/>/
+
+            str.match(regexp) do
+                attrs["#{$1}"] = "#{$2}"
+                attrs["#{$3}"] = "#{$4}"
+            end
+
+            return attrs
+        end
+    end
+end

data/lib/webtester.rb

@@ -0,0 +1,4 @@
+require 'test'
+require 'request'
+require 'result'
+require 'cookie'

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: webtester
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Diego F. Nascimento
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-07 00:00:00.000000000 Z
+dependencies: []
+description: " A simple API to create HTTP Request tests. "
+email: diego.fnascimento@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cookie.rb
+- lib/request.rb
+- lib/result.rb
+- lib/test.rb
+- lib/webtester.rb
+homepage: http://rubygems.org/gems/webtester
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Web Application Request Tester
+test_files: []