ruby-jss 1.6.0 → 2.0.0a11

data/lib/jamf/validate.rb

@@ -1,4 +1,4 @@
-# Copyright 2020 Pixar
+# Copyright 2022 Pixar
 #
 #    Licensed under the Apache License, Version 2.0 (the "Apache License")
 #    with the following modification; you may not use this file except in
@@ -22,12 +22,9 @@
 #
 #
 
-# The Module
 module Jamf
 
-  # A collection of methods for validating values. Mostly for
-  # ensuring the validity of data being set as attributes of APIObject
-  # subclass instances.
+  # A collection of methods for validating values.
   #
   # Some of these methods can take multiple input types, such as a String
   # or an Array.  All of them will either raise an exception
@@ -36,9 +33,22 @@ module Jamf
   #
   module Validate
 
+    # Raise an invalid data error
+    def self.raise_invalid_data_error(msg)
+      raise Jamf::InvalidDataError, msg.strip
+    end
+
+    extend Jamf::OAPIValidate
+
     # The regular expression that matches a valid MAC address.
     MAC_ADDR_RE = /^[a-f0-9]{2}(:[a-f0-9]{2}){5}$/i.freeze
 
+    # The Regexp that matches a valid IPv4 address
+    IPV4_ADDR_RE = /^((25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)(\.|$)){4}/.freeze
+
+    # the regular expression that matches a valid UDID/UUID
+    UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.freeze
+
     # Validate the format and content of a MAC address
     #
     # @param val[String] The value to validate
@@ -47,11 +57,10 @@ module Jamf
     #
     # @return [String] The valid value
     #
-    def self.mac_address(val, msg = nil)
-      msg ||= "Not a valid MAC address: '#{val}'"
-      raise Jamf::InvalidDataError, msg unless val =~ MAC_ADDR_RE
+    def self.mac_address(val, msg: nil)
+      return val if val =~ MAC_ADDR_RE
 
-      val
+      raise_invalid_data_error(msg || "Not a valid MAC address: '#{val}'")
     end
 
     # Validate the format and content of an IPv4 address
@@ -62,103 +71,65 @@ module Jamf
     #
     # @return [String] The valid value
     #
-    def self.ip_address(val, msg = nil)
-      msg ||= "Not a valid IPv4 address: '#{val}'"
-      ok = true
-      parts = val.strip.split '.'
-      ok = false unless parts.size == 4
-      parts.each { |p| ok = false unless p.j_integer? && p.to_i < 256 && p.to_i >= 0 }
-      raise Jamf::InvalidDataError, msg unless ok
+    def self.ip_address(val, msg: nil)
+      val = val.strip
+      return val if val =~ IPV4_ADDR_RE
 
-      val
+      raise_invalid_data_error(msg || "Not a valid IPv4 address: '#{val}'")
     end
 
-    # Does a given JSONObject class have a given JSON attribute?
-    #
-    # @param klass [<JSONObject] A class descended from JSONObject
-    #
-    # @param attr_name [Symbol] The attribute to validate
-    #
-    # @return [Symbol] The valid attribute
-    #
-    def self.json_attribute_name(klass, attr_name)
-      raise "#{klass} is not a descendent of JSONObject" unless klass < Jamf::JSONObject
-
-      raise Jamf::NoSuchItemError, "No attribute #{attr_name} for class #{klass}" unless klass::OBJECT_MODEL.key? attrib
-
-      attr_name
-    end
-
-    # Does a value exist in a given enum array?
-    #
-    # @param klass [<JSONObject] A class descended from JSONObject
-    #
-    # @param attr_name [Symbol] The attribute to validate
-    #
-    # @return [Symbol] The valid attribute
-    #
-    def self.in_enum(val, enum)
-      raise Jamf::InvalidDataError, "Value must be one of: #{enum.join ', '}" unless enum.include? val
-
-      val
-    end
-
-    # Validate that a value doesn't already exist for a given identifier of
-    # a given CollectionResource class
+    # Validate that a value doesn't already exist for a given identifier of a
+    # given class
     #
     # e.g. when klass = Jamf::Computer, identifier = :name, and val = 'foo'
-    # will raise an error when a computer named 'foo' already exists
+    # will raise an error when a computer named 'foo' exists
     #
     # Otherwise returns val.
     #
-    # @param val[Object] The value to check for uniqueness
+    # @param klass[Jamf::APIObject] A subclass of Jamf::APIObject, e.g. Jamf::Computer
     #
-    # @param klass[Jamf::CollectionResource] A descendent of Jamf::CollectionResource, e.g. Jamf::Computer
+    # @param identifier[Symbol] One of the keys of an Item of the class's #all Array
     #
-    # @param identifier[Symbol] One of the values of klass.identifiers
+    # @param val[Object] The value to check for uniqueness
     #
     # @param msg[String] A custom error message when the value is invalid
     #
-    # @param cnx[Jamf::Connection] The api connection to use for validation
+    # @param cnx [Jamf::Connection] The api connection to use for validation
     #
     # @return [Object] the validated unique value
     #
-    def self.doesnt_exist(val, klass, identifier, msg = nil, cnx: Jamf.cnx)
-      msg ||= "A #{klass} already exists with #{identifier} '#{val}'"
+    def self.doesnt_already_exist(klass, identifier, val, msg: nil, api: Jamf.cnx)
+      return val unless klass.all(:refresh, cnx: cnx).map { |i| i[identifier] }.include? val
 
-      raise Jamf::InvalidDataError, "No identifier '#{identifier}' for #{klass}" unless klass.identifiers.include? identifier
+      key = klass.real_lookup_key identifier
 
-      return val unless klass.send("all_#{identifier}s", :refresh, cnx: cnx).include? val
+      # use map_all_ids_to cuz it works with any identifer, even non-existing
+      existing_values = klass.map_all_ids_to(key, cnx: cnx).values
+      matches = existing_values.select { |existing_val| existing_val.casecmp? val }
+      return val if matches.empty?
 
-      raise Jamf::AlreadyExistsError, msg
+      raise_invalid_data_error(msg || "A #{klass} already exists with #{identifier} '#{val}'")
     end
 
-    TRUE_FALSE = [true, false].freeze
-
-    # Confirm that the given value is a boolean value, accepting
-    # strings and symbols and returning real booleans as needed
-    # Accepts: true, false, 'true', 'false', 'yes', 'no', 't','f', 'y', or 'n'
-    # as strings or symbols, case insensitive
+    # validate that the given value is a non-empty string
     #
-    # @param val [Boolean,String,Symbol] The value to validate
+    # @param val [Object] the thing to validate
     #
     # @param msg[String] A custom error message when the value is invalid
     #
-    # @return [Boolean] the valid boolean
+    # @return [String] the valid non-empty string
     #
-    def self.boolean(val, msg = 'Value must be true or false, or equivalent string or symbol')
-      return val if TRUE_FALSE.include? val
-      return true if val.to_s =~ /^(t(rue)?|y(es)?)$/i
-      return false if val.to_s =~ /^(f(alse)?|no?)$/i
+    def self.non_empty_string(val, attr_name: nil, msg: nil)
+      return val if val.is_a?(String) && !val.empty?
 
-      raise Jamf::InvalidDataError, msg
+      raise_invalid_data_error(msg || "#{attr_name} value must be a non-empty String")
     end
 
     # Confirm that a value provided is an integer or a string version
     # of an integer, and return the string version
     #
     # The JPAPI specs say that all IDs are integers in strings
-    # tho, the endpoints are still implementing that in different versions.
+    # tho, some endpoints are still using actual integers.
     #
     # @param val[Object] the value to validate
     #
@@ -166,98 +137,88 @@ module Jamf
     #
     # @return [String] the valid integer-in-a-string
     #
-    def self.j_id(val, msg = 'Value must be an Integer or an Integer in a String, e.g. "42"')
+    def self.j_id(val, attr_name: nil, msg: nil)
       case val
       when Integer
         return val.to_s
       when String
         return val if val.j_integer?
       end
-      raise Jamf::InvalidDataError, msg
+      raise_invalid_data_error(msg || "#{attr_name} value must be an Integer or an Integer in a String, e.g. \"42\"")
     end
 
-    # Confirm that a value is an Integer or a String representation of an
-    # Integer. Return the integer, or raise an error
+    # validate that the given value is a valid uuid string
     #
-    # @param val[Object] the value to validate
+    # @param val [Object] the thing to validate
     #
     # @param msg[String] A custom error message when the value is invalid
     #
-    # @return [Integer] the valid integer
+    # @return [String] the valid uuid string
     #
-    def self.integer(val, msg = 'Value must be an Integer')
-      val = val.to_i if val.is_a?(String) && val.j_integer?
-      raise Jamf::InvalidDataError, msg unless val.is_a? Integer
+    def self.uuid(val, msg: nil)
+      return val if val.is_a?(String) && val =~ UUID_RE
 
-      val
+      raise_invalid_data_error(msg || 'value must be valid uuid')
     end
 
-    # Confirm that a value is a Float or a String representation of a Float.
-    # Return the Float, or raise an error
+    # validate that the given value is an integer in the Jamf::IBeacon::MAJOR_MINOR_RANGE
     #
-    # @param val[Object] the value to validate
+    # @param val [Object] the thing to validate
     #
     # @param msg[String] A custom error message when the value is invalid
     #
-    # @return [Float] the valid float
+    # @return [String] the valid integer
     #
-    def self.float(val, msg = 'Value must be a Floating Point number')
-      val = val.to_f if val.is_a?(String) && val.j_float?
-      raise Jamf::InvalidDataError, msg unless val.is_a? Float
+    def self.ibeacon_major_minor(val, msg: nil)
+      val = val.to_i if val.is_a?(String) && val.jss_integer?
+      ok = val.is_a? Integer
+      ok = Jamf::IBeacon::MAJOR_MINOR_RANGE.include? val if ok
+      return val if ok
 
-      val
+      raise_invalid_data_error(msg || "value must be an integer in the range #{Jamf::IBeacon::MAJOR_MINOR_RANGE}")
     end
 
-    # Confirm that a value is a string, symbol, or nil,
-    # all of which will be returned as a string
+    # validate a country name or code from Jamf::APP_STORE_COUNTRY_CODES
+    # returning the validated code, or raising an error
     #
-    # @param val[Object] the value to validate
+    # @param country[String] The country name or code
     #
     # @param msg[String] A custom error message when the value is invalid
     #
-    # @return [String] the valid String
+    # @return [String] the valid two-letter country code
     #
-    def self.string(val, msg = 'Value must be a String')
-      return Jamf::BLANK if val.nil?
-
-      val = val.to_s if val.is_a? Symbol
-      raise Jamf::InvalidDataError, msg unless val.is_a? String
-
-      val
-    end
+    def self.app_store_country_code(country, msg: nil)
+      country = country.to_s.upcase
+      return country if Jamf::APP_STORE_COUNTRY_CODES.value? country
 
-    # validate that the given value is a non-empty string
-    # Symbols are accepted and returned as strings
-    #
-    # @param val [Object] the thing to validate
-    #
-    # @param msg[String] A custom error message when the value is invalid
-    #
-    # @return [String] the valid non-empty string
-    #
-    def self.non_empty_string(val, msg = 'value must be a non-empty String')
-      val = val.to_s if val.is_a? Symbol
-      raise Jamf::InvalidDataError, msg unless val.is_a?(String) && !val.empty?
+      Jamf::APP_STORE_COUNTRY_CODES.each do |name, code|
+        return code if name.upcase == country
+      end
 
-      val
+      raise_invalid_data_error(msg || "Unknown country name or code '#{country}'. See Jamf::APP_STORE_COUNTRY_CODES or JSS.country_code_match(str)")
     end
 
-    SCRIPT_SHEBANG = '#!'.freeze
-
-    # validate that the given value is a string that starts with #!
+    # validate an email address - must match the RegEx /^\S+@\S+\.\S+$/
+    # i.e.:
+    #  1 or more non-whitespace chars, followed by
+    #  an @ character, followed by
+    #  1 or more non-whitespace chars, followed by
+    #  a dot, followed by
+    #  1 or more non-whitespace chars
     #
-    # @param val [Object] the thing to validate
+    # @param email[String] The email address
     #
     # @param msg[String] A custom error message when the value is invalid
     #
-    # @return [String] the validated string
+    # @return [String] the validly formatted email address
     #
-    def self.script_contents(val, msg = "value must be a String starting with '#!'")
-      raise Jamf::InvalidDataError, msg unless val.is_a?(String) && val.start_with?(SCRIPT_SHEBANG)
+    def self.email_address(email, msg: nil)
+      email = email.to_s
+      return email if email =~ /^\S+@\S+\.\S+$/
 
-      val
+      raise_invalid_data_error(msg || "'#{email}' is not formatted as a valid email address")
     end
 
   end # module validate
 
-end # module JSS
+end # module Jamf

data/lib/jamf/version.rb

@@ -1,4 +1,4 @@
-### Copyright 2020 Pixar
+### Copyright 2022 Pixar
 
 ###
 ###    Licensed under the Apache License, Version 2.0 (the "Apache License")
@@ -26,7 +26,7 @@
 ###
 module Jamf
 
-  ### The version of the Jamf module
-  VERSION = '0.0.6a1'.freeze
+  ### The version of ruby-jss
+  VERSION = '2.0.0a11'.freeze
 
 end # module

data/lib/jamf.rb

@@ -1,4 +1,4 @@
-# Copyright 2020 Pixar
+# Copyright 2022 Pixar
 
 #
 #    Licensed under the Apache License, Version 2.0 (the "Apache License")
@@ -20,159 +20,104 @@
 #    distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 #    KIND, either express or implied. See the Apache License for the specific
 #    language governing permissions and limitations under the Apache License.
-#
-#
 
-#
-# JAMF, A Ruby module for interacting with a JAMF Pro Server via the JAMF API
-#
+# Required Libraries, etc
+#####################################
 
-### Standard Libraries
+# Standard Libraries
+#
+# TODO: Move some of these to where they are first needed so they aren't
+# loaded unnecessarily
 require 'English'
 require 'json'
 require 'yaml'
 require 'pathname'
+require 'fileutils'
 require 'time'
+require 'date'
 require 'singleton'
 require 'open-uri'
 require 'ipaddr'
+require 'rexml/document'
 require 'base64'
 require 'shellwords'
 require 'digest'
 require 'open3'
 
-### Gems
-
-# Used, among other places, in the Connection::APIError class
+# Gems
 require 'immutable-struct'
+require 'concurrent'
 
-# TODO: needed?
-# require 'recursive-open-struct'
-
-# non-api parts of Jamf module
-require 'jamf/configuration'
+# Load things not loaded by zeitwerk
+require 'jamf/ruby_extensions'
 require 'jamf/exceptions'
-require 'jamf/utility'
-require 'jamf/validate'
-require 'jamf/version'
+require 'jamf/db_connection'
 
-# backports and extensions to existing Ruby classes
-require 'jamf/compatibility'
-require 'jamf/ruby_extensions'
+# Configure the Zeitwerk loader, See https://github.com/fxn/zeitwerk
+require 'zeitwerk'
+require 'zeitwerk_config'
 
-# API connection
-require 'jamf/api/connection'
+# touch this file to make zeitwerk and mixins send text to stderr as things load
+# or get mixed in
+JAMF_VERBOSE_LOADING_FILE = Pathname.new('/tmp/ruby-jss-verbose-loading')
 
+# Or, set this ENV var to also make zeitverk and mixins send text to stderr
+JAMF_VERBOSE_LOADING_ENV = 'RUBY_JSS_VERBOSE_LOADING'.freeze
 
-# The main module.
-# See README.md
-#
+# touch this file to make zeitwek  eager-load everything when the gem is required.
+JAMF_ZEITWERK_EAGER_LOAD_FILE = Pathname.new('/tmp/ruby-jss-zeitwerk-eager-load')
+
+# the `Zeitwerk::Loader.for_gem` creates the loader object, and must
+# happen in this file, so we pass it into a method defined in
+# zeitwerk_config
+setup_zeitwerk_loader Zeitwerk::Loader.for_gem
+
+# Jamf, A Ruby module for interacting with the JAMF Pro Server via both of its REST APIs
 module Jamf
 
-  # The minimum Ruby version that works with this gem
-  # 2.3 allows us to start using some nice features like the safe-navigation
-  # operator and Array#dig & Hash#dig, and such.
-  #
-  # For a list of features, see https://github.com/ruby/ruby/blob/v2_3_0/NEWS
-  # and http://nithinbekal.com/posts/ruby-2-3-features/
-  #
-  MINIMUM_RUBY_VERSION = '2.3'.freeze
-
-  if Gem::Version.new(RUBY_VERSION) < Gem::Version.new(MINIMUM_RUBY_VERSION)
-    raise "Can't use the JAMF module, ruby itself must be version #{MINIMUM_RUBY_VERSION} or greater."
+  def self.validate_ruby_version
+    return if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new(MINIMUM_RUBY_VERSION)
+
+    raise "Can't use ruby-jss #{Jamf::VERSION}, ruby itself must be version #{MINIMUM_RUBY_VERSION} or greater, this is ruby #{RUBY_VERSION}."
   end
 
-  # AUTOLOADING
-  ##################################
-
-  # Top-level API Base Classes
-  autoload :JSONObject, 'jamf/api/base_classes/json_object'
-  autoload :Resource, 'jamf/api/base_classes/resource'
-  autoload :SingletonResource, 'jamf/api/base_classes/singleton_resource'
-  autoload :CollectionResource, 'jamf/api/base_classes/collection_resource'
-
-  # Base Classes used for JSONObject subclasses
-  autoload :Prestage, 'jamf/api/base_classes/prestage'
-
-  # MixIn Modules
-  autoload :ChangeLog, 'jamf/api/mixins/change_log'
-  autoload :Extendable, 'jamf/api/mixins/extendable'
-  autoload :Locatable, 'jamf/api/mixins/locatable'
-  autoload :Referable, 'jamf/api/mixins/referable'
-  autoload :Searchable, 'jamf/api/mixins/searchable'
-  autoload :Lockable, 'jamf/api/mixins/lockable'
-  autoload :UnCreatable, 'jamf/api/mixins/uncreatable'
-  autoload :Immutable, 'jamf/api/mixins/immutable'
-  autoload :UnDeletable, 'jamf/api/mixins/undeletable'
-  autoload :BaseClass, 'jamf/api/mixins/base_class'
-  autoload :Pageable, 'jamf/api/mixins/pageable'
-  autoload :Filterable, 'jamf/api/mixins/filterable'
-  autoload :Sortable, 'jamf/api/mixins/sortable'
-  autoload :BulkDeletable, 'jamf/api/mixins/bulk_deletable'
-
-  # Utility modules
-  autoload :Validate, 'jamf/validate'
-
-  # Subclasses of JSONObject, but not Resource
-  autoload :AndroidDetails, 'jamf/api/json_objects/android_details'
-  autoload :AppleTVDetails, 'jamf/api/json_objects/appletv_details'
-  autoload :CellularNetwork, 'jamf/api/json_objects/cellular_network'
-  autoload :ChangeLogEntry, 'jamf/api/json_objects/change_log_entry'
-  autoload :ComputerPrestageSkipSetupItems, 'jamf/api/json_objects/computer_prestage_skip_setup_items'
-  autoload :Country, 'jamf/api/json_objects/country'
-  autoload :Criterion, 'jamf/api/json_objects/criterion'
-  autoload :DeviceEnrollmentDevice, 'jamf/api/json_objects/device_enrollment_device'
-  autoload :DeviceEnrollmentDeviceSyncState, 'jamf/api/json_objects/device_enrollment_device_sync_state'
-  autoload :DeviceEnrollmentSyncStatus, 'jamf/api/json_objects/device_enrollment_sync_status'
-  autoload :ExtensionAttributeValue, 'jamf/api/json_objects/extension_attribute_value'
-  autoload :InstalledApplication, 'jamf/api/json_objects/installed_application'
-  autoload :InstalledCertificate, 'jamf/api/json_objects/installed_certificate'
-  autoload :InstalledConfigurationProfile, 'jamf/api/json_objects/installed_configuration_profile'
-  autoload :InstalledEBook, 'jamf/api/json_objects/installed_ebook'
-  autoload :InstalledProvisioningProfile, 'jamf/api/json_objects/installed_provisioning_profile'
-  autoload :InventoryPreloadExtensionAttribute, 'jamf/api/json_objects/inventory_preload_extension_attribute'
-  autoload :IosDetails, 'jamf/api/json_objects/ios_details'
-  autoload :Locale, 'jamf/api/json_objects/locale'
-  autoload :Location, 'jamf/api/json_objects/location'
-  autoload :PrestageLocation, 'jamf/api/json_objects/prestage_location'
-  autoload :PrestageSyncStatus, 'jamf/api/json_objects/prestage_sync_status'
-  autoload :MobileDeviceDetails, 'jamf/api/json_objects/mobile_device_details'
-  autoload :MobileDeviceSecurity, 'jamf/api/json_objects/mobile_device_security'
-  autoload :MobileDevicePrestageName, 'jamf/api/json_objects/md_prestage_name'
-  autoload :MobileDevicePrestageNames, 'jamf/api/json_objects/md_prestage_names'
-  autoload :MobileDevicePrestageSkipSetupItems, 'jamf/api/json_objects/md_prestage_skip_setup_items'
-  autoload :PurchasingData, 'jamf/api/json_objects/purchasing_data'
-  autoload :PrestagePurchasingData, 'jamf/api/json_objects/prestage_purchasing_data'
-  autoload :PrestageScope, 'jamf/api/json_objects/prestage_scope'
-  autoload :PrestageAssignment, 'jamf/api/json_objects/prestage_assignment'
-  autoload :TimeZone, 'jamf/api/json_objects/time_zone'
-
-  # Subclasses of SingletonResource
-  autoload :ClientCheckInSettings, 'jamf/api/resources/singleton_resources/client_checkin_settings'
-  autoload :ReEnrollmentSettings, 'jamf/api/resources/singleton_resources/reenrollment_settings'
-  autoload :AppStoreCountryCodes, 'jamf/api/resources/singleton_resources/app_store_country_codes'
-  autoload :TimeZones, 'jamf/api/resources/singleton_resources/time_zones'
-  autoload :Locales, 'jamf/api/resources/singleton_resources/locales'
-
-  # Subclasses of CollectionResource
-  autoload :AdvancedMobileDeviceSearch, 'jamf/api/resources/collection_resources/advanced_mobile_device_search'
-  autoload :AdvancedUserSearch, 'jamf/api/resources/collection_resources/advanced_user_search'
-  autoload :Attachment, 'jamf/api/resources/collection_resources/attachment'
-  autoload :Category, 'jamf/api/resources/collection_resources/category'
-  autoload :Building, 'jamf/api/resources/collection_resources/building'
-  autoload :Computer, 'jamf/api/resources/collection_resources/computer'
-  autoload :ComputerPrestage, 'jamf/api/resources/collection_resources/computer_prestage'
-  autoload :Department, 'jamf/api/resources/collection_resources/department'
-  autoload :DeviceEnrollment, 'jamf/api/resources/collection_resources/device_enrollment'
-  autoload :ExtensionAttribute, 'jamf/api/resources/collection_resources/extension_attribute'
-  autoload :InventoryPreloadRecord, 'jamf/api/resources/collection_resources/inventory_preload_record'
-  autoload :MobileDevice, 'jamf/api/resources/collection_resources/mobile_device'
-  autoload :MobileDevicePrestage, 'jamf/api/resources/collection_resources/mobile_device_prestage'
-  autoload :Site, 'jamf/api/resources/collection_resources/site'
-  autoload :Script, 'jamf/api/resources/collection_resources/script'
-
-  # other classes used as attributes inside the resource classes
-  autoload :IPAddress, 'jamf/api/attribute_classes/ip_address'
-  autoload :Timestamp, 'jamf/api/attribute_classes/timestamp'
-
-end # module
+  # Only look at the filesystem once.
+  def self.verbose_loading?
+    return @verbose_loading unless @verbose_loading.nil?
+
+    @verbose_loading = JAMF_VERBOSE_LOADING_FILE.file?
+    @verbose_loading ||= ENV.include? JAMF_VERBOSE_LOADING_ENV
+    @verbose_loading
+  end
+
+  # rubocop: disable Style/StderrPuts
+  def self.load_msg(msg)
+    return unless verbose_loading?
+
+    $stderr.puts msg
+  end
+  # rubocop: enable Style/StderrPuts
+
+  # the single instance of our configuration object
+  def self.config
+    Jamf::Configuration.instance
+  end
+
+  # These need to come after the definition of verboase_loading?
+  # since they will try to use it when they get loaded
+  ###################
+
+  include Jamf::Constants
+  extend Jamf::Utility
+  extend Jamf::Connection::DefaultConnection
+
+end # module Jamf
+
+# make sure we can run
+Jamf.validate_ruby_version
+
+# JSS module is now a synonym for Jamf module
+JSS = Jamf
+
+# testing zeitwerk loading
+eager_load_for_testing if JAMF_ZEITWERK_EAGER_LOAD_FILE.file?

data/lib/jss-api.rb

@@ -1,4 +1,4 @@
-### Copyright 2020 Pixar
+### Copyright 2022 Pixar
 
 ###
 ###    Licensed under the Apache License, Version 2.0 (the "Apache License")
@@ -23,4 +23,4 @@
 ###
 
 # backward compatility for 'require "jss-api"'
-require 'jss'
+require 'jamf'