resat 0.7.0

data/schemas/config.yaml

@@ -0,0 +1,48 @@
+# == Synopsis
+#
+#   This file contains the Kwalify YAML schema for the resat config file
+#
+#   The resat config file is used to specify the API URI components as
+#   well as any required auxiliary information (such as username/password)
+#
+#   The 'params' and 'headers' collections define request parameters and 
+#   headers that will be sent with every API calls by default.
+# 
+#   The 'variables' collection define global variables and their values.
+#   The 'output' field defines the path to the file where extracted
+#   variables should be saved if the corresponding 'save' field in the 
+#   scenario is true.
+#   The 'input' field defines the path to the file where variables are
+#   defined that should be loaded prior to executing any scenario.
+#   Both the output and input file use YAML to serialize variables so that
+#   a file produced as an output of resat can be later used as input.
+#
+# == Note
+#
+#  All the URI components defined in the Config file may be overridden by
+#  each request in the scenario.
+
+# Schema for resat configuration
+type:  map
+class: Resat::Config
+mapping:
+    "host":     { type: str, required: yes } # Default host
+    "port":     { type: int }                # Default port (optional)
+    "base_url": { type: str }                # Default base URL (optional)
+    "use_ssl":  { type: bool, default: no }  # http or https? (http by default)
+    "username": { type: str }                # Basic auth username (optional)
+    "password": { type: str }                # Basic auth password (optional)
+    "params":                                # Parameters used for all requests
+        &name_value_pairs
+        type: seq
+        sequence:
+            - type: map
+              mapping: 
+                  "name":  { type: str, required: yes, unique: yes }
+                  "value": { type: str, required: yes }
+    "headers":   *name_value_pairs           # Headers used for all requests
+    "delay":    { type: str }                # Delay in seconds before each request (integer or range)
+    "variables": *name_value_pairs           # Global variables
+    "output":   { type: str }                # Path to variables save file
+    "input":    { type: str }                # Path to variables load file
+

data/schemas/scenarios.yaml

@@ -0,0 +1,169 @@
+# == Synopsis
+#   This file contains the Kwalify YAML schema for resat test scenarios.
+#   Scenarios consists of API requests and responses validation.
+#
+#   A scenario may include other scenarios in which case all the included
+#   scenarios steps will be executed first even if the included scenario
+#   is marked as 'ignore' (that way it becomes possible to define
+#   include-only scenarios).
+#
+#   Each step may define guards, that is conditions that must be validated
+#   before the flow can proceed. These conditions may apply to the response
+#   header or body and may define a pattern that a given field must validate
+#   for the guard to be enabled (and the flow to proceed). If no pattern is
+#   specified then all that is required is for the call to be successful. 
+#   During execution a guard will re-send the same request until the condition
+#   gets fulfilled or it timeouts.
+#   
+#   API responses bodies and headers can optionally be run through filters.
+#   Filters can provide additional validation and can also initialize variables
+#   from the response. These variables can the be used in headers and parameters
+#   to later API requests as well as patterns used for validation and extraction.
+#
+#   Variables are initialized via extractors defined in filters. Extractors
+#   may use a regular expression with a capturing group. The variable is 
+#   initialized with the first capturing group match. If no regular expression
+#   is specified then the whole field is stored in the given variable.
+#
+#   Fields in headers are identified by name while fields in response bodies 
+#   are identified by their XPath e.g.:
+#
+#   deployments/deployment/servers/server/state
+#
+#   Filters validation is done through regular expressions validators and/or
+#   checking whether a field is empty. All validators regular expressions must
+#   match for the validation to pass. The validation will be applied to all 
+#   elements matching the field XPath in the case of validators applied to a
+#   response body.
+#
+#   To use a variable simply prefix its name with the '$' character e.g.:
+#
+#   # Filter definition for extracting 'server_id' variable:
+#   target: header
+#   extractors:
+#   - field:    location
+#     pattern:  '.*\/servers\/(\d+)$'
+#     variable: server_id
+#   
+#   # API call definition using the 'server_id' variable:
+#   operation: show
+#   resource:  server
+#   id:        $server_id
+#
+#   Finally, API responses can also be run through handlers. Handlers have
+#   access to the raw request and response for processing. The scenario
+#   specifies the name of the module that implements the handler. The module
+#   should expose a 'process' method taking two arguments: the underlying
+#   HTTP request and corresponding response.
+
+# Schema for scenarios definitions
+type:  map
+class: Resat::Scenario
+mapping:
+  "name":   { type: str, required: yes }                                        # Scenario name
+  "config": { type: str }                                                       # Path to config file
+  "ignore": { type: bool, default: no }                                         # Ignore scenario?
+  "includes":                                                                   # Included scenarios if any
+    type: seq
+    sequence:
+      - type: str
+  "steps":                                                                      # Scenario steps definition
+    type: seq
+    sequence:
+      - type: map
+        class: Resat::Step
+        mapping:
+#------------------------------------------------------------------------------------------------------------------------          
+          "request":                                                             # API REQUEST DEFINITION
+            type:  map
+            class: Resat::ApiRequest
+            mapping:
+              "host":      { type: str }                                         # Request host (config override)
+              "port":      { type: str }                                         # Request port (config override)
+              "base_url":  { type: str }                                         # Request base URL (config override)
+              "use_ssl":   { type: bool }                                        # http or https (config override)
+              "username":  { type: str }                                         # Basic auth username (config override)
+              "password":  { type: str }                                         # Basic auth password (config override)
+              "operation": { enum: [create, index, show, update, destroy] }      # Request operation
+              "custom":                                                          # Custom operation
+                type:  map
+                class: Resat::CustomOperation
+                mapping:
+                  "name":      { type: str, required: yes }                      # Custom operation name
+                  "type":      { enum: [get, post, put, delete], required: yes } # Custom operation request type
+                  "separator": { type: str, default: / }                         # Separator between base URI and operation name
+              "resource":  { type: str, required: yes }                          # Request resource
+              "id":        { type: str }                                         # Request resource id
+              "format":    { enum: [js, xml, html], default: xml }               # Request format (only applies to GET requests)
+              "delay":     { type: str}                                          # Delay before request is made (integer or range)
+              "params":                                                          # Request body parameters
+                &name_value_pairs
+                type: seq
+                sequence:
+                  - type: map
+                    mapping: 
+                      "name":  { type: str, required: yes, unique: yes }
+                      "value": { type: str, required: yes }
+              "headers": *name_value_pairs                                       # Request headers
+              "valid_codes":                                                     # List of valid response codes (all 2xx by default)
+                type: seq
+                sequence:
+                  - type: int
+#------------------------------------------------------------------------------------------------------------------------          
+          "guards":                                                              # GUARDS DEFINITION
+            type: seq
+            sequence:
+              - type:  map
+                class: Resat::Guard
+                mapping:
+                  "name":    { type: str, required: yes }
+                  "target":  { enum: [header, body] }                            # Guard target (response header or body)
+                  "field":   { type: str }                                       # Field guard applies to
+                  "status":  { type: int }
+                  "pattern": { type: str }                                       # Pattern field should match if any
+                  "period":  { type: int, default: 5 }                           # Period between API requests
+                  "timeout": { type: int, default: 120 }                         # Guard timeout 
+#------------------------------------------------------------------------------------------------------------------------          
+          "filters":                                                             # FILTERS DEFINITION
+            type: seq
+            sequence:
+              - type:  map
+                class: Resat::Filter
+                mapping:
+                  "name":     { type: str, required: yes }                       # Filter name (used for logging)
+                  "target":   { enum: [header, body], required: yes }            # Filter target (response header or body)
+                  "is_empty": { type: bool, default: no }                        # Check target is (not) empty
+                  "required_fields":                                             # List of target's required fields
+                    type: seq
+                    sequence:
+                      - type: str
+                  "validators":                                                  # List of validators
+                    type: seq
+                    sequence:
+                      - type:  map
+                        class: Resat::Validator
+                        mapping:
+                          "field":    { type: str, required: yes }               # Field validator applies to
+                          "is_empty": { type: bool, default: no }                # Check field is (not) empty
+                          "pattern":  { type: str }                              # Regular expression field must match
+                  "extractors":                                                  # List of extractors
+                    type: seq
+                    sequence:
+                      - type:  map
+                        class: Resat::Extractor
+                        mapping:
+                          "field":    { type: str, required: yes }               # Field extractor applies to
+                          "pattern":  { type: str, pattern: /.*\(.*\).*/ }       # Pattern used to extract data (if any)
+                          "variable": { type: str, required: yes, unique: yes }  # Variable extracted data should be stored in
+                          "save":     { type: bool, default: no }                # Whether variable should be saved in output file
+                          "export":   { type: bool, default: no }                # Whether variable should be exported so that other
+                                                                                 # scenarios in same execution can use it
+#------------------------------------------------------------------------------------------------------------------------          
+          "handlers":                                                            # HANDLERS DEFINITION
+            type: seq
+            sequence:
+              - type:  map
+                class: Resat::Handler
+                mapping:
+                  "name":     { type: str, required: yes }                       # Handler name (used for logging)
+                  "module":   { type: str, required: yes }                       # Handler moduler name

data/schemas/variables.yaml

@@ -0,0 +1,18 @@
+# == Synopsis
+#
+#   This file contains the Kwalify YAML schema for files containing serialized
+#   variables.
+#
+#   resat scenarios may define filters with extractors that can save the
+#   extracted value to an output file specified in the config file.
+#
+#   variables are serialized into a name value pairs YAML sequence.
+#
+
+# Schema for serialized variables
+type:  seq
+sequence:
+  - type: map
+    mapping: 
+        "name":  { type: str, required: yes, unique: yes }
+        "value": { type: str, required: yes }

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: resat
+version: !ruby/object:Gem::Version 
+  version: 0.7.0
+platform: ruby
+authors: 
+- Raphael Simon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-03 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: kwalify
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.7.1
+    version: 
+description: Web scripting for the masses
+email: raphael@rightscale.com
+executables: 
+- resat
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- bin/resat
+- lib/api_request.rb
+- lib/config.rb
+- lib/engine.rb
+- lib/file_set.rb
+- lib/filter.rb
+- lib/guard.rb
+- lib/handler.rb
+- lib/kwalify_helper.rb
+- lib/log.rb
+- lib/net_patch.rb
+- lib/rdoc_patch.rb
+- lib/resat.rb
+- lib/scenario_runner.rb
+- lib/variables.rb
+- schemas/config.yaml
+- schemas/scenarios.yaml
+- schemas/variables.yaml
+- examples/rightscale/additional/run_server.yml
+- examples/rightscale/config/resat.yaml
+- examples/rightscale/README.rdoc
+- examples/rightscale/scenarios/create_server.yml
+- examples/rightscale/scenarios/delete_server.yml
+- examples/rightscale/scenarios/list_servers.yml
+- examples/twitter/additional/follow.yml
+- examples/twitter/additional/send_message.yml
+- examples/twitter/config/resat.yaml
+- examples/twitter/output.yml
+- examples/twitter/README.rdoc
+- examples/twitter/scenarios/timelines.yml
+- examples/twitter/scenarios/tweet.yml
+has_rdoc: true
+homepage: http://github.com/raphael/resat
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Web scripting for the masses
+test_files: []
+