742 lines
28 KiB
Ruby
742 lines
28 KiB
Ruby
# Copyright 2015 Google Inc.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
require 'date'
|
|
require 'google/apis/core/base_service'
|
|
require 'google/apis/core/json_representation'
|
|
require 'google/apis/core/hashable'
|
|
require 'google/apis/errors'
|
|
|
|
module Google
|
|
module Apis
|
|
module FirebaserulesV1
|
|
|
|
# Arg matchers for the mock function.
|
|
class Arg
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# A generic empty message that you can re-use to avoid defining duplicated
|
|
# empty messages in your APIs. A typical example is to use it as the request
|
|
# or the response type of an API method. For instance:
|
|
# service Foo `
|
|
# rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
|
|
# `
|
|
# The JSON representation for `Empty` is empty JSON object ````.
|
|
# Corresponds to the JSON property `anyValue`
|
|
# @return [Google::Apis::FirebaserulesV1::Empty]
|
|
attr_accessor :any_value
|
|
|
|
# Argument exactly matches value provided.
|
|
# Corresponds to the JSON property `exactValue`
|
|
# @return [Object]
|
|
attr_accessor :exact_value
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@any_value = args[:any_value] if args.key?(:any_value)
|
|
@exact_value = args[:exact_value] if args.key?(:exact_value)
|
|
end
|
|
end
|
|
|
|
# A generic empty message that you can re-use to avoid defining duplicated
|
|
# empty messages in your APIs. A typical example is to use it as the request
|
|
# or the response type of an API method. For instance:
|
|
# service Foo `
|
|
# rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
|
|
# `
|
|
# The JSON representation for `Empty` is empty JSON object ````.
|
|
class Empty
|
|
include Google::Apis::Core::Hashable
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
end
|
|
end
|
|
|
|
# `File` containing source content.
|
|
class File
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# Textual Content.
|
|
# Corresponds to the JSON property `content`
|
|
# @return [String]
|
|
attr_accessor :content
|
|
|
|
# Fingerprint (e.g. github sha) associated with the `File`.
|
|
# Corresponds to the JSON property `fingerprint`
|
|
# NOTE: Values are automatically base64 encoded/decoded in the client library.
|
|
# @return [String]
|
|
attr_accessor :fingerprint
|
|
|
|
# File name.
|
|
# Corresponds to the JSON property `name`
|
|
# @return [String]
|
|
attr_accessor :name
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@content = args[:content] if args.key?(:content)
|
|
@fingerprint = args[:fingerprint] if args.key?(:fingerprint)
|
|
@name = args[:name] if args.key?(:name)
|
|
end
|
|
end
|
|
|
|
# Represents a service-defined function call that was invoked during test
|
|
# execution.
|
|
class FunctionCall
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# The arguments that were provided to the function.
|
|
# Corresponds to the JSON property `args`
|
|
# @return [Array<Object>]
|
|
attr_accessor :args
|
|
|
|
# Name of the function invoked.
|
|
# Corresponds to the JSON property `function`
|
|
# @return [String]
|
|
attr_accessor :function
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@args = args[:args] if args.key?(:args)
|
|
@function = args[:function] if args.key?(:function)
|
|
end
|
|
end
|
|
|
|
# Mock function definition.
|
|
# Mocks must refer to a function declared by the target service. The type of
|
|
# the function args and result will be inferred at test time. If either the
|
|
# arg or result values are not compatible with function type declaration, the
|
|
# request will be considered invalid.
|
|
# More than one `FunctionMock` may be provided for a given function name so
|
|
# long as the `Arg` matchers are distinct. There may be only one function
|
|
# for a given overload where all `Arg` values are `Arg.any_value`.
|
|
class FunctionMock
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# The list of `Arg` values to match. The order in which the arguments are
|
|
# provided is the order in which they must appear in the function
|
|
# invocation.
|
|
# Corresponds to the JSON property `args`
|
|
# @return [Array<Google::Apis::FirebaserulesV1::Arg>]
|
|
attr_accessor :args
|
|
|
|
# The name of the function.
|
|
# The function name must match one provided by a service declaration.
|
|
# Corresponds to the JSON property `function`
|
|
# @return [String]
|
|
attr_accessor :function
|
|
|
|
# Possible result values from the function mock invocation.
|
|
# Corresponds to the JSON property `result`
|
|
# @return [Google::Apis::FirebaserulesV1::Result]
|
|
attr_accessor :result
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@args = args[:args] if args.key?(:args)
|
|
@function = args[:function] if args.key?(:function)
|
|
@result = args[:result] if args.key?(:result)
|
|
end
|
|
end
|
|
|
|
# The response for FirebaseRulesService.GetReleaseExecutable
|
|
class GetReleaseExecutableResponse
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# Executable view of the `Ruleset` referenced by the `Release`.
|
|
# Corresponds to the JSON property `executable`
|
|
# NOTE: Values are automatically base64 encoded/decoded in the client library.
|
|
# @return [String]
|
|
attr_accessor :executable
|
|
|
|
# The Rules runtime version of the executable.
|
|
# Corresponds to the JSON property `executableVersion`
|
|
# @return [String]
|
|
attr_accessor :executable_version
|
|
|
|
# `Language` used to generate the executable bytes.
|
|
# Corresponds to the JSON property `language`
|
|
# @return [String]
|
|
attr_accessor :language
|
|
|
|
# `Ruleset` name associated with the `Release` executable.
|
|
# Corresponds to the JSON property `rulesetName`
|
|
# @return [String]
|
|
attr_accessor :ruleset_name
|
|
|
|
# Optional, indicates the freshness of the result. The response is
|
|
# guaranteed to be the latest within an interval up to the
|
|
# sync_time (inclusive).
|
|
# Corresponds to the JSON property `syncTime`
|
|
# @return [String]
|
|
attr_accessor :sync_time
|
|
|
|
# Timestamp for the most recent `Release.update_time`.
|
|
# Corresponds to the JSON property `updateTime`
|
|
# @return [String]
|
|
attr_accessor :update_time
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@executable = args[:executable] if args.key?(:executable)
|
|
@executable_version = args[:executable_version] if args.key?(:executable_version)
|
|
@language = args[:language] if args.key?(:language)
|
|
@ruleset_name = args[:ruleset_name] if args.key?(:ruleset_name)
|
|
@sync_time = args[:sync_time] if args.key?(:sync_time)
|
|
@update_time = args[:update_time] if args.key?(:update_time)
|
|
end
|
|
end
|
|
|
|
# Issues include warnings, errors, and deprecation notices.
|
|
class Issue
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# Short error description.
|
|
# Corresponds to the JSON property `description`
|
|
# @return [String]
|
|
attr_accessor :description
|
|
|
|
# The severity of the issue.
|
|
# Corresponds to the JSON property `severity`
|
|
# @return [String]
|
|
attr_accessor :severity
|
|
|
|
# Position in the `Source` content including its line, column number, and an
|
|
# index of the `File` in the `Source` message. Used for debug purposes.
|
|
# Corresponds to the JSON property `sourcePosition`
|
|
# @return [Google::Apis::FirebaserulesV1::SourcePosition]
|
|
attr_accessor :source_position
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@description = args[:description] if args.key?(:description)
|
|
@severity = args[:severity] if args.key?(:severity)
|
|
@source_position = args[:source_position] if args.key?(:source_position)
|
|
end
|
|
end
|
|
|
|
# The response for FirebaseRulesService.ListReleases.
|
|
class ListReleasesResponse
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# The pagination token to retrieve the next page of results. If the value is
|
|
# empty, no further results remain.
|
|
# Corresponds to the JSON property `nextPageToken`
|
|
# @return [String]
|
|
attr_accessor :next_page_token
|
|
|
|
# List of `Release` instances.
|
|
# Corresponds to the JSON property `releases`
|
|
# @return [Array<Google::Apis::FirebaserulesV1::Release>]
|
|
attr_accessor :releases
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@next_page_token = args[:next_page_token] if args.key?(:next_page_token)
|
|
@releases = args[:releases] if args.key?(:releases)
|
|
end
|
|
end
|
|
|
|
# The response for FirebaseRulesService.ListRulesets.
|
|
class ListRulesetsResponse
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# The pagination token to retrieve the next page of results. If the value is
|
|
# empty, no further results remain.
|
|
# Corresponds to the JSON property `nextPageToken`
|
|
# @return [String]
|
|
attr_accessor :next_page_token
|
|
|
|
# List of `Ruleset` instances.
|
|
# Corresponds to the JSON property `rulesets`
|
|
# @return [Array<Google::Apis::FirebaserulesV1::Ruleset>]
|
|
attr_accessor :rulesets
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@next_page_token = args[:next_page_token] if args.key?(:next_page_token)
|
|
@rulesets = args[:rulesets] if args.key?(:rulesets)
|
|
end
|
|
end
|
|
|
|
# `Release` is a named reference to a `Ruleset`. Once a `Release` refers to a
|
|
# `Ruleset`, rules-enabled services will be able to enforce the `Ruleset`.
|
|
class Release
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# Time the release was created.
|
|
# Output only.
|
|
# Corresponds to the JSON property `createTime`
|
|
# @return [String]
|
|
attr_accessor :create_time
|
|
|
|
# Resource name for the `Release`.
|
|
# `Release` names may be structured `app1/prod/v2` or flat `app1_prod_v2`
|
|
# which affords developers a great deal of flexibility in mapping the name
|
|
# to the style that best fits their existing development practices. For
|
|
# example, a name could refer to an environment, an app, a version, or some
|
|
# combination of three.
|
|
# In the table below, for the project name `projects/foo`, the following
|
|
# relative release paths show how flat and structured names might be chosen
|
|
# to match a desired development / deployment strategy.
|
|
# Use Case | Flat Name | Structured Name
|
|
# -------------|---------------------|----------------
|
|
# Environments | releases/qa | releases/qa
|
|
# Apps | releases/app1_qa | releases/app1/qa
|
|
# Versions | releases/app1_v2_qa | releases/app1/v2/qa
|
|
# The delimiter between the release name path elements can be almost anything
|
|
# and it should work equally well with the release name list filter, but in
|
|
# many ways the structured paths provide a clearer picture of the
|
|
# relationship between `Release` instances.
|
|
# Format: `projects/`project_id`/releases/`release_id``
|
|
# Corresponds to the JSON property `name`
|
|
# @return [String]
|
|
attr_accessor :name
|
|
|
|
# Name of the `Ruleset` referred to by this `Release`. The `Ruleset` must
|
|
# exist the `Release` to be created.
|
|
# Corresponds to the JSON property `rulesetName`
|
|
# @return [String]
|
|
attr_accessor :ruleset_name
|
|
|
|
# Time the release was updated.
|
|
# Output only.
|
|
# Corresponds to the JSON property `updateTime`
|
|
# @return [String]
|
|
attr_accessor :update_time
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@create_time = args[:create_time] if args.key?(:create_time)
|
|
@name = args[:name] if args.key?(:name)
|
|
@ruleset_name = args[:ruleset_name] if args.key?(:ruleset_name)
|
|
@update_time = args[:update_time] if args.key?(:update_time)
|
|
end
|
|
end
|
|
|
|
# Possible result values from the function mock invocation.
|
|
class Result
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# A generic empty message that you can re-use to avoid defining duplicated
|
|
# empty messages in your APIs. A typical example is to use it as the request
|
|
# or the response type of an API method. For instance:
|
|
# service Foo `
|
|
# rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
|
|
# `
|
|
# The JSON representation for `Empty` is empty JSON object ````.
|
|
# Corresponds to the JSON property `undefined`
|
|
# @return [Google::Apis::FirebaserulesV1::Empty]
|
|
attr_accessor :undefined
|
|
|
|
# The result is an actual value. The type of the value must match that
|
|
# of the type declared by the service.
|
|
# Corresponds to the JSON property `value`
|
|
# @return [Object]
|
|
attr_accessor :value
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@undefined = args[:undefined] if args.key?(:undefined)
|
|
@value = args[:value] if args.key?(:value)
|
|
end
|
|
end
|
|
|
|
# `Ruleset` is an immutable copy of `Source` with a globally unique identifier
|
|
# and a creation time.
|
|
class Ruleset
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# Time the `Ruleset` was created.
|
|
# Output only.
|
|
# Corresponds to the JSON property `createTime`
|
|
# @return [String]
|
|
attr_accessor :create_time
|
|
|
|
# Name of the `Ruleset`. The ruleset_id is auto generated by the service.
|
|
# Format: `projects/`project_id`/rulesets/`ruleset_id``
|
|
# Output only.
|
|
# Corresponds to the JSON property `name`
|
|
# @return [String]
|
|
attr_accessor :name
|
|
|
|
# `Source` is one or more `File` messages comprising a logical set of rules.
|
|
# Corresponds to the JSON property `source`
|
|
# @return [Google::Apis::FirebaserulesV1::Source]
|
|
attr_accessor :source
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@create_time = args[:create_time] if args.key?(:create_time)
|
|
@name = args[:name] if args.key?(:name)
|
|
@source = args[:source] if args.key?(:source)
|
|
end
|
|
end
|
|
|
|
# `Source` is one or more `File` messages comprising a logical set of rules.
|
|
class Source
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# `File` set constituting the `Source` bundle.
|
|
# Corresponds to the JSON property `files`
|
|
# @return [Array<Google::Apis::FirebaserulesV1::File>]
|
|
attr_accessor :files
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@files = args[:files] if args.key?(:files)
|
|
end
|
|
end
|
|
|
|
# Position in the `Source` content including its line, column number, and an
|
|
# index of the `File` in the `Source` message. Used for debug purposes.
|
|
class SourcePosition
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# First column on the source line associated with the source fragment.
|
|
# Corresponds to the JSON property `column`
|
|
# @return [Fixnum]
|
|
attr_accessor :column
|
|
|
|
# Name of the `File`.
|
|
# Corresponds to the JSON property `fileName`
|
|
# @return [String]
|
|
attr_accessor :file_name
|
|
|
|
# Line number of the source fragment. 1-based.
|
|
# Corresponds to the JSON property `line`
|
|
# @return [Fixnum]
|
|
attr_accessor :line
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@column = args[:column] if args.key?(:column)
|
|
@file_name = args[:file_name] if args.key?(:file_name)
|
|
@line = args[:line] if args.key?(:line)
|
|
end
|
|
end
|
|
|
|
# `TestCase` messages provide the request context and an expectation as to
|
|
# whether the given context will be allowed or denied. Test cases may specify
|
|
# the `request`, `resource`, and `function_mocks` to mock a function call to
|
|
# a service-provided function.
|
|
# The `request` object represents context present at request-time.
|
|
# The `resource` is the value of the target resource as it appears in
|
|
# persistent storage before the request is executed.
|
|
class TestCase
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# Test expectation.
|
|
# Corresponds to the JSON property `expectation`
|
|
# @return [String]
|
|
attr_accessor :expectation
|
|
|
|
# Optional function mocks for service-defined functions. If not set, any
|
|
# service defined function is expected to return an error, which may or may
|
|
# not influence the test outcome.
|
|
# Corresponds to the JSON property `functionMocks`
|
|
# @return [Array<Google::Apis::FirebaserulesV1::FunctionMock>]
|
|
attr_accessor :function_mocks
|
|
|
|
# Request context.
|
|
# The exact format of the request context is service-dependent. See the
|
|
# appropriate service documentation for information about the supported
|
|
# fields and types on the request. Minimally, all services support the
|
|
# following fields and types:
|
|
# Request field | Type
|
|
# ---------------|-----------------
|
|
# auth.uid | `string`
|
|
# auth.token | `map<string, string>`
|
|
# headers | `map<string, string>`
|
|
# method | `string`
|
|
# params | `map<string, string>`
|
|
# path | `string`
|
|
# time | `google.protobuf.Timestamp`
|
|
# If the request value is not well-formed for the service, the request will
|
|
# be rejected as an invalid argument.
|
|
# Corresponds to the JSON property `request`
|
|
# @return [Object]
|
|
attr_accessor :request
|
|
|
|
# Optional resource value as it appears in persistent storage before the
|
|
# request is fulfilled.
|
|
# The resource type depends on the `request.path` value.
|
|
# Corresponds to the JSON property `resource`
|
|
# @return [Object]
|
|
attr_accessor :resource
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@expectation = args[:expectation] if args.key?(:expectation)
|
|
@function_mocks = args[:function_mocks] if args.key?(:function_mocks)
|
|
@request = args[:request] if args.key?(:request)
|
|
@resource = args[:resource] if args.key?(:resource)
|
|
end
|
|
end
|
|
|
|
# Test result message containing the state of the test as well as a
|
|
# description and source position for test failures.
|
|
class TestResult
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# Debug messages related to test execution issues encountered during
|
|
# evaluation.
|
|
# Debug messages may be related to too many or too few invocations of
|
|
# function mocks or to runtime errors that occur during evaluation.
|
|
# For example: ```Unable to read variable [name: "resource"]```
|
|
# Corresponds to the JSON property `debugMessages`
|
|
# @return [Array<String>]
|
|
attr_accessor :debug_messages
|
|
|
|
# Position in the `Source` content including its line, column number, and an
|
|
# index of the `File` in the `Source` message. Used for debug purposes.
|
|
# Corresponds to the JSON property `errorPosition`
|
|
# @return [Google::Apis::FirebaserulesV1::SourcePosition]
|
|
attr_accessor :error_position
|
|
|
|
# The set of function calls made to service-defined methods.
|
|
# Function calls are included in the order in which they are encountered
|
|
# during evaluation, are provided for both mocked and unmocked functions,
|
|
# and included on the response regardless of the test `state`.
|
|
# Corresponds to the JSON property `functionCalls`
|
|
# @return [Array<Google::Apis::FirebaserulesV1::FunctionCall>]
|
|
attr_accessor :function_calls
|
|
|
|
# State of the test.
|
|
# Corresponds to the JSON property `state`
|
|
# @return [String]
|
|
attr_accessor :state
|
|
|
|
# The set of visited permission expressions for a given test. This returns
|
|
# the positions and evaluation results of all visited permission
|
|
# expressions which were relevant to the test case, e.g.
|
|
# ```
|
|
# match /path `
|
|
# allow read if: <expr>
|
|
# `
|
|
# ```
|
|
# For a detailed report of the intermediate evaluation states, see the
|
|
# `expression_reports` field
|
|
# Corresponds to the JSON property `visitedExpressions`
|
|
# @return [Array<Google::Apis::FirebaserulesV1::VisitedExpression>]
|
|
attr_accessor :visited_expressions
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@debug_messages = args[:debug_messages] if args.key?(:debug_messages)
|
|
@error_position = args[:error_position] if args.key?(:error_position)
|
|
@function_calls = args[:function_calls] if args.key?(:function_calls)
|
|
@state = args[:state] if args.key?(:state)
|
|
@visited_expressions = args[:visited_expressions] if args.key?(:visited_expressions)
|
|
end
|
|
end
|
|
|
|
# The request for FirebaseRulesService.TestRuleset.
|
|
class TestRulesetRequest
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# `Source` is one or more `File` messages comprising a logical set of rules.
|
|
# Corresponds to the JSON property `source`
|
|
# @return [Google::Apis::FirebaserulesV1::Source]
|
|
attr_accessor :source
|
|
|
|
# `TestSuite` is a collection of `TestCase` instances that validate the logical
|
|
# correctness of a `Ruleset`. The `TestSuite` may be referenced in-line within
|
|
# a `TestRuleset` invocation or as part of a `Release` object as a pre-release
|
|
# check.
|
|
# Corresponds to the JSON property `testSuite`
|
|
# @return [Google::Apis::FirebaserulesV1::TestSuite]
|
|
attr_accessor :test_suite
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@source = args[:source] if args.key?(:source)
|
|
@test_suite = args[:test_suite] if args.key?(:test_suite)
|
|
end
|
|
end
|
|
|
|
# The response for FirebaseRulesService.TestRuleset.
|
|
class TestRulesetResponse
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# Syntactic and semantic `Source` issues of varying severity. Issues of
|
|
# `ERROR` severity will prevent tests from executing.
|
|
# Corresponds to the JSON property `issues`
|
|
# @return [Array<Google::Apis::FirebaserulesV1::Issue>]
|
|
attr_accessor :issues
|
|
|
|
# The set of test results given the test cases in the `TestSuite`.
|
|
# The results will appear in the same order as the test cases appear in the
|
|
# `TestSuite`.
|
|
# Corresponds to the JSON property `testResults`
|
|
# @return [Array<Google::Apis::FirebaserulesV1::TestResult>]
|
|
attr_accessor :test_results
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@issues = args[:issues] if args.key?(:issues)
|
|
@test_results = args[:test_results] if args.key?(:test_results)
|
|
end
|
|
end
|
|
|
|
# `TestSuite` is a collection of `TestCase` instances that validate the logical
|
|
# correctness of a `Ruleset`. The `TestSuite` may be referenced in-line within
|
|
# a `TestRuleset` invocation or as part of a `Release` object as a pre-release
|
|
# check.
|
|
class TestSuite
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# Collection of test cases associated with the `TestSuite`.
|
|
# Corresponds to the JSON property `testCases`
|
|
# @return [Array<Google::Apis::FirebaserulesV1::TestCase>]
|
|
attr_accessor :test_cases
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@test_cases = args[:test_cases] if args.key?(:test_cases)
|
|
end
|
|
end
|
|
|
|
# The request for FirebaseRulesService.UpdateReleasePatch.
|
|
class UpdateReleaseRequest
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# `Release` is a named reference to a `Ruleset`. Once a `Release` refers to a
|
|
# `Ruleset`, rules-enabled services will be able to enforce the `Ruleset`.
|
|
# Corresponds to the JSON property `release`
|
|
# @return [Google::Apis::FirebaserulesV1::Release]
|
|
attr_accessor :release
|
|
|
|
# Specifies which fields to update.
|
|
# Corresponds to the JSON property `updateMask`
|
|
# @return [String]
|
|
attr_accessor :update_mask
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@release = args[:release] if args.key?(:release)
|
|
@update_mask = args[:update_mask] if args.key?(:update_mask)
|
|
end
|
|
end
|
|
|
|
# Store the position and access outcome for an expression visited in rules.
|
|
class VisitedExpression
|
|
include Google::Apis::Core::Hashable
|
|
|
|
# Position in the `Source` content including its line, column number, and an
|
|
# index of the `File` in the `Source` message. Used for debug purposes.
|
|
# Corresponds to the JSON property `sourcePosition`
|
|
# @return [Google::Apis::FirebaserulesV1::SourcePosition]
|
|
attr_accessor :source_position
|
|
|
|
# The evaluated value for the visited expression, e.g. true/false
|
|
# Corresponds to the JSON property `value`
|
|
# @return [Object]
|
|
attr_accessor :value
|
|
|
|
def initialize(**args)
|
|
update!(**args)
|
|
end
|
|
|
|
# Update properties of this object
|
|
def update!(**args)
|
|
@source_position = args[:source_position] if args.key?(:source_position)
|
|
@value = args[:value] if args.key?(:value)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|