rest-object 0.0.1

data/lib/rest-object.rb

@@ -0,0 +1,59 @@
+# Module to be included for REST Object
+#
+require_relative 'rest-object/gree_json.rb'
+
+module RestObject
+
+    # response is a Net:HTTPResponse object returned from REST call
+    attr_reader   :response, :code, :body
+
+    def initialize(response)
+        @response = response
+        @code = response.code
+        @body = response.body
+    end
+
+    def is_restful?
+        begin
+            return (JSON.parse(@body).class == Hash)
+        rescue
+            return false
+        end
+    end
+
+    # Verify if @code is 200
+    def is_successful?
+        @code == "200"
+    end
+
+    # Verify if @code is 4xx
+    def is_client_error?
+    end
+
+    # Verify if @code is 5xx
+    def is_server_error?
+    end
+
+    # Verify API response body
+    def verify_rest_body(expected, content_type = :json)
+        if content_type == :json
+            GreeJson.check_json_response(expected, @body)
+        else
+            return (@body == expected)
+        end
+    end
+
+    # Verify API response header
+    def verify_rest_header(expected)
+    end
+
+end
+
+
+# Unit test
+if __FILE__ == $0
+    GreeLog.level = Logger::INFO
+    GreeLog.echo_to_screen = true
+
+end
+

data/lib/rest-object/gree_err.rb

@@ -0,0 +1,93 @@
+# convenience functions for dealing with errors and exceptions
+
+require 'pp'
+
+require_relative 'gree_ruby_extensions.rb'
+require_relative 'gree_logger.rb'
+
+module GreeErr
+
+    # Construct an error message string saying 2 things are not identical
+    def self.msg_not_identical(value_name, var1, var2)
+        return "#{value_name} is not identical: #1 = #{value_1}, #2 = #{value_2}"
+    end
+
+    # Construct an error message string saying something has an unsupported value
+    def self.msg_unsupported(value_name, value)
+        return "Unsupported #{value_name}: '#{value}'"
+    end
+
+    # Raise a RuntimeError when 2 things are not identical
+    def self.not_identical_raise(value_name, value_1, value_2)
+        raise RuntimeError, self.msg_not_identical(value_name, value_1, value_2), caller
+    end
+
+    def self.raise(*args)
+        _log_message = ""
+        # look for a backtrace to include
+        for _arg in args
+            if _arg.respond_to? :backtrace
+                _log_message << "  " << _arg.backtrace.join("\n  ")
+            end
+        end
+        # if no backtrace found, add generic
+        if _log_message == ""
+            _log_message << "  " << caller.join("\n  ")
+        end
+        _log_message = "Exception-> " + args.pretty_inspect + _log_message
+        GreeLog.error(previous_function_name + "()") {
+            _log_message
+        }
+        Kernel.raise *args
+    end
+
+    # Raise an ArgumentError when an argument has unsupported value
+    def self.unsupported_raise(value_name, value)
+        raise ArgumentError, self.msg_unsupported(value_name, value), caller
+    end
+
+    # Execute block, ignoring the specified exception type (default: all exceptions)
+    def self.with_ignored_exceptions(exception_types = StandardError)
+        begin
+            yield
+        rescue exception_types => _the_exception
+            # Ignore the exception
+        end
+    end
+
+end
+
+# ======================
+# SELF-TEST
+# ======================
+
+if $0 == __FILE__
+    def test
+        GreeLog.handler=Logger.new(
+            File.join(File.expand_path(File.dirname(__FILE__)), 'test-' + Time.now.strftime('%Y-%m-%d-%H%M%S') + '.log')
+        )
+
+        begin
+            GreeErr.raise 'this is an error message'
+        rescue
+        end
+
+        begin
+            GreeErr.raise ArgumentError
+        rescue
+        end
+
+        begin
+            GreeErr.raise ArgumentError, 'this is a message for ArgumentError exception'
+        rescue
+        end
+
+        begin
+            GreeErr.raise
+        rescue
+        end
+    end
+
+    test
+
+end

data/lib/rest-object/gree_json.rb

@@ -0,0 +1,79 @@
+# Utilities for JSON handling
+
+require_relative "gree_logger.rb"
+require 'json'
+
+module GreeJson
+
+    # Validate a JSON response, comparing to an expected hash
+    # TODO: add strict parm to check for extra keys
+    def self.check_json_response(expected, response)
+        begin
+            result = JSON.parse(response)
+            _validate_json_or_json_array(expected, result)
+        rescue => ex
+            GreeLog.puts "EXCEPTION: #{ex.message}\n"
+            GreeLog.puts "EXPECTED\n#{expected.inspect}\n"
+            GreeLog.puts "ACTUAL\n#{response}\nEND"
+            # rethrow the message to remove the recursive stack trace
+            raise ex.message
+        end
+    end
+
+    def self._validate_json_or_json_array(expected, actual)
+        if actual.class == Array
+            _validate_json_array(expected, actual, actual.count)
+        else
+            _validate_json(expected, actual)
+        end
+    end
+
+    def self._validate_json(expected, actual)
+        if actual.nil?
+            raise "missing field(s) in response: expected=#{expected} - actual == nil"
+        end
+        expected.each do |k, v|
+            a = actual[k.to_s]
+            #if a.nil?
+            if !actual.has_key?(k.to_s)
+                raise "missing \"#{k}\" property in JSON response, expected: #{v.inspect}"
+            end
+            case v
+                when Hash
+                    if a.class != Hash
+                        raise "got #{a.class} instead of JSON object for #{k}"
+                    end
+                    _validate_json(v, a)
+                when Array
+                    if a.class != Array
+                        raise "got JSON object instead of array for #{k}"
+                    end
+                    _validate_json_array(v, a, k.to_s)
+                when Regexp
+                    a.should match v
+                else
+                    a.should == v unless v == :any
+            end
+       end
+    end
+
+    def self._validate_json_array(expected, actual, k)
+        if actual.class != Array
+            raise "#{k} in response is not an array as expected"
+        end
+        if expected.count != actual.count
+            raise "Error in #{k} array: expected #{expected.count} items, got #{actual.count}"
+        end
+        expected.each_index do |i|
+            _validate_json(expected[i], actual[i])
+        end
+    end
+
+end
+
+
+# Unit test
+if __FILE__ == $0
+
+end
+

data/lib/rest-object/gree_logger.rb

@@ -0,0 +1,101 @@
+# Utilities for log handling
+
+require 'logger'
+require 'pp'
+
+class GreeLog
+
+    @@logger=nil
+    @@echo_to_screen = false
+
+    def self.close
+        @@logger.close
+        @@logger = nil
+    end
+
+    def self.echo_to_screen
+        return @@echo_to_screen
+    end
+
+    def self.echo_to_screen=(value)
+        @@echo_to_screen=value
+    end
+
+    def self.logger
+        return @@logger
+    end
+
+    def self.logger=(logger_object)
+        @@logger=logger_object
+    end
+
+    def self.logging?
+        return !@@logger.nil?
+    end
+
+    def self.method_missing(method_name, *method_args, &block)
+        if @@echo_to_screen
+            puts "[#{Time.now.strftime('%H:%M:%S')}]  #{method_name.to_s.upcase} -- #{previous_function_name}: #{method_args.inspect} #{(block ? '{' + block.to_s + '}' : '')}"
+        end
+        if @@logger
+            @@logger.progname = previous_function_name
+            @@logger.send(method_name, *method_args, &block)
+        end
+    end
+
+    # print out a message without escaping the the quotes, newlines ...
+    def self.puts(message)
+        if @@echo_to_screen
+           Kernel.puts "#{message}"
+        end
+        if @@logger
+            @@logger.progname = previous_function_name
+            @@logger.send("info", message)
+        end
+    end
+
+    # Returns the name of the function from which this method was called, by looking at the call stack. If call stack
+    # is empty, returns "(anonymous)"
+    #
+    #   def foo
+    #       puts current_function_name
+    #   end
+    #
+    #   foo -> "foo"
+    #
+    #   current_function_name -> "(anonymous)"
+    #
+    # Used for logging and error reporting, so that generic code can record the name of the currently running function.
+
+    def self.current_function_name
+        return caller()[0] =~ /in `([^']+)'/ ? $1 : '(anonymous)'
+    end
+
+    # Returns the name of the function two levels down in the call stack. If call stack
+    # has insufficient depth, returns "(anonymous)"
+    #
+    #   def foo
+    #       puts previous_function_name
+    #   end
+    #
+    #   def bar
+    #       foo
+    #   end
+    #
+    #   bar -> "bar"
+    #
+    #   foo -> "(anonymous)"
+    #
+    #   previous_function_name => "(anonymous)"
+    #
+    # Used for setting up a centralized error handler that calls a centralized logger.
+
+    def self.previous_function_name
+        if caller().length < 2
+            return '(anonymous)'
+        else
+            return caller()[1] =~ /in `([^']+)'/ ? $1 : '(anonymous)'
+        end
+    end
+
+end

data/lib/rest-object/gree_ruby_extensions.rb

@@ -0,0 +1,73 @@
+# Gree Ruby Extensions
+# This file provides various convenient extensions to Ruby's built-in objects and libraries
+
+unless defined? "INFINITY"
+    INFINITY = 1.0/0
+end
+
+unless defined? "NaN"
+    NaN = 0.0/0
+end
+
+class Array
+    # Same as <tt>Array.detect</tt>, but scans from end of array to beginning.
+    def reverse_detect(&block)
+        self.reverse_each {|_element|
+            if block.call(_element)
+                return _element
+            end
+        }
+        return nil
+    end
+end
+
+class Hash
+    def hash_value_missing?(key)
+        # test if key is missing, or key value is nil or empty string
+        return !self.has_key?(key) || self[key]=="" || self[key].nil?
+    end
+end
+
+# Returns the name of the function from which this method was called, by looking at the call stack. If call stack
+# is empty, returns "(anonymous)"
+#
+#   def foo
+#       puts current_function_name
+#   end
+#
+#   foo -> "foo"
+#
+#   current_function_name -> "(anonymous)"
+#
+# Used for logging and error reporting, so that generic code can record the name of the currently running function.
+
+def current_function_name
+    return caller()[0] =~ /in `([^']+)'/ ? $1 : '(anonymous)'
+end
+
+# Returns the name of the function two levels down in the call stack. If call stack
+# has insufficient depth, returns "(anonymous)"
+#
+#   def foo
+#       puts previous_function_name
+#   end
+#
+#   def bar
+#       foo
+#   end
+#
+#   bar -> "bar"
+#
+#   foo -> "(anonymous)"
+#
+#   previous_function_name => "(anonymous)"
+#
+# Used for setting up a centralized error handler that calls a centralized logger.
+
+def previous_function_name
+    if caller().length < 2
+        return '(anonymous)'
+    else
+        return caller()[1] =~ /in `([^']+)'/ ? $1 : '(anonymous)'
+    end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: rest-object
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Chaoyi Chen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-27 00:00:00.000000000 Z
+dependencies: []
+description: REST API Object DSL for RESTful API testing
+email: chaoyi.chen@gree.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rest-object.rb
+- lib/rest-object/gree_logger.rb
+- lib/rest-object/gree_ruby_extensions.rb
+- lib/rest-object/gree_json.rb
+- lib/rest-object/gree_err.rb
+homepage: http://rubygems.org/gems/hola
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: REST API Object DSL for RESTful API testing
+test_files: []