Unlock 30% off on Manual Testing Annual Plans this Holiday Season.
Copied to Clipboard!
How to use field method of NoCriteriaProvided Package

Best Inspec_ruby code snippet using NoCriteriaProvided.field
filter.rb
Source:filter.rb
...85      new_criteria_string = criteria_string86      filtered_raw_data = raw_data87      # If we were provided params, interpret them as criteria to be evaluated88      # against the raw data. Criteria are assumed to be hash keys.89      conditions.each do |raw_field_name, desired_value|90        raise(ArgumentError, "'#{decorate_symbols(raw_field_name)}' is not a recognized criterion - expected one of #{decorate_symbols(list_fields).join(", ")}'") unless field?(raw_field_name)91        populate_lazy_field(raw_field_name, desired_value) if is_field_lazy?(raw_field_name)92        new_criteria_string += " #{raw_field_name} == #{desired_value.inspect}"93        filtered_raw_data = filter_raw_data(filtered_raw_data, raw_field_name, desired_value)94      end95      # If we were given a block, make a special Struct for each row, that has an accessor96      # for each field declared using `register_custom_property`, then instance-eval the block97      # against the struct.98      if block_given?99        # Perform the filtering.100        filtered_raw_data = filtered_raw_data.find_all { |row_as_hash| create_eval_context_for_row(row_as_hash, "").instance_eval(&block) }101        # Try to interpret the block for updating the stringification.102        src = Trace.new103        # Swallow any exceptions raised here.104        # See https://github.com/chef/inspec/issues/2929105        begin106          src.instance_eval(&block)107        rescue # rubocop: disable Lint/HandleExceptions108          # Yes, robocop, ignoring all exceptions is normally109          # a bad idea.  Here, an exception just means we don't110          # understand what was in a `where` block, so we can't111          # meaningfully sytringify it.  We still have a decent112          # default stringification.113        end114        new_criteria_string += Trace.to_ruby(src)115      end116      self.class.new(resource, filtered_raw_data, new_criteria_string)117    end118    def create_eval_context_for_row(*_)119      raise "#{self.class} must not be used on its own. It must be inherited "\120           "and the #create_eval_context_for_row method must be implemented. This is an internal "\121           "error and should not happen."122    end123    def resource124      resource_instance125    end126    def params127      # TODO: consider deprecating128      raw_data129    end130    def entries131      row_criteria_string = resource.to_s + criteria_string + " one entry"132      raw_data.map do |row|133        create_eval_context_for_row(row, row_criteria_string)134      end135    end136    def get_column_values(field)137      raw_data.map do |row|138        row[field]139      end140    end141    def list_fields142      @__fields_in_raw_data ||= raw_data.reduce([]) do |fields, row|143        fields.concat(row.keys).uniq144      end145    end146    def field?(proposed_field)147      # Currently we only know about a field if it is present in a at least one row of the raw data.148      # If we have no rows in the raw data, assume all fields are acceptable (and rely on failing to match on value, nil)149      return true if raw_data.empty?150      # Most resources have Symbol keys in their raw data.  Some have Strings (looking at you, `shadow`).151      is_field = false152      is_field ||= list_fields.include?(proposed_field.to_s)153      is_field ||= list_fields.include?(proposed_field.to_sym)154      is_field ||= is_field_lazy?(proposed_field.to_s)155      is_field ||= is_field_lazy?(proposed_field.to_sym)156      is_field157    end158    def to_s159      resource.to_s + criteria_string160    end161    alias inspect to_s162    def populate_lazy_field(field_name, criterion)163      return unless is_field_lazy?(field_name)164      return if field_populated?(field_name)165      raw_data.each do |row|166        next if row.key?(field_name) # skip row if pre-existing data is present167        callback_for_lazy_field(field_name).call(row, criterion, self)168      end169      mark_lazy_field_populated(field_name)170    end171    def is_field_lazy?(sought_field_name)172      custom_properties_schema.values.any? do |property_struct|173        sought_field_name == property_struct.field_name && \174          property_struct.opts[:lazy]175      end176    end177    def callback_for_lazy_field(field_name)178      return unless is_field_lazy?(field_name)179      custom_properties_schema.values.find do |property_struct|180        property_struct.field_name == field_name181      end.opts[:lazy]182    end183    def field_populated?(field_name)184      @populated_lazy_columns[field_name]185    end186    def mark_lazy_field_populated(field_name)187      @populated_lazy_columns[field_name] = true188    end189    private190    def matches_float(x, y)191      return false if x.nil?192      return false if !x.is_a?(Float) && (x =~ /\A[-+]?(\d+\.?\d*|\.\d+)\z/).nil?193      x.to_f == y194    end195    def matches_int(x, y)196      return false if x.nil?197      return false if !x.is_a?(Integer) && (x =~ /\A[-+]?\d+\z/).nil?198      x.to_i == y199    end200    def matches_regex(x, y)201      return x == y if x.is_a?(Regexp)202      !x.to_s.match(y).nil?203    end204    def matches(x, y)205      x === y # rubocop:disable Style/CaseEquality206    end207    def filter_raw_data(current_raw_data, field, desired_value)208      return [] if current_raw_data.empty?209      method_ref = case desired_value210                   when Float   then :matches_float211                   when Integer then :matches_int212                   when Regexp  then :matches_regex213                   else              :matches214                   end215      assume_symbolic_keyed_data = current_raw_data.first.keys.first.is_a? Symbol216      field = assume_symbolic_keyed_data ? field.to_sym : field.to_s217      current_raw_data.find_all do |row|218        next unless row.key?(field)219        send(method_ref, row[field], desired_value)220      end221    end222    def decorate_symbols(thing)223      return thing.map { |t| decorate_symbols(t) } if thing.is_a?(Array)224      return ":" + thing.to_s if thing.is_a? Symbol225      return thing + " (String)" if thing.is_a? String226      thing227    end228  end229  class Factory230    CustomPropertyType = Struct.new(:field_name, :block, :opts)231    def initialize232      @filter_methods = %i{where entries raw_data}233      @custom_properties = {}234      register_custom_matcher(:exist?) { |table| !table.raw_data.empty? }235      register_custom_property(:count) { |table|  table.raw_data.count }236      @resource = nil # TODO: this variable is never initialized237    end238    def install_filter_methods_on_resource(resource_class, raw_data_fetcher_method_name) # rubocop: disable Metrics/AbcSize, Metrics/MethodLength239      # A context in which you can access the fields as accessors240      non_block_struct_fields = @custom_properties.values.reject(&:block).map(&:field_name)241      unless non_block_struct_fields.empty?242        row_eval_context_type = Struct.new(*non_block_struct_fields.map(&:to_sym)) do243          attr_accessor :criteria_string244          attr_accessor :filter_table245          def to_s246            @criteria_string || super247          end248        end249      end250      properties_to_define = @custom_properties.map do |method_name, custom_property_structure|251        { method_name: method_name, method_body: create_custom_property_body(custom_property_structure) }252      end253      # Define the filter table subclass254      custom_properties = @custom_properties # We need a local var, not an instance var, for a closure below255      table_class = Class.new(Table) do256        # Install each custom property onto the FilterTable subclass257        properties_to_define.each do |property_info|258          define_method property_info[:method_name], &property_info[:method_body]259        end260        define_method :custom_properties_schema do261          custom_properties262        end263        # Install a method that can wrap all the fields into a context with accessors264        define_method :create_eval_context_for_row do |row_as_hash, criteria_string = ""|265          return row_eval_context_type.new if row_as_hash.nil?266          context = row_eval_context_type.new(*non_block_struct_fields.map { |field| row_as_hash[field] })267          context.criteria_string = criteria_string268          context.filter_table = self269          context270        end271      end272      # Now that the table class is defined and the row eval context struct is defined,273      # extend the row eval context struct to support triggering population of lazy fields274      # in where blocks. To do that, we'll need a reference to the table (which275      # knows which fields are populated, and how to populate them) and we'll need to276      # override the getter method for each lazy field, so it will trigger277      # population if needed.  Keep in mind we don't have to adjust the constructor278      # args of the row struct; also the Struct class will already have provided279      # a setter for each field.280      @custom_properties.values.each do |property_info|281        next unless property_info.opts[:lazy]282        field_name = property_info.field_name.to_sym283        row_eval_context_type.send(:define_method, field_name) do284          unless filter_table.field_populated?(field_name)285            filter_table.populate_lazy_field(field_name, NoCriteriaProvided) # No access to criteria here286            # OK, the underlying raw data has the value in the first row287            # (because we would trigger population only on the first row)288            # We could just return the value, but we need to set it on this Struct in case it is referenced multiple times289            # in the where block.290            self[field_name] = filter_table.raw_data[0][field_name]291          end292          # Now return the value using the Struct getter, whether newly populated or not293          self[field_name]294        end295      end296      # Define all access methods with the parent resource297      # These methods will be configured to return an `ExceptionCatcher` object298      # that will always return the original exception, but only when called299      # upon. This will allow method chains in `describe` statements to pass the300      # `instance_eval` when loaded and only throw-and-catch the exception when301      # the tests are run.302      methods_to_install_on_resource_class = @filter_methods + @custom_properties.keys303      methods_to_install_on_resource_class.each do |method_name|304        resource_class.send(:define_method, method_name) do |*args, &block|305          begin306            # self here is the resource instance307            filter_table_instance = table_class.new(self, send(raw_data_fetcher_method_name), " with")308            filter_table_instance.send(method_name, *args, &block)309          rescue Inspec::Exceptions::ResourceFailed, Inspec::Exceptions::ResourceSkipped => e310            FilterTable::ExceptionCatcher.new(resource_class, e)311          end312        end313      end314    end315    alias connect install_filter_methods_on_resource316    # TODO: This should almost certainly be privatized.  Every FilterTable client should get :entries and :where;317    # InSpec core resources do not define anything else, other than azure_generic_resource, which is likely a mis-use.318    def register_filter_method(method_name)319      if method_name.nil?320        # TODO: @resource is never initialized321        throw RuntimeError, "Called filter.add_accessor for resource #{@resource} with method name nil!"322      end323      if @filter_methods.include? method_name.to_sym324        # TODO: issue deprecation warning?325      else326        @filter_methods.push(method_name.to_sym)327      end328      self329    end330    alias add_accessor register_filter_method331    def register_custom_property(property_name, opts = {}, &property_implementation)332      if property_name.nil?333        # TODO: @resource is never initialized334        throw RuntimeError, "Called filter.add for resource #{@resource} with method name nil!"335      end336      if @custom_properties.key?(property_name.to_sym)337        # TODO: issue deprecation warning?338      else339        @custom_properties[property_name.to_sym] =340          CustomPropertyType.new(opts[:field] || property_name, property_implementation, opts)341      end342      self343    end344    alias add register_custom_property345    alias register_column register_custom_property346    alias register_custom_matcher register_custom_property347    private348    # This provides the implementation for methods requested using349    # register_custom_property(:some_method_name, opts, &block)350    # Some usage in the wild involves people passing a desired value to the generated method, like:351    #  things.ids(23)352    # I'm calling this the 'filter_criterion_value'. I speculate that a default value is353    # provided here so that users can meaningfully query for nil.354    def create_custom_property_body(custom_property_struct)355      if !custom_property_struct.block.nil?356        # If the custom method provided its own block, rely on it.357        lambda do |filter_criteria_value = NoCriteriaProvided|358          # Here self is an instance of the FilterTable subclass that wraps the raw data.359          # Call the block with two args - the table instance, and any filter criteria value.360          custom_property_struct.block.call(self, filter_criteria_value)361        end362      else363        # No block definition, so the property was registered using (field: :some_field)364        # This does however support passing a block to this method, and filtering using it, like Enumerable#select.365        lambda do |filter_criteria_value = NoCriteriaProvided, &cond_block|366          if filter_criteria_value == NoCriteriaProvided && !block_given?367            # No second-order block given.  Just return an array of the values in the selected column.368            result = where(nil)369            if custom_property_struct.opts[:lazy]370              result.populate_lazy_field(custom_property_struct.field_name, filter_criteria_value)371            end372            result = where(nil).get_column_values(custom_property_struct.field_name) # TODO: the where(nil). is likely unneeded373            result = result.flatten.uniq.compact if custom_property_struct.opts[:style] == :simple374            result375          else376            # A secondary block was provided.  Rely on where() to execute the block, while also filtering on any single value377            # Suspected bug: if filter_criteria_value == NoCriteriaProvided, this is unlikely to match - see hash condition handling in where() above.378            where(custom_property_struct.field_name => filter_criteria_value, &cond_block)379          end380        end381      end382    end383  end384  def self.create385    Factory.new386  end387end...
Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.