scooter 0.0.0 → 3.2.19

data/README.md

@@ -1,21 +1,80 @@
 # Scooter
 
-TODO: Write a gem description
+#### Table of Contents
 
-## Installation
+1. [Overview](#overview)
+2. [Usage](#usage)
+3. [Versioning](#versioning)
+4. [Releasing](#releasing)
+  * [Pushing a new version to the internal rubygems mirror](#pushing-a-new-version-to-the-internal-rubygems-mirror)
+5. [Rdocs](#rdocs)
+6. [Contributing](#contributing)
 
-Add this line to your application's Gemfile:
+## Overview
 
-    gem 'scooter'
+Scooter is a ruby gem developed by QA to facilitate http traffic between the
+test runner and a Puppet Enterprise Installation–specifically the services
+available in the pe-console-services process: Classifier, RBAC, and Activity
+Service.
 
-And then execute:
+## Usage
 
-    $ bundle
+Scooter only supports versions of Puppet Enterprise 3.7 and higher. Scooter is only available on the internal server, rubygems.delivery.puppetlabs.net.
 
-Or install it yourself as:
+To install Scooter, simply use the gem command with the source flag set to the internal rubygems mirror–remember that you will have to be on Puppet's DNS to see the mirrored gem server.
 
-    $ gem install scooter
+```
+$ gem install scooter --source http://rubygems.delivery.puppetlabs.net
+```
 
-## Usage
+Scooter is currently divvied into the following sections:
+
+ - [HttpDispatchers](docs/http_dispatchers.md) – These are modules that can be mixed into classes that represent real users: whitelisted certificate users, local console users, or users connected through an LDAP directory. Currently, there is only one dispatcher currently defined--ConsoleDispatcher–but there could be new dispatchers created to facilitate traffic to other products, such as Puppet Server and PuppetDB.
+
+ - LDAPdispatcher – This class extends the Net::LDAP library, which is a requirement to for RBAC testing with LDAP fixtures.
+ - Utilities – Currently, this houses random string generators and convenience methods to use beaker to acquire certificates to impersonate whitelisted certificate users.
+
+## Versioning
+
+Scooter supports semantic versioning, with any 1.x release of scooter supporting all PE versions between 3.7.x and 4.0.
+
+If you are looking for scooter support for PE 4.0 aka shallow gravy, please use any scooter version that is 2.x. Routes to the services changed between PE 3.7 and PE 4.0, requiring a major version bump of scooter between those versions.
+
+## Releasing
+
+The plan is to release Scooter at a regular cadence, probably once a week. Early on, we will release more often, as the port from qatests is not totally complete. Early feedback may significantly change the structure, so be cautious about building any significant dependencies yet. Once the dust has settled, a 1.0 release will be cut and support normal semantic versioning.
+
+Discussion is still ongoing about whether this library will be publicly available on rubygems or not. Please feel free to email the the QA team for any further information regarding a public release.
+
+ - One issue blocking a public release of Scooter is to avoid possibly leaking information about unreleased features/products that Scooter might have information on. This could be mitigated by careful version control of Scooter, releasing it to the public only periodically, but releasing internally at a more frequent basis for internal testing.
+
+ - Should the gem accept PR's from the public? That seems to require significant overhead in terms of testing and stability of PR's. Perhaps make the gem public without accepting PR's from the public? Make the gem available on rubygems.org while the repo stays private?
+
+### Pushing a new version to the internal rubygems mirror
+
+ 1. Log into jenkins-qe
+
+ 2. Trigger the Scooter Release Pipeline
+
+   a. The pipeline is responsible for checking in the version bump, generating a new HISTORY.md file, creating and pushing the gem
+
+   b. Select an appropriate version number *** WARNING - whatever version number you select will be auto-created and pushed liver, BE CAREFUL ***
+
+## Rdocs
+
+Much of the documentation of Scooter is embedded in the ruby code itself, using rdoc standards for documentation. Currently, Puppet does not have an internal server delivering yard documentation; if you wish to view the rdocs, you must build it out yourself after you have downloaded the gem.
+
+```
+prompt:~$ yard server --gems
+
+#>> YARD 0.8.7.4 documentation server at http://0.0.0.0:8808
+#Thin web server (v1.6.2 codename Doc Brown)
+#Maximum connections set to 1024
+#Listening on 0.0.0.0:8808, CTRL+C to stop
+#
+#goto: http://0.0.0.0:8808/docs/scooter/frames
+```
+
+## Contributing
 
-TODO: Write usage instructions here
+You are encouraged to fork and submit PR's to Scooter. Sam Woods or Tony Vu are your best bet for getting a PR merged in; that list will grow as QA adds more regular contributors to the repo.

data/Rakefile

@@ -1,2 +1,9 @@
 require "bundler/gem_tasks"
 
+require 'rspec/core/rake_task'
+
+desc "Run spec tests"
+RSpec::Core::RakeTask.new(:test) do |t|
+  t.rspec_opts = ['--color']
+  t.pattern = 'spec/'
+end

data/docs/http_dispatchers.md

@@ -0,0 +1,79 @@
+## HttpDispatchers
+
+### Overview
+
+Currently, there is only one class available in this section, the [`ConsoleDispatcher`](#console-dispatcher). A few, general ideas about the organization and procedure are as follows (All of this page needs better organization):
+
+The underlying basis for the `ConsoleDispatcher` is the [Faraday](https://github.com/lostisland/faraday) library. A `Faraday::Connection` object should be utilized, probably as a `@connection` object defined as an `attr_accessor` for any other new httpdispatchers.
+
+An `HttpDispatcher` should include modules representing the products/services and a mechanism for changing the versions of the service.
+
+Method names at the service level, should, in general, not use the `@connection` object but use the methods defined in the version module; they do not necessarily need to be representative of the endpoints of the service.
+
+Method names defined in the version module should be representative of the endpoints of the service.
+
+```
+├── classifier
+│   └── v1
+│       └── v1.rb
+├── classifier.rb
+├── consoledispatcher.rb
+├── rbac
+│   └── v1
+│       ├── directory_service.rb
+│       └── v1.rb
+└── rbac.rb
+```
+
+#### Why Faraday and not HTTParty?
+
+Faraday was designed with the concept of middleware–classes that you can add to your connection stack to act on requests and responses. That middleware stack has proven to be very valuable for dealing with redundant methods for dealing with API calls, while still retaining much of the versatility that HTTParty had. Faraday's middleware also allows for easy inclusion of other independent libraries, such as the Faraday cookie jar that the ConsoleDispatcher uses for its default connection.
+
+### Console Dispatcher
+
+The `ConsoleDispatcher` is designed to speak to any of the services packaged up in pe-console-services: Node Classifer, RBAC, and Activity Service. Beyond those services, the Console Dispatcher also handles connecting to the /auth endpoints, handling sessions and the CSRF token if necessary.
+
+#### Certificate Dispatcher
+
+``` ruby
+require 'scooter'
+
+#example beaker config
+#HOSTS:
+#  ubuntu1404:
+#    vmname: ubuntu-1404
+#    roles:
+#      - master
+#      - agent
+#      - database
+#      - dashboard
+#    platform: ubuntu-14.04-amd64
+
+certificate_dispatcher = Scooter::HttpDispatchers::ConsoleDispatcher.new(dashboard)
+```
+
+A `ConsoleDispatcher` assumes it is a certificate dispatcher if no credentials are passed in during initialization. As a certificate dispatcher, you do not need to maintain a session or signin. Once created, a certificate dispatcher talks directly to the services, defined by the dashboard object passed in.
+
+#### Credential Dispatcher
+
+``` ruby
+require 'scooter'
+
+#example beaker config
+#HOSTS:
+#  ubuntu1404:
+#    vmname: ubuntu-1404
+#    roles:
+#      - master
+#      - agent
+#      - database
+#      - dashboard
+#    platform: ubuntu-14.04-amd64
+
+
+certificate_dispatcher = Scooter::HttpDispatchers::ConsoleDispatcher.new(dashboard,
+    login: 'admin',
+    password: 'password')
+```
+
+A `ConsoleDispatcher` assumes it is a credential dispatcher if credentials–login and password–are passed in as parameters during creation. As a credential dispatcher, you will need to successfully signin to get a session to make further successful calls to any of the services.

data/lib/scooter.rb

@@ -1,5 +1,13 @@
-require "scooter/version"
+require 'scooter/version'
+require 'beaker'
+require 'net/ldap'
+require 'faraday'
+require 'faraday_middleware'
+require 'faraday-cookie_jar'
+require 'nokogiri'
 
 module Scooter
-  # Your code goes here...
-end
+  %w( utilities httpdispatchers ldap ).each do |lib|
+    require "scooter/#{lib}"
+  end
+end

data/lib/scooter/httpdispatchers.rb

@@ -0,0 +1,12 @@
+%w( httpdispatcher consoledispatcher puppetdbdispatcher orchestratordispatcher).each do |lib|
+  require "scooter/httpdispatchers/#{lib}"
+end
+
+module Scooter
+  # This module is just the housing for the single dispatcher we have right now,
+  # ConsoleDispatcher, but should eventually include other dispatchers for other
+  # services that talk over http, such as the Puppet Server and PuppetDB.
+  module HttpDispatchers
+  end
+end
+

data/lib/scooter/httpdispatchers/activity.rb

@@ -0,0 +1,46 @@
+%w( v1 ).each do |lib|
+  require "scooter/httpdispatchers/activity/v1/#{lib}"
+end
+
+module Scooter
+  module HttpDispatchers
+    module Activity
+      include Scooter::HttpDispatchers::Activity::V1
+      include Scooter::Utilities
+
+      def set_activity_service_path(connection=self.connection)
+        set_url_prefix
+        connection.url_prefix.path = '/activity-api'
+      end
+
+      # Used to compare replica activity to master. Raises exception if it does not match.
+      # @param [BeakerHost] host_name
+      def activity_database_matches_self?(host_name)
+        original_host_name = self.host
+        begin
+          self.host = host_name.to_s
+          initialize_connection
+          other_rbac_events       = get_rbac_events.env.body
+          other_classifier_events = get_classifier_events.env.body
+        ensure
+          self.host = original_host_name
+          initialize_connection
+        end
+
+        self_rbac_events       = get_rbac_events.env.body
+        self_classifier_events = get_classifier_events.env.body
+
+        rbac_events_match       = other_rbac_events == self_rbac_events
+        classifier_events_match = other_classifier_events == self_classifier_events
+
+        errors = ''
+        errors << "Rbac events do not match\r\n" unless rbac_events_match
+        errors << "Classifier events do not match\r\n" unless classifier_events_match
+
+        @faraday_logger.warn(errors.chomp) unless errors.empty?
+        errors.empty?
+      end
+
+    end
+  end
+end

data/lib/scooter/httpdispatchers/activity/v1/v1.rb

@@ -0,0 +1,50 @@
+module Scooter
+  module HttpDispatchers
+    module Activity
+      # Methods here are generally representative of endpoints, and depending
+      # on the method, return either a Faraday response object or some sort of
+      # instance of the object created/modified.
+      module V1
+        # Gets events from classifier
+        #
+        # @param [Hash] filters query strings to filter the activity events:
+        # @option filters [String] :subject_type [optional; required only when subject_id is provided]
+        # @option filters [String] :subject_id [optional; comma-separated list of subject_ids]
+        # @option filters [String] :object_type [optional; required only when object_id is provided]
+        # @option filters [String] :object_id [optional; comma-separated list of object_ids]
+        # @option filters [String] :offset [optional; skip n event commits]
+        # @option filters [String] :limit [optional; return no more than n event commits; defaults to 1000]
+        # @return [Object] The events queried
+        def get_classifier_events(filters = {})
+          set_activity_service_path
+          @connection.get 'v1/events' do |request|
+            request.params['service_id'] = 'classifier'
+            filters.each { |param, value|
+              request.params[param] = value
+            }
+          end
+        end
+
+        # Gets events from rbac
+        #
+        # @param [Hash] filters query strings to filter the activity events:
+        # @option filters [String] :subject_type [optional; required only when subject_id is provided]
+        # @option filters [String] :subject_id [optional; comma-separated list of subject_ids]
+        # @option filters [String] :object_type [optional; required only when object_id is provided]
+        # @option filters [String] :object_id [optional; comma-separated list of object_ids]
+        # @option filters [String] :offset [optional; skip n event commits]
+        # @option filters [String] :limit [optional; return no more than n event commits; defaults to 1000]
+        # @return [Object] The events queried
+        def get_rbac_events(filters = {})
+          set_activity_service_path
+          @connection.get 'v1/events' do |request|
+            request.params['service_id'] = 'rbac'
+            filters.each { |param, value|
+              request.params[param] = value
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scooter/httpdispatchers/classifier.rb

@@ -0,0 +1,376 @@
+%w( v1 ).each do |lib|
+  require "scooter/httpdispatchers/classifier/v1/#{lib}"
+end
+module Scooter
+  module HttpDispatchers
+    # Methods added here are not representative of endpoints, but are more
+    # generalized to be helpers to to acquire/transform data, such as getting
+    # the uuid of a node group based on the name. Be cautious about using
+    # these methods if you are utilizing a dispatcher with credentials;
+    # the user is not guaranteed to have privileges for all the methods
+    # defined here, or the user may not be signed in. If you have a method
+    # defined here that is using the connection object directly, you should
+    # probably be using a method defined in the version module instead.
+    module Classifier
+
+      include Scooter::HttpDispatchers::Classifier::V1
+      include Scooter::Utilities
+      Rootuuid = '00000000-0000-4000-8000-000000000000'
+
+      def set_classifier_path(connection=self.connection)
+        set_url_prefix
+        connection.url_prefix.path = '/classifier-api'
+      end
+
+      # This returns a tree-like hash of all node groups in the classifier; each
+      # key is a uuid, each value is an array of direct children. If no direct
+      # children are found, the value is an empty array. This representation
+      # is useful for iterating over specific children of known node groups,
+      # and is using primarily in <tt>delete_node_group_descendents</tt> and
+      # <tt>delete_tree_recursion</tt>.
+      # === Example return hash for default PE Installation
+      #  { "00000000-0000-4000-8000-000000000000" => # root group with one child
+      #     ["6d37be98-42ee-400d-a66e-ebced989546c"],
+      #    "6d37be98-42ee-400d-a66e-ebced989546c" => # node group with 5 kids
+      #     ["42e385ca-8fb2-442d-a0af-3b14c86d321b",
+      #     "32e6a36d-59ad-44ea-8708-feb910907058",
+      #     "44ebbb50-501c-45f1-8c92-95d5b0313d24",
+      #     "58448b7d-3175-4695-ac32-31cf4ee25754",
+      #     "00350026-bfb6-4ce7-bd06-1a1cfea445f9",
+      #     "b6400234-2a61-4417-b85e-c2dcc123686b"],
+      #    "42e385ca-8fb2-442d-a0af-3b14c86d321b" => [], # childless node group
+      #    "32e6a36d-59ad-44ea-8708-feb910907058" => [],
+      #    "44ebbb50-501c-45f1-8c92-95d5b0313d24" => [],
+      #    "58448b7d-3175-4695-ac32-31cf4ee25754" => [],
+      #    "00350026-bfb6-4ce7-bd06-1a1cfea445f9" => [],
+      #    "b6400234-2a61-4417-b85e-c2dcc123686b" => [] }
+      def get_node_group_trees_of_direct_descendents
+        node_groups  = get_list_of_node_groups
+        groups       = node_groups.map { |each| [each['id'], each['parent']] }
+
+        # Constants for the array of tuples just created.
+        id           = 0
+        parent       = 1
+
+        # Create root node and insert it into the tree hash.
+        rootindex    = groups.find_index { |e| e[id] == e[parent] }
+        rootid       = (groups.delete_at(rootindex))[id]
+        tree         = Object::Hash.new
+        tree[rootid] = Object::Array.new
+
+        # Construct the rest of the tree as a hash of
+        # id => [ child1, child2,...] nodes.
+        groups.each do |g|
+          tree[g[id]] = Object::Array.new
+          if tree.has_key?(g[parent]) then
+            tree[g[parent]] << g[id]
+          else
+            tree[g[parent]] = Object::Array.new
+            tree[g[parent]] << g[id]
+          end
+        end
+        tree
+      end
+
+      # This method deletes all the descendents of the Rootuuid; the root group
+      # can never be deleted. If you are looking to clean out a system entirely,
+      # consider using <tt>import_baseline_hierarchy</tt> instead, as this
+      # method doesn't clean out any classes or other settings the root group
+      # might have.
+      def delete_all_node_groups
+        delete_node_group_descendents(get_node_group(Rootuuid))
+      end
+
+      # This takes an optional hash of node group parameters, and auto-fills
+      # any required keys for node group generation. It returns the response
+      # body from the server.
+      def create_new_node_group_model(options={})
+        # name, classes, parent are the only required keys
+        name               = options['name'] || RandomString.generate
+        classes            = options['classes'] || {}
+        parent             = options['parent'] || Rootuuid
+        rule               = options['rule']
+        id                 = options['id']
+        environment        = options['environment']
+        variables          = options['variables']
+        description        = options['description']
+        environment_trumps = options['environment_trumps']
+
+        hash = { "name"    => name,
+                 "parent"  => parent,
+                 "classes" => classes }
+
+        if environment_trumps
+          hash['environment_trumps'] = environment_trumps
+        end
+        if rule
+          hash['rule'] = rule
+        end
+        if environment
+          hash['environment'] = environment
+        end
+        if variables
+          hash['variables'] = variables
+        end
+        if description
+          hash['description'] = description
+        end
+        if id
+          hash['id'] = id
+        end
+
+        create_node_group(hash).env.body
+      end
+
+      alias_method :generate_node_group, :create_new_node_group_model
+
+      # This takes an optional hash of node group parameters. If a "name" option
+      # is provided it will attempt to find an existing node group with that
+      # name in the environment specified in the "environment" option (default:
+      # "production").
+      #
+      # If an existing node group is found, it will be updated according to the
+      # provided options (via `#replace_node_group_with_update_hash`).
+      #
+      # If no existing node group is found, the options hash will be used to
+      # create a new node group (via `#create_new_node_group_model`).
+      def find_or_create_node_group_model(options={})
+        options["environment"] ||= "production"
+        if options["name"] && existing = get_node_group_by_name(options["name"], options["environment"])
+          replace_node_group_with_update_hash(existing, options)
+        else
+          create_new_node_group_model(options)
+        end
+      end
+
+      # If for some reason your node group model is out of sync with the
+      # server's state for that node group, you can use this method to just
+      # update your model with the server state.
+      def refresh_node_group_model(node_group_model)
+        get_node_group(node_group_model['id'])
+      end
+
+      # This will delete anything that inherits from the node group specified,
+      # but not the actual node group itself.
+      def delete_node_group_descendents(node_group_model)
+        id   = node_group_model['id']
+        tree = get_node_group_trees_of_direct_descendents
+        tree[id].each do |childid|
+          delete_tree_recursion(tree, childid)
+        end
+      end
+
+      # This will return a node group hash given the name of the node group. It
+      # defaults to production for the environment, since node names can be
+      # the same for different environments.
+      def get_node_group_by_name(name, environment='production')
+        nodes = get_list_of_node_groups
+        nodes.each do |node|
+          if node['name'] == name && node['environment'] == environment
+            return node
+          end
+        end
+        nil # return nil if no matching name found
+      end
+
+      # This will return the node group id given the name of the node group. It
+      # defaults to production for the environment, since node names can be
+      # the same for different environments.
+      def get_node_group_id_by_name(name, environment='production')
+        nodes = get_list_of_node_groups
+        nodes.each do |node|
+          if node['name'] == name && node['environment'] == environment
+            return node['id']
+          end
+        end
+        nil # return nil if no matching name found
+      end
+
+      # The tree parameter required here is generated from the method
+      # <tt>get_node_group_trees_with_direct_descendents</tt>. This method
+      # will also delete the node_group_id as well.
+      def delete_tree_recursion(tree, node_group_id)
+        tree[node_group_id].each do |childid|
+          delete_tree_recursion(tree, childid)
+        end
+        #protect against trying to delete the Rootuuid
+        delete_node_group(node_group_id) if node_group_id != Rootuuid
+      end
+
+      # This method imports a bare root group into the NC, cleaning out and
+      # deleting any node groups that might have been available. Consider
+      # using this or <tt>delete_all_node_groups</tt> at the beginning of your
+      # test, depending on requirements of the test.
+      def import_baseline_hierarchy
+        hierarchy = [{ "environment_trumps" => false,
+                       "parent"             => Rootuuid,
+                       "name"               => "default",
+                       "rule"               => ["and", ["~", "name", ".*"]],
+                       "variables"          => {},
+                       "id"                 => Rootuuid,
+                       "environment"        => "production",
+                       "classes"            => {} }]
+        import_hierarchy(hierarchy)
+      end
+
+      # This doesn't have a home right now, so it will exist in this module
+      # until it has a proper home.
+      def deep_merge(group, update_hash)
+        # TODO : This doesn't work if v is ever an array.  Needs to be
+        # reimplemented a la is_deep_subset?
+
+        update_hash.each do |k, v|
+          if v.is_a? Hash
+            group[k] ||= {}
+            deep_merge(group[k], update_hash[k])
+          else
+            group[k] = update_hash[k]
+          end
+        end
+      end
+
+      private :deep_merge
+
+      def remove_nil_values(hash)
+        hash.each do |k, v|
+          case v
+            when Hash
+              remove_nil_values(v)
+            else
+              hash.delete(k) if v == nil
+          end
+        end
+      end
+
+      private :remove_nil_values
+
+      # This uses a PUTs instead of a POST to update a node group; when using
+      # PUTs, it will delete and replace the entire node group instead of just
+      # updating the keys provided.
+      def replace_node_group_with_update_hash(node_group_model, update_hash)
+        merged_model = node_group_model.merge(update_hash)
+        replace_node_group(merged_model['id'], merged_model)
+        # no verification of the response for now, will need to write some code
+        # that verifies this and takes care of array ordering
+      end
+
+      # This uses the POST method to update a node group; when using POST, it
+      # will only send and update the specified keys.
+      def update_node_group_with_node_group_model(node_group_model, update_hash)
+        id       = node_group_model['id']
+        response = update_node_group(id, update_hash)
+
+        deep_merge(node_group_model, update_hash)
+        node_group_model = remove_nil_values(node_group_model)
+
+        # check to see if the update hash had any class changes that require
+        # transforms to the groups['deleted'] object
+        if node_group_model['deleted'] && node_group_model['classes'] != {} && update_hash['classes']
+          update_hash['classes'].each do |classname, parameters|
+            if node_group_model['deleted'][classname] == nil
+              next
+            end
+            parameters.each do |parameter, value|
+              if value == nil
+                node_group_model['deleted'][classname].delete(parameter)
+              else
+                node_group_model['deleted'][classname][parameter]['value'] = value
+              end
+            end
+          end
+        end
+
+        # check to see if we need to delete any classes from the model's
+        # node_group_model{'deleted'] key
+        if node_group_model['deleted']
+          node_group_model['deleted'].each do |classname, parameters|
+            if node_group_model['classes'][classname] == nil || node_group_model['deleted'][classname].keys == ['puppetlabs.classifier/deleted']
+              node_group_model['deleted'].delete(classname)
+            end
+          end
+          node_group_model.delete('deleted') if node_group_model['deleted'] == {}
+        end
+
+        if node_group_model != response.env.body
+          raise "node_group_model did not match the server response:\n#{node_group_model}\n#{response.env.body}"
+        end
+
+        # If we got this far, return the "model" hash.
+        node_group_model
+      end
+
+      # Used to compare replica classifier to master. Raises exception if it does not match.
+      # @param [BeakerHost] host_name
+      def classifier_database_matches_self?(host_name)
+        original_host_name = self.host
+        begin
+          self.host = host_name.to_s
+          initialize_connection
+          other_nodes        = get_list_of_nodes
+          other_classes      = get_list_of_classes
+          other_environments = get_list_of_environments
+          other_groups       = get_list_of_node_groups
+        ensure
+          self.host = original_host_name
+          initialize_connection
+        end
+
+        self_nodes        = get_list_of_nodes
+        self_classes      = get_list_of_classes
+        self_environments = get_list_of_environments
+        self_groups       = get_list_of_node_groups
+
+        nodes_match        = nodes_match?(other_nodes, self_nodes)
+        classes_match      = classes_match?(other_classes, self_classes)
+        environments_match = environments_match?(other_environments, self_environments)
+        groups_match       = groups_match?(other_groups, self_groups)
+
+        errors = ''
+        errors << "Nodes do not match\r\n" unless nodes_match
+        errors << "Classes do not match\r\n" unless classes_match
+        errors << "Environments do not match\r\n" unless environments_match
+        errors << "Groups do not match\r\n" unless groups_match
+
+        @faraday_logger.warn(errors.chomp) unless errors.empty?
+        errors.empty?
+      end
+
+      # Check to see if all nodes match between two query responses
+      # @param [Object] other_nodes - response from get_list_of_nodes
+      # @param [Object] self_nodes - response from get_list_of_nodes
+      # @return [Boolean]
+      def nodes_match?(other_nodes, self_nodes=nil)
+        self_nodes = get_list_of_nodes if self_nodes.nil?
+        return other_nodes == self_nodes
+      end
+
+      # Check to see if all classes match between two query responses
+      # @param [Object] other_classes - response from get_list_of_classes
+      # @param [Object] self_classes - response from get_list_of_classes
+      # @return [Boolean]
+      def classes_match?(other_classes, self_classes=nil)
+        self_classes = get_list_of_classes if self_classes.nil?
+        return other_classes == self_classes
+      end
+
+      # Check to see if all groups match between two query responses
+      # @param [Object] other_groups - response from get_list_of_node_groups
+      # @param [Object] self_groups - response from get_list_of_node_groups
+      # @return [Boolean]
+      def groups_match?(other_groups, self_groups=nil)
+        self_groups = get_list_of_node_groups if self_groups.nil?
+        return other_groups == self_groups
+      end
+
+      # Check to see if all environments match between two query responses
+      # @param [Object] other_environments - response from get_list_of_environments
+      # @param [Object] self_environments - response from get_list_of_environments
+      # @return [Boolean]
+      def environments_match?(other_environments, self_environments=nil)
+        self_environments = get_list_of_environments if self_environments.nil?
+        return other_environments == self_environments
+      end
+
+    end
+  end
+end