tests

package
Version: v0.0.0-...-6fa03d5 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: May 4, 2020 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source
var (
	GetSetValidationOper_OperResult_name = map[int32]string{
		0: "NO_ERROR",
		1: "FAILED",
	}
	GetSetValidationOper_OperResult_value = map[string]int32{
		"NO_ERROR": 0,
		"FAILED":   1,
	}
)

Enum value maps for GetSetValidationOper_OperResult.

View Source
var File_proto_tests_tests_proto protoreflect.FileDescriptor

Functions

This section is empty.

Types

type Connection

type Connection struct {

	// The name of the target to be set in gNMI messages. For gNMI implementations
	// that can be address multiple targets, this value can be used to specify
	// which one should be the device under test.
	Target string `protobuf:"bytes,1,opt,name=target,proto3" json:"target,omitempty"`
	// Address is used while dialing into gNMI server under test. It needs to be
	// in the form "host:port" or it should resolve to a "host:port".
	Address     string       `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	Credentials *Credentials `protobuf:"bytes,3,opt,name=credentials,proto3" json:"credentials,omitempty"`
	// Dial timeout in seconds while connecting to gNMI server under test.
	Timeout int32 `protobuf:"varint,4,opt,name=timeout,proto3" json:"timeout,omitempty"`
	// contains filtered or unexported fields
}

Connection contains required information to be able to dial into a target.

func (*Connection) Descriptor deprecated

func (*Connection) Descriptor() ([]byte, []int)

Deprecated: Use Connection.ProtoReflect.Descriptor instead.

func (*Connection) GetAddress

func (x *Connection) GetAddress() string

func (*Connection) GetCredentials

func (x *Connection) GetCredentials() *Credentials

func (*Connection) GetTarget

func (x *Connection) GetTarget() string

func (*Connection) GetTimeout

func (x *Connection) GetTimeout() int32

func (*Connection) ProtoMessage

func (*Connection) ProtoMessage()

func (*Connection) ProtoReflect

func (x *Connection) ProtoReflect() protoreflect.Message

func (*Connection) Reset

func (x *Connection) Reset()

func (*Connection) String

func (x *Connection) String() string

type Credentials

type Credentials struct {

	// Resolver value is used to determine which credentials resolver to pick
	// while resolving username and password to use during gNMI connection. By
	// default, plaintext resolver is used if nothing is specified here. If a
	// special resolver is needed, it needs to be registered into global resolvers
	// table.
	Resolver string `protobuf:"bytes,1,opt,name=resolver,proto3" json:"resolver,omitempty"`
	Username string `protobuf:"bytes,2,opt,name=username,proto3" json:"username,omitempty"`
	Password string `protobuf:"bytes,3,opt,name=password,proto3" json:"password,omitempty"`
	// contains filtered or unexported fields
}

Credentials to use while connecting to target.

func (*Credentials) Descriptor deprecated

func (*Credentials) Descriptor() ([]byte, []int)

Deprecated: Use Credentials.ProtoReflect.Descriptor instead.

func (*Credentials) GetPassword

func (x *Credentials) GetPassword() string

func (*Credentials) GetResolver

func (x *Credentials) GetResolver() string

func (*Credentials) GetUsername

func (x *Credentials) GetUsername() string

func (*Credentials) ProtoMessage

func (*Credentials) ProtoMessage()

func (*Credentials) ProtoReflect

func (x *Credentials) ProtoReflect() protoreflect.Message

func (*Credentials) Reset

func (x *Credentials) Reset()

func (*Credentials) String

func (x *Credentials) String() string

type DataTreePaths

type DataTreePaths struct {

	// test_oper is the operation to be performed for the test.
	TestOper *DataTreePaths_TestQuery `protobuf:"bytes,1,opt,name=test_oper,json=testOper,proto3" json:"test_oper,omitempty"`
	// contains filtered or unexported fields
}

DataTreePaths specifies a test which allows for checks for the existence of particular data within the data tree. It allows recursion into lists, or simple queries for data tree paths.

A test which performs a simple check for a data tree path consists of a single TestQuery, which specifies the path to be queried. For example, to query for the existence of the /interfaces/interface[name=eth0]/state/counters/{in,out}-pkts leaves in the received data a query specifying:

{

steps { name: "interfaces" }
steps { name: "interface" key { name: "name" value: "eth0" } }
required_paths {
  prefix {
    elem { name: "state" }
    elem { name: "counters" }
  }
  paths { elem { name: "in-pkts" } }
  paths { elem { name: "out-pkts" } }
}

}

is specified. This query is simply expanded to check for the specified paths.

The test also supports querying recursively down the data tree using the GetListKeys message within a particular TestQuery. Such a query specifies that the query described by the "steps" repeated should be made, and the resulting key values of the list found should be assigned into an array. Subsequent nested queries can then refer to a value within that array using the variable name specified.

For example, if a test wishes to performn a check for each interface within the data tree, then nested TestQuery messages are required. The first retrieves the keys of the /interfaces/interface list from the data tree - and calls a nested TestQuery for each key within the /interfaces/interface list (referred to as %%interface%%) which performs the actual check:

{

steps { name: "interfaces" }
steps { name: "interface"  }
get_list_keys {
  var_name: "%%interface%%"
  next_query {
    steps { name: "interfaces" }
    steps { name: "interface" key_name: "%%interface%%" }
    required_paths {
      prefix: {
        elem: "state"
        elem: "counters"
     }
     paths { elem { name: "in-pkts" } }
     paths { elem { name: "out-pkts" } }
   }
 }
}

}

Will execute first a query for /interfaces/interface and assign the results to the %%interface%% variable. The child operation will execute for each element of the %%interface%% list, and subsequently make a query for /interfaces/interface[%%interface%%] where %%interface%% is an individual key found in the parent query (e.g., "name=eth0"). The child operation checks for the required paths at state/counters/{in,out}-pkts relative to the query made in the ListQuery operation.

Where multiple get_list_keys queries are nested, each next_query is called for each value of its parent query, such that it is possible to express nested list traversals such as:

foreach interface in /interfaces/interface:

 foreach subinterface of that interface:
   foreach ipv4 address of that subinterface:
     ... etc ...

using nested queries:

{
  steps { name: "interfaces" }
  steps { name: "interface" }
  get_list_keys {
    var_name: "%%interface%%"
    next_query {
      steps { name: "interfaces" }
      steps { name: "interface" key_name: "%%interface%%" }
      steps { name: "subinterfaces" }
      steps { name: "subinterface" }
      get_list_keys {
        var_name: "%%subinterface%%"
        next_query {
          steps { name: "interfaces" }
          steps { name: "interface" key_name: "%%interface%%" }
          steps { name: "subinterfaces" }
          steps { name: "subinterface" key_name: "%%subinterface%%" }
          steps { name: "ipv4" }
          steps { name: "addresses" }
          steps { name: "address" }
          get_list_keys {
            var_name: "%%v4address%%"
            next_query {
              steps { name: "interfaces" }
              steps { name: "interface" key_name: "%%interface%%" }
              steps { name: "subinterfaces" }
              steps { name: "subinterface" key_name: "%%subinterface%%" }
              steps { name: "ipv4" }
              steps { name: "addresses" }
              steps { name: "address"  key_name: "%%v4address%%" }
              required_paths {
                ... actual test with required paths ...
              }
            }
          }
        }
      }
    }
  }
}

The filter field within a TestQuery can be used to filter the set of list items that are to be iterated over. When a PathValueMatch filter is specified, its contents are evaluated, and only when the result of the match is true is the item in the list iterated over.

For example, it is possible to iterate over components of a particular type within the OpenConfig schema by specifying a filter:

{

steps: { name: "components" }
steps: { name: "component" }
get_list_keys {
  var_name: "%%component_name%%"
  filter {
    path {
      elem { name: "state" }
      elem { name: "type" }
    }
    equal { string_val: "TRANSCEIVER" }
  }
  next_query {
    steps: { name: "components" }
    steps: { name: "component" key_name: "%%component_name%%" }
    required_paths {
      prefix { name: "state" }
      paths { name: "mfg-name" }
      paths { name: "serial-no" }
    }
  }
}

}

The get_list_keys query is filtered according to the criteria described in the "filter". The path specified in this message must be relative to the current selection.

It is also possible to filter based on multiple queries, using the "and" and "or" fields of the PathValueMatch message, for example, to filter on components of type LINECARD or PORT, the following PathValueMatch is specified:

{

path {
  elem { name: "state" }
  elem { name: "type" }
}
equal { string_val: "LINECARD" }
or {
  path {
    elem { name: "state" }
    elem { name: "type" }
  }
  equal { string_val: PORT" }
}

}

The "or" field specifies that a PathValueMatch should be evaluated to true if the parent or any "or" query evaluates to true.

If multiple filters, are required, for example, to match multiple list keys, the "and" field can be used within a PathValueMatch:

{

// Assume we are within a query of the
// network-instances/network-instance/protocols/protocol list.
path {
  elem { name: "state" }
  elem { name: "identifier" }
}
equal { string_val: "BGP" }
and {
  path {
    elem { name: "state" }
    elem { name: "name" }
  }
  equal { string_val: "15169" }
}

}

As well as requiring a specific set of paths to exist, the datatreepaths test can be used to test values within the data tree, using the required_values field. For example, to validate that all non-logical interfaces have LLDP enabled, the following query can be formulated -- checking that /lldp/interfaces/interface[name=<if-name>]/state/enabled = true:

{

steps { name: "interfaces" }
steps { name: "interface" }
get_list_keys {
  var_name: "<if-name>"
  filter {
    path {
      elem { name: "state" }
      elem { name: "logical" }
    }
    equal { bool_val: false }
  }
  next_query {
    steps { name: "lldp" }
    steps { name: "interfaces" }
    steps { name: "interface" key_name: "<if-name>" }
    required_values {
      prefix {
        elem { name: "state" }
      }
      matches {
        path {
          elem { name: "enabled" }
        }
        equal { bool_val: true }
      }
    }
  }
}

}

func (*DataTreePaths) Descriptor deprecated

func (*DataTreePaths) Descriptor() ([]byte, []int)

Deprecated: Use DataTreePaths.ProtoReflect.Descriptor instead.

func (*DataTreePaths) GetTestOper

func (x *DataTreePaths) GetTestOper() *DataTreePaths_TestQuery

func (*DataTreePaths) ProtoMessage

func (*DataTreePaths) ProtoMessage()

func (*DataTreePaths) ProtoReflect

func (x *DataTreePaths) ProtoReflect() protoreflect.Message

func (*DataTreePaths) Reset

func (x *DataTreePaths) Reset()

func (*DataTreePaths) String

func (x *DataTreePaths) String() string

type DataTreePaths_ListQuery

type DataTreePaths_ListQuery struct {

	// var_name specifies the variable name by which the key values will
	// be referred to in subsequent queries.
	VarName string `protobuf:"bytes,1,opt,name=var_name,json=varName,proto3" json:"var_name,omitempty"`
	// next_query specifies a query that should be run for each key that
	// is retrieved by the ListQuery operation.
	NextQuery *DataTreePaths_TestQuery `protobuf:"bytes,2,opt,name=next_query,json=nextQuery,proto3" json:"next_query,omitempty"`
	// filter specifies a filter that must be met for each entry
	// in the list for it to be included in subsequent iterations. If it
	// is not set then all entries are iterated. Logical AND/ORs can
	// be specified within the filter.
	Filter *PathValueMatch `protobuf:"bytes,3,opt,name=filter,proto3" json:"filter,omitempty"`
	// contains filtered or unexported fields
}

ListQuery specifies an operation that retrieves the keys from a list.

func (*DataTreePaths_ListQuery) Descriptor deprecated

func (*DataTreePaths_ListQuery) Descriptor() ([]byte, []int)

Deprecated: Use DataTreePaths_ListQuery.ProtoReflect.Descriptor instead.

func (*DataTreePaths_ListQuery) GetFilter

func (x *DataTreePaths_ListQuery) GetFilter() *PathValueMatch

func (*DataTreePaths_ListQuery) GetNextQuery

func (*DataTreePaths_ListQuery) GetVarName

func (x *DataTreePaths_ListQuery) GetVarName() string

func (*DataTreePaths_ListQuery) ProtoMessage

func (*DataTreePaths_ListQuery) ProtoMessage()

func (*DataTreePaths_ListQuery) ProtoReflect

func (x *DataTreePaths_ListQuery) ProtoReflect() protoreflect.Message

func (*DataTreePaths_ListQuery) Reset

func (x *DataTreePaths_ListQuery) Reset()

func (*DataTreePaths_ListQuery) String

func (x *DataTreePaths_ListQuery) String() string

type DataTreePaths_QueryStep

type DataTreePaths_QueryStep struct {

	// name specifies a name that should be explicitly matched in the
	// gnmi.PathElem the QueryStep is being compared to.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// key specifies the key map which should be explicitly matched in
	// the gnmi.PathElem the QueryStep is being compared to.
	Key map[string]string `` /* 147-byte string literal not displayed */
	// key_name specifies the name of a variable that has been written to
	// by a previous stage of the test. The value of the key map in the
	// PathElem is substituted for the value currently being iterated over
	// for the variable.
	KeyName string `protobuf:"bytes,3,opt,name=key_name,json=keyName,proto3" json:"key_name,omitempty"`
	// contains filtered or unexported fields
}

QueryStep defines a query against the gNMI path of a data tree element.

func (*DataTreePaths_QueryStep) Descriptor deprecated

func (*DataTreePaths_QueryStep) Descriptor() ([]byte, []int)

Deprecated: Use DataTreePaths_QueryStep.ProtoReflect.Descriptor instead.

func (*DataTreePaths_QueryStep) GetKey

func (x *DataTreePaths_QueryStep) GetKey() map[string]string

func (*DataTreePaths_QueryStep) GetKeyName

func (x *DataTreePaths_QueryStep) GetKeyName() string

func (*DataTreePaths_QueryStep) GetName

func (x *DataTreePaths_QueryStep) GetName() string

func (*DataTreePaths_QueryStep) ProtoMessage

func (*DataTreePaths_QueryStep) ProtoMessage()

func (*DataTreePaths_QueryStep) ProtoReflect

func (x *DataTreePaths_QueryStep) ProtoReflect() protoreflect.Message

func (*DataTreePaths_QueryStep) Reset

func (x *DataTreePaths_QueryStep) Reset()

func (*DataTreePaths_QueryStep) String

func (x *DataTreePaths_QueryStep) String() string

type DataTreePaths_RequiredPaths

type DataTreePaths_RequiredPaths struct {

	// prefix is a common prefix for the paths within the required_paths
	// list.
	Prefix *gnmi.Path `protobuf:"bytes,1,opt,name=prefix,proto3" json:"prefix,omitempty"`
	// paths is the set of paths that are to be checked for.
	Paths []*gnmi.Path `protobuf:"bytes,2,rep,name=paths,proto3" json:"paths,omitempty"`
	// contains filtered or unexported fields
}

RequiredPaths specifies an operation that checks for paths within the data tree.

func (*DataTreePaths_RequiredPaths) Descriptor deprecated

func (*DataTreePaths_RequiredPaths) Descriptor() ([]byte, []int)

Deprecated: Use DataTreePaths_RequiredPaths.ProtoReflect.Descriptor instead.

func (*DataTreePaths_RequiredPaths) GetPaths

func (x *DataTreePaths_RequiredPaths) GetPaths() []*gnmi.Path

func (*DataTreePaths_RequiredPaths) GetPrefix

func (x *DataTreePaths_RequiredPaths) GetPrefix() *gnmi.Path

func (*DataTreePaths_RequiredPaths) ProtoMessage

func (*DataTreePaths_RequiredPaths) ProtoMessage()

func (*DataTreePaths_RequiredPaths) ProtoReflect

func (*DataTreePaths_RequiredPaths) Reset

func (x *DataTreePaths_RequiredPaths) Reset()

func (*DataTreePaths_RequiredPaths) String

func (x *DataTreePaths_RequiredPaths) String() string

type DataTreePaths_RequiredValues

type DataTreePaths_RequiredValues struct {

	// prefix is a common prefix for the paths within the required_values
	// list.
	Prefix *gnmi.Path `protobuf:"bytes,1,opt,name=prefix,proto3" json:"prefix,omitempty"`
	// matches specifies a set of path to value criteria that must be met.
	// Each match is considered in isolation to evalute to true or false.
	// The test fails if any of the matches evaluate to false.
	Matches []*PathValueMatch `protobuf:"bytes,2,rep,name=matches,proto3" json:"matches,omitempty"`
	// contains filtered or unexported fields
}

RequiredValues specifies an operation that checks values within the data tree.

func (*DataTreePaths_RequiredValues) Descriptor deprecated

func (*DataTreePaths_RequiredValues) Descriptor() ([]byte, []int)

Deprecated: Use DataTreePaths_RequiredValues.ProtoReflect.Descriptor instead.

func (*DataTreePaths_RequiredValues) GetMatches

func (x *DataTreePaths_RequiredValues) GetMatches() []*PathValueMatch

func (*DataTreePaths_RequiredValues) GetPrefix

func (x *DataTreePaths_RequiredValues) GetPrefix() *gnmi.Path

func (*DataTreePaths_RequiredValues) ProtoMessage

func (*DataTreePaths_RequiredValues) ProtoMessage()

func (*DataTreePaths_RequiredValues) ProtoReflect

func (*DataTreePaths_RequiredValues) Reset

func (x *DataTreePaths_RequiredValues) Reset()

func (*DataTreePaths_RequiredValues) String

type DataTreePaths_TestQuery

type DataTreePaths_TestQuery struct {

	// steps specifies the set of QuerySteps that should be made against the
	// data tree to retrieve the data for the operation being performed.
	Steps []*DataTreePaths_QueryStep `protobuf:"bytes,1,rep,name=steps,proto3" json:"steps,omitempty"`
	// Types that are assignable to Type:
	//	*DataTreePaths_TestQuery_GetListKeys
	//	*DataTreePaths_TestQuery_RequiredPaths
	//	*DataTreePaths_TestQuery_RequiredValues
	Type isDataTreePaths_TestQuery_Type `protobuf_oneof:"type"`
	// contains filtered or unexported fields
}

TestQuery specifies a single stage of a query within the test.

func (*DataTreePaths_TestQuery) Descriptor deprecated

func (*DataTreePaths_TestQuery) Descriptor() ([]byte, []int)

Deprecated: Use DataTreePaths_TestQuery.ProtoReflect.Descriptor instead.

func (*DataTreePaths_TestQuery) GetGetListKeys

func (x *DataTreePaths_TestQuery) GetGetListKeys() *DataTreePaths_ListQuery

func (*DataTreePaths_TestQuery) GetRequiredPaths

func (*DataTreePaths_TestQuery) GetRequiredValues

func (x *DataTreePaths_TestQuery) GetRequiredValues() *DataTreePaths_RequiredValues

func (*DataTreePaths_TestQuery) GetSteps

func (*DataTreePaths_TestQuery) GetType

func (m *DataTreePaths_TestQuery) GetType() isDataTreePaths_TestQuery_Type

func (*DataTreePaths_TestQuery) ProtoMessage

func (*DataTreePaths_TestQuery) ProtoMessage()

func (*DataTreePaths_TestQuery) ProtoReflect

func (x *DataTreePaths_TestQuery) ProtoReflect() protoreflect.Message

func (*DataTreePaths_TestQuery) Reset

func (x *DataTreePaths_TestQuery) Reset()

func (*DataTreePaths_TestQuery) String

func (x *DataTreePaths_TestQuery) String() string

type DataTreePaths_TestQuery_GetListKeys

type DataTreePaths_TestQuery_GetListKeys struct {
	// get_list_keys specifies that the query is used to retrieve a set
	// of list keys from the data tree and assign them to a variable. The
	// QuerySteps specified must therefore point to a list within the
	// data tree.
	GetListKeys *DataTreePaths_ListQuery `protobuf:"bytes,2,opt,name=get_list_keys,json=getListKeys,proto3,oneof"`
}

type DataTreePaths_TestQuery_RequiredPaths

type DataTreePaths_TestQuery_RequiredPaths struct {
	// required_paths specifies that the query results are to be used to
	// check for required paths in the data tree.
	RequiredPaths *DataTreePaths_RequiredPaths `protobuf:"bytes,3,opt,name=required_paths,json=requiredPaths,proto3,oneof"`
}

type DataTreePaths_TestQuery_RequiredValues

type DataTreePaths_TestQuery_RequiredValues struct {
	// required_values specifies that the query results are to be used to
	// check whether values that are found at the path match a certain
	// criteria.
	RequiredValues *DataTreePaths_RequiredValues `protobuf:"bytes,4,opt,name=required_values,json=requiredValues,proto3,oneof"`
}

type Default

type Default struct {
	// contains filtered or unexported fields
}

Default message to use if test doesn't need any arguments. Default message will be type of the field in the message. The name of the field discriminates one test from another.

func (*Default) Descriptor deprecated

func (*Default) Descriptor() ([]byte, []int)

Deprecated: Use Default.ProtoReflect.Descriptor instead.

func (*Default) ProtoMessage

func (*Default) ProtoMessage()

func (*Default) ProtoReflect

func (x *Default) ProtoReflect() protoreflect.Message

func (*Default) Reset

func (x *Default) Reset()

func (*Default) String

func (x *Default) String() string

type FakeTest

type FakeTest struct {

	// pass indicates whether the faked test should pass or fail.
	Pass bool `protobuf:"varint,1,opt,name=pass,proto3" json:"pass,omitempty"`
	// contains filtered or unexported fields
}

FakeTest is the configuration used for a fake test within the framework.

func (*FakeTest) Descriptor deprecated

func (*FakeTest) Descriptor() ([]byte, []int)

Deprecated: Use FakeTest.ProtoReflect.Descriptor instead.

func (*FakeTest) GetPass

func (x *FakeTest) GetPass() bool

func (*FakeTest) ProtoMessage

func (*FakeTest) ProtoMessage()

func (*FakeTest) ProtoReflect

func (x *FakeTest) ProtoReflect() protoreflect.Message

func (*FakeTest) Reset

func (x *FakeTest) Reset()

func (*FakeTest) String

func (x *FakeTest) String() string

type GNMIPathCompliance

type GNMIPathCompliance struct {
	CheckElem   bool   `protobuf:"varint,1,opt,name=check_elem,json=checkElem,proto3" json:"check_elem,omitempty"`
	CheckTarget string `protobuf:"bytes,2,opt,name=check_target,json=checkTarget,proto3" json:"check_target,omitempty"`
	CheckOrigin string `protobuf:"bytes,3,opt,name=check_origin,json=checkOrigin,proto3" json:"check_origin,omitempty"`
	// contains filtered or unexported fields
}

GNMIPathCompliance defines the test to validate target and origin fields of gNMI Path as well as usage of Elem field instead of deprecated Element field. If check_target and/or check_origin fields are set to "*", corresponding field in gNMI prefix path must exist, but can be any value. If they are set to a value other than "*", corresponding field must be equal to the value. If check_target and/or check_origin isn't set or set to an empty string, this means no validation is needed on the corresponding field. For instance:

{

// target must exist, but can have any value other than empty string
check_target: "*"
// origin must exist and be equal to "openconfig"
check_origin: "openconfig"
// Elem field of gNMI Path must be used instead of Element field
check_elem: true

}

func (*GNMIPathCompliance) Descriptor deprecated

func (*GNMIPathCompliance) Descriptor() ([]byte, []int)

Deprecated: Use GNMIPathCompliance.ProtoReflect.Descriptor instead.

func (*GNMIPathCompliance) GetCheckElem

func (x *GNMIPathCompliance) GetCheckElem() bool

func (*GNMIPathCompliance) GetCheckOrigin

func (x *GNMIPathCompliance) GetCheckOrigin() string

func (*GNMIPathCompliance) GetCheckTarget

func (x *GNMIPathCompliance) GetCheckTarget() string

func (*GNMIPathCompliance) ProtoMessage

func (*GNMIPathCompliance) ProtoMessage()

func (*GNMIPathCompliance) ProtoReflect

func (x *GNMIPathCompliance) ProtoReflect() protoreflect.Message

func (*GNMIPathCompliance) Reset

func (x *GNMIPathCompliance) Reset()

func (*GNMIPathCompliance) String

func (x *GNMIPathCompliance) String() string

type GetSetTest

type GetSetTest struct {

	// Types that are assignable to Args:
	//	*GetSetTest_OperValidation
	Args isGetSetTest_Args `protobuf_oneof:"args"`
	// contains filtered or unexported fields
}

GetSetTest contains all the information specific to a configuration test - which is expected to use RPCs to interact with configuration. Set is used to change the configuration, and Get or Subscribe can be used to retrieve configuration values to verify the target's initial or final states.

func (*GetSetTest) Descriptor deprecated

func (*GetSetTest) Descriptor() ([]byte, []int)

Deprecated: Use GetSetTest.ProtoReflect.Descriptor instead.

func (*GetSetTest) GetArgs

func (m *GetSetTest) GetArgs() isGetSetTest_Args

func (*GetSetTest) GetOperValidation

func (x *GetSetTest) GetOperValidation() *GetSetValidationTest

func (*GetSetTest) ProtoMessage

func (*GetSetTest) ProtoMessage()

func (*GetSetTest) ProtoReflect

func (x *GetSetTest) ProtoReflect() protoreflect.Message

func (*GetSetTest) Reset

func (x *GetSetTest) Reset()

func (*GetSetTest) String

func (x *GetSetTest) String() string

type GetSetTest_OperValidation

type GetSetTest_OperValidation struct {
	OperValidation *GetSetValidationTest `protobuf:"bytes,10,opt,name=oper_validation,json=operValidation,proto3,oneof"`
}

type GetSetValidationOper

type GetSetValidationOper struct {

	// Types that are assignable to Setrequest:
	//	*GetSetValidationOper_Set
	//	*GetSetValidationOper_CommonSetrequest
	Setrequest isGetSetValidationOper_Setrequest `protobuf_oneof:"setrequest"`
	// set_ok specifies whether the Set RPC should be successful.
	SetOk GetSetValidationOper_OperResult `protobuf:"varint,10,opt,name=set_ok,json=setOk,proto3,enum=tests.GetSetValidationOper_OperResult" json:"set_ok,omitempty"`
	// Types that are assignable to Getrequest:
	//	*GetSetValidationOper_Get
	//	*GetSetValidationOper_CommonGetrequest
	Getrequest isGetSetValidationOper_Getrequest `protobuf_oneof:"getrequest"`
	GetOk      GetSetValidationOper_OperResult   `protobuf:"varint,20,opt,name=get_ok,json=getOk,proto3,enum=tests.GetSetValidationOper_OperResult" json:"get_ok,omitempty"`
	// Types that are assignable to Getresponse:
	//	*GetSetValidationOper_GetResponse
	//	*GetSetValidationOper_CommonGetresponse
	Getresponse isGetSetValidationOper_Getresponse `protobuf_oneof:"getresponse"`
	// contains filtered or unexported fields
}

GetSetValidationOper describes an individual operation within a GetSetValidationTest. If the message consists of:

* Solely a SetRequest - the SetRequest is sent to the test target, and the
  result checked against the expected error status in set_ok.
* Solely a GetRequest - the GetRequest is sent to the test target, and the
  result checked against the expected GetResponse.
* Both a SetRequest and a GetRequest - the SetRequest is sent to the test
  target, and the return value compared against set_ok. Subsequently, the
  GetRequest is sent to the test target, the return code compared to get_ok
  and the GetResponse compared to the expected GetResponse.

func (*GetSetValidationOper) Descriptor deprecated

func (*GetSetValidationOper) Descriptor() ([]byte, []int)

Deprecated: Use GetSetValidationOper.ProtoReflect.Descriptor instead.

func (*GetSetValidationOper) GetCommonGetrequest

func (x *GetSetValidationOper) GetCommonGetrequest() string

func (*GetSetValidationOper) GetCommonGetresponse

func (x *GetSetValidationOper) GetCommonGetresponse() string

func (*GetSetValidationOper) GetCommonSetrequest

func (x *GetSetValidationOper) GetCommonSetrequest() string

func (*GetSetValidationOper) GetGet

func (x *GetSetValidationOper) GetGet() *gnmi.GetRequest

func (*GetSetValidationOper) GetGetOk

func (*GetSetValidationOper) GetGetResponse

func (x *GetSetValidationOper) GetGetResponse() *gnmi.GetResponse

func (*GetSetValidationOper) GetGetrequest

func (m *GetSetValidationOper) GetGetrequest() isGetSetValidationOper_Getrequest

func (*GetSetValidationOper) GetGetresponse

func (m *GetSetValidationOper) GetGetresponse() isGetSetValidationOper_Getresponse

func (*GetSetValidationOper) GetSet

func (x *GetSetValidationOper) GetSet() *gnmi.SetRequest

func (*GetSetValidationOper) GetSetOk

func (*GetSetValidationOper) GetSetrequest

func (m *GetSetValidationOper) GetSetrequest() isGetSetValidationOper_Setrequest

func (*GetSetValidationOper) ProtoMessage

func (*GetSetValidationOper) ProtoMessage()

func (*GetSetValidationOper) ProtoReflect

func (x *GetSetValidationOper) ProtoReflect() protoreflect.Message

func (*GetSetValidationOper) Reset

func (x *GetSetValidationOper) Reset()

func (*GetSetValidationOper) String

func (x *GetSetValidationOper) String() string

type GetSetValidationOper_CommonGetrequest

type GetSetValidationOper_CommonGetrequest struct {
	// common_getrequest specifies a key within the Suite common_getrequests
	// to be used.
	CommonGetrequest string `protobuf:"bytes,12,opt,name=common_getrequest,json=commonGetrequest,proto3,oneof"`
}

type GetSetValidationOper_CommonGetresponse

type GetSetValidationOper_CommonGetresponse struct {
	// common_getresponse specifies a key within the Suite common_getresponses
	// to be used.
	CommonGetresponse string `protobuf:"bytes,22,opt,name=common_getresponse,json=commonGetresponse,proto3,oneof"`
}

type GetSetValidationOper_CommonSetrequest

type GetSetValidationOper_CommonSetrequest struct {
	// common_setrequest specifies a key within the Suite common_setrequests
	// to be used.
	CommonSetrequest string `protobuf:"bytes,2,opt,name=common_setrequest,json=commonSetrequest,proto3,oneof"`
}

type GetSetValidationOper_Get

type GetSetValidationOper_Get struct {
	// get specifies a GetRequest to be sent to the target.
	Get *gnmi.GetRequest `protobuf:"bytes,11,opt,name=get,proto3,oneof"`
}

type GetSetValidationOper_GetResponse

type GetSetValidationOper_GetResponse struct {
	// get_response specifies the GetResponse that is expected from
	// the target.
	GetResponse *gnmi.GetResponse `protobuf:"bytes,21,opt,name=get_response,json=getResponse,proto3,oneof"`
}

type GetSetValidationOper_OperResult

type GetSetValidationOper_OperResult int32

OperResult specifies the expected result of an operation. By default an operation is expected to succeed.

const (
	GetSetValidationOper_NO_ERROR GetSetValidationOper_OperResult = 0
	GetSetValidationOper_FAILED   GetSetValidationOper_OperResult = 1
)

func (GetSetValidationOper_OperResult) Descriptor

func (GetSetValidationOper_OperResult) Enum

func (GetSetValidationOper_OperResult) EnumDescriptor deprecated

func (GetSetValidationOper_OperResult) EnumDescriptor() ([]byte, []int)

Deprecated: Use GetSetValidationOper_OperResult.Descriptor instead.

func (GetSetValidationOper_OperResult) Number

func (GetSetValidationOper_OperResult) String

func (GetSetValidationOper_OperResult) Type

type GetSetValidationOper_Set

type GetSetValidationOper_Set struct {
	// set specifies a SetRequest to be sent to the target.
	Set *gnmi.SetRequest `protobuf:"bytes,1,opt,name=set,proto3,oneof"`
}

type GetSetValidationTest

type GetSetValidationTest struct {

	// initialise_oper is the operation to initialise the target. It may consist
	// of a configuration to be set and/or get request that validates the target's
	// current state.
	InitialiseOper *GetSetValidationOper `protobuf:"bytes,1,opt,name=initialise_oper,json=initialiseOper,proto3" json:"initialise_oper,omitempty"`
	// test_oper is the operation that is under test in the validation test.  The
	// Get and/or Set operations may be set within the operation such that the
	// test can validate a set, a set followed by a get, or solely a get
	// operation.
	TestOper *GetSetValidationOper `protobuf:"bytes,2,opt,name=test_oper,json=testOper,proto3" json:"test_oper,omitempty"`
	// contains filtered or unexported fields
}

GetSetValidationTest describes a test that validates configuration sets on a target. It does not validate the underlying behaviour of the system, but restricts itself to validating that setting and retrieving configuration returns the expected result.

The expected test methodology is as follows:

1. Set the configuration of the target to a "known good" initial state.
2. Validate that the configuration running on the target matches this
   state.
3. Perform an update or replace operation on the configuration.
4. Validate that the new state of the target matches that which is
   expected.

func (*GetSetValidationTest) Descriptor deprecated

func (*GetSetValidationTest) Descriptor() ([]byte, []int)

Deprecated: Use GetSetValidationTest.ProtoReflect.Descriptor instead.

func (*GetSetValidationTest) GetInitialiseOper

func (x *GetSetValidationTest) GetInitialiseOper() *GetSetValidationOper

func (*GetSetValidationTest) GetTestOper

func (x *GetSetValidationTest) GetTestOper() *GetSetValidationOper

func (*GetSetValidationTest) ProtoMessage

func (*GetSetValidationTest) ProtoMessage()

func (*GetSetValidationTest) ProtoReflect

func (x *GetSetValidationTest) ProtoReflect() protoreflect.Message

func (*GetSetValidationTest) Reset

func (x *GetSetValidationTest) Reset()

func (*GetSetValidationTest) String

func (x *GetSetValidationTest) String() string

type HasKeys

type HasKeys struct {

	// Path to the list that should be checked.
	Path *gnmi.Path `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	// Items that should be found in the list.
	Item []*HasKeys_Item `protobuf:"bytes,2,rep,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

HasKeys defines the input for a test that checks that a particular list in the schema has a specified set of keys in the list. It can be used to check for data completeness of a particular list within the schema.

func (*HasKeys) Descriptor deprecated

func (*HasKeys) Descriptor() ([]byte, []int)

Deprecated: Use HasKeys.ProtoReflect.Descriptor instead.

func (*HasKeys) GetItem

func (x *HasKeys) GetItem() []*HasKeys_Item

func (*HasKeys) GetPath

func (x *HasKeys) GetPath() *gnmi.Path

func (*HasKeys) ProtoMessage

func (*HasKeys) ProtoMessage()

func (*HasKeys) ProtoReflect

func (x *HasKeys) ProtoReflect() protoreflect.Message

func (*HasKeys) Reset

func (x *HasKeys) Reset()

func (*HasKeys) String

func (x *HasKeys) String() string

type HasKeys_Item

type HasKeys_Item struct {
	Key map[string]string `` /* 147-byte string literal not displayed */
	// contains filtered or unexported fields
}

Item defines an entry in the list.

func (*HasKeys_Item) Descriptor deprecated

func (*HasKeys_Item) Descriptor() ([]byte, []int)

Deprecated: Use HasKeys_Item.ProtoReflect.Descriptor instead.

func (*HasKeys_Item) GetKey

func (x *HasKeys_Item) GetKey() map[string]string

func (*HasKeys_Item) ProtoMessage

func (*HasKeys_Item) ProtoMessage()

func (*HasKeys_Item) ProtoReflect

func (x *HasKeys_Item) ProtoReflect() protoreflect.Message

func (*HasKeys_Item) Reset

func (x *HasKeys_Item) Reset()

func (*HasKeys_Item) String

func (x *HasKeys_Item) String() string

type PathValueMatch

type PathValueMatch struct {

	// path is the path to be verified. It can be absolute or relative
	// based pon the context that the PathValueMatch message is used.
	Path *gnmi.Path `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	// criteria specifies the condition to be met for the value at the
	// path.
	//
	// Types that are assignable to Criteria:
	//	*PathValueMatch_Equal
	//	*PathValueMatch_IsUnset
	//	*PathValueMatch_IsSet
	//	*PathValueMatch_NotEqual
	Criteria isPathValueMatch_Criteria `protobuf_oneof:"criteria"`
	// and specifies a set of additional matches that must be met for
	// the test to evaluate to true. If any matches are not met, the
	// match is false.
	//
	// For example, if the following message is specified:
	// {
	//   path {
	//     elem { name: "system" }
	//     elem { name: "state" }
	//     elem { name: "hostname" }
	//   }
	//   equal { string_val: "box0" }
	//   and {
	//     path {
	//       elem { name: "system" }
	//       elem { name: "state" }
	//       elem { name: "domain-name" }
	//     }
	//     equal { string_val: "openconfig.net" }
	//   }
	//   and {
	//     path {
	//       elem { name: "system" }
	//       elem { name: "clock" }
	//       elem { name: "state" }
	//       elem { name: "timezone-name" }
	//     }
	//     equal { string_val: "Europe/London" }
	//   }
	// }
	//
	// Then the query only evaluates to true if /system/state/hostname
	// == "box0" && /system/state/domain-name == "openconfig.net" &&
	// /system/clock/state/timezone-name == "Europe/London".
	And []*PathValueMatch `protobuf:"bytes,20,rep,name=and,proto3" json:"and,omitempty"`
	// or specifies a set of matches that any one of which must be
	// met for the test to evaluate to true.
	//
	// For example, if the following message is spceified:
	//
	// {
	//   or {
	//     path {
	//       elem { name: "system" }
	//       elem { name: "state" }
	//       elem { name: "hostname" }
	//     }
	//     equal { string_val: "box0.openconfig.net" }
	//     and {
	//       path {
	//         elem { name: "system" }
	//         elem { name: "state" }
	//         elem { name: "domain-name" }
	//       }
	//       equal { string_val: "openconfig.net" }
	//   }
	//   or {
	//     path {
	//       elem { name: "system" }
	//       elem { name: "state" }
	//       elem { name: "hostname" }
	//     }
	//     equal { string_val: "box0" }
	//     and {
	//       path {
	//         elem { name: "system" }
	//         elem { name: "state" }
	//         elem { name: "domain-name" }
	//       }
	//       equal { string_val: "openconfig.net" }
	//     }
	//   }
	// }
	//
	// Then the query only evaluates to true if:
	//  (/system/state/hostname == "box0.openconfig.net" &&
	//  /system/state/domain-name == "openconfig") ||
	//  (/system/state/hostname == "box0" && /system/state/domain-name ==
	//  "openconfig.net")
	//
	//  In this case, the top-level query has no specified path or criteria. Such
	//  a query evaluates to true to allow such nesting.
	Or []*PathValueMatch `protobuf:"bytes,21,rep,name=or,proto3" json:"or,omitempty"`
	// contains filtered or unexported fields
}

PathValueMatch specifies a match critiera for a set of gNMI paths. It is used to express criteria that a gNMI path must match.

Both AND and OR logical expressions are contained within the PathValue message and explained in further detail below. The order of operations that is implemented within the frameworks is AND and then OR. The following examples illustrate the use of the message for form a variety of different logical expressions:

(a == "a" AND b == "b" ) OR c == "c"

{

path { elem { name: "a" } }
equal { string_val: "a" }
and {
 path { elem { name: "b" } }
 equal { string_val: "b" }
}
or {
 path { elem { name: "c" } }
 equal { string_val: "c" }
}

}

In this message (a AND b) is evaluated and if true, the expression returns true, if false, c is evaluated and the operation returns the result of the equality comparison.

(a == "a" ) OR (b == "b" AND c == "c")

{

path { elem { name: "a" } }
equal { string_val: "a" } }
or {
 path { elem { name: "b" } }
 equal { string_val: "b" }
 and {
   path { elem { name: "c" } }
   equal { string_val: "c" }
 }
}

}

In this message a is evaluated, and if true, the result is returned. If it is false, the (b AND C) criteria is evaluated in whole (since it is encapsulated within a new PathValue message) and the result is subsequently returned.

func (*PathValueMatch) Descriptor deprecated

func (*PathValueMatch) Descriptor() ([]byte, []int)

Deprecated: Use PathValueMatch.ProtoReflect.Descriptor instead.

func (*PathValueMatch) GetAnd

func (x *PathValueMatch) GetAnd() []*PathValueMatch

func (*PathValueMatch) GetCriteria

func (m *PathValueMatch) GetCriteria() isPathValueMatch_Criteria

func (*PathValueMatch) GetEqual

func (x *PathValueMatch) GetEqual() *gnmi.TypedValue

func (*PathValueMatch) GetIsSet

func (x *PathValueMatch) GetIsSet() bool

func (*PathValueMatch) GetIsUnset

func (x *PathValueMatch) GetIsUnset() bool

func (*PathValueMatch) GetNotEqual

func (x *PathValueMatch) GetNotEqual() *gnmi.TypedValue

func (*PathValueMatch) GetOr

func (x *PathValueMatch) GetOr() []*PathValueMatch

func (*PathValueMatch) GetPath

func (x *PathValueMatch) GetPath() *gnmi.Path

func (*PathValueMatch) ProtoMessage

func (*PathValueMatch) ProtoMessage()

func (*PathValueMatch) ProtoReflect

func (x *PathValueMatch) ProtoReflect() protoreflect.Message

func (*PathValueMatch) Reset

func (x *PathValueMatch) Reset()

func (*PathValueMatch) String

func (x *PathValueMatch) String() string

type PathValueMatch_Equal

type PathValueMatch_Equal struct {
	// equal is a gNMI TypedValue that the value found at the path must
	// be equal to.
	Equal *gnmi.TypedValue `protobuf:"bytes,2,opt,name=equal,proto3,oneof"`
}

type PathValueMatch_IsSet

type PathValueMatch_IsSet struct {
	// is_set specifies that the value found at the path must be set -
	// it is typically used to filter based on a particular container
	// existing.
	IsSet bool `protobuf:"varint,4,opt,name=is_set,json=isSet,proto3,oneof"`
}

type PathValueMatch_IsUnset

type PathValueMatch_IsUnset struct {
	// is_unset specifies that the value found at the path must not be
	// set in the schema.
	IsUnset bool `protobuf:"varint,3,opt,name=is_unset,json=isUnset,proto3,oneof"`
}

type PathValueMatch_NotEqual

type PathValueMatch_NotEqual struct {
	// not_equal specifies a gNMI TypedValue that the value found at the
	// path must not be equal to.
	NotEqual *gnmi.TypedValue `protobuf:"bytes,5,opt,name=not_equal,json=notEqual,proto3,oneof"`
}

type SchemaPathComplete

type SchemaPathComplete struct {

	// prefix is a gNMI path that should be appended to each path in the
	// paths list to form an absolute schema path.
	Prefix *gnmi.Path `protobuf:"bytes,2,opt,name=prefix,proto3" json:"prefix,omitempty"`
	// paths is the list of paths that are expected to be received by the
	// test framework.
	Path []*gnmi.Path `protobuf:"bytes,1,rep,name=path,proto3" json:"path,omitempty"`
	// contains filtered or unexported fields
}

SchemaPathComplete defines the input for a test that checks that at least one instance of a particular schema path is sent to the test framework. It can be used to check for path coverage of a particular target.

func (*SchemaPathComplete) Descriptor deprecated

func (*SchemaPathComplete) Descriptor() ([]byte, []int)

Deprecated: Use SchemaPathComplete.ProtoReflect.Descriptor instead.

func (*SchemaPathComplete) GetPath

func (x *SchemaPathComplete) GetPath() []*gnmi.Path

func (*SchemaPathComplete) GetPrefix

func (x *SchemaPathComplete) GetPrefix() *gnmi.Path

func (*SchemaPathComplete) ProtoMessage

func (*SchemaPathComplete) ProtoMessage()

func (*SchemaPathComplete) ProtoReflect

func (x *SchemaPathComplete) ProtoReflect() protoreflect.Message

func (*SchemaPathComplete) Reset

func (x *SchemaPathComplete) Reset()

func (*SchemaPathComplete) String

func (x *SchemaPathComplete) String() string

type SubscribeTest

type SubscribeTest struct {

	// Request to use by framework during gnmi Subscribe RPC. If test is part of
	// an extension list, a real subscription isn't created, but the query is
	// registered to receive updates corresponding to its path from subscription
	// of parent test.
	Request *gnmi.SubscribeRequest `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"`
	// log_responses indicates to the test whether it should log all
	// SubscribeResponse messages that are received from the target.
	LogResponses bool `protobuf:"varint,2,opt,name=log_responses,json=logResponses,proto3" json:"log_responses,omitempty"`
	// ignore_invalid_paths specifies whether invalid paths that are received
	// from the target should be ignored, or treated as a test error. If this
	// field is set to a non-nil value, then errors in deserialisation are
	// ignored by the test.
	//
	// USE CAUTION WHEN ENABLING THIS OPTION - since invalid output from the
	// target will not be treated as an error. It should be used solely when
	// the test pass/fail criteria DO NOT depend on the correctness of all
	// updates.
	IgnoreInvalidPaths bool `protobuf:"varint,3,opt,name=ignore_invalid_paths,json=ignoreInvalidPaths,proto3" json:"ignore_invalid_paths,omitempty"`
	// Types that are assignable to Args:
	//	*SubscribeTest_FakeTest
	//	*SubscribeTest_PathValidation
	//	*SubscribeTest_HasKeys
	//	*SubscribeTest_SchemapathComplete
	//	*SubscribeTest_DataTreePaths
	//	*SubscribeTest_ValueValidation
	//	*SubscribeTest_GnmipathCompliance
	Args isSubscribeTest_Args `protobuf_oneof:"args"`
	// contains filtered or unexported fields
}

Message that contains all the information specific to a gnmi Subscribe RPC.

func (*SubscribeTest) Descriptor deprecated

func (*SubscribeTest) Descriptor() ([]byte, []int)

Deprecated: Use SubscribeTest.ProtoReflect.Descriptor instead.

func (*SubscribeTest) GetArgs

func (m *SubscribeTest) GetArgs() isSubscribeTest_Args

func (*SubscribeTest) GetDataTreePaths

func (x *SubscribeTest) GetDataTreePaths() *DataTreePaths

func (*SubscribeTest) GetFakeTest

func (x *SubscribeTest) GetFakeTest() string

func (*SubscribeTest) GetGnmipathCompliance

func (x *SubscribeTest) GetGnmipathCompliance() *GNMIPathCompliance

func (*SubscribeTest) GetHasKeys

func (x *SubscribeTest) GetHasKeys() *HasKeys

func (*SubscribeTest) GetIgnoreInvalidPaths

func (x *SubscribeTest) GetIgnoreInvalidPaths() bool

func (*SubscribeTest) GetLogResponses

func (x *SubscribeTest) GetLogResponses() bool

func (*SubscribeTest) GetPathValidation

func (x *SubscribeTest) GetPathValidation() *Default

func (*SubscribeTest) GetRequest

func (x *SubscribeTest) GetRequest() *gnmi.SubscribeRequest

func (*SubscribeTest) GetSchemapathComplete

func (x *SubscribeTest) GetSchemapathComplete() *SchemaPathComplete

func (*SubscribeTest) GetValueValidation

func (x *SubscribeTest) GetValueValidation() *Default

func (*SubscribeTest) ProtoMessage

func (*SubscribeTest) ProtoMessage()

func (*SubscribeTest) ProtoReflect

func (x *SubscribeTest) ProtoReflect() protoreflect.Message

func (*SubscribeTest) Reset

func (x *SubscribeTest) Reset()

func (*SubscribeTest) String

func (x *SubscribeTest) String() string

type SubscribeTest_DataTreePaths

type SubscribeTest_DataTreePaths struct {
	DataTreePaths *DataTreePaths `protobuf:"bytes,14,opt,name=data_tree_paths,json=dataTreePaths,proto3,oneof"`
}

type SubscribeTest_FakeTest

type SubscribeTest_FakeTest struct {
	FakeTest string `protobuf:"bytes,10,opt,name=fake_test,json=fakeTest,proto3,oneof"`
}

type SubscribeTest_GnmipathCompliance

type SubscribeTest_GnmipathCompliance struct {
	GnmipathCompliance *GNMIPathCompliance `protobuf:"bytes,16,opt,name=gnmipath_compliance,json=gnmipathCompliance,proto3,oneof"`
}

type SubscribeTest_HasKeys

type SubscribeTest_HasKeys struct {
	HasKeys *HasKeys `protobuf:"bytes,12,opt,name=has_keys,json=hasKeys,proto3,oneof"`
}

type SubscribeTest_PathValidation

type SubscribeTest_PathValidation struct {
	PathValidation *Default `protobuf:"bytes,11,opt,name=path_validation,json=pathValidation,proto3,oneof"`
}

type SubscribeTest_SchemapathComplete

type SubscribeTest_SchemapathComplete struct {
	SchemapathComplete *SchemaPathComplete `protobuf:"bytes,13,opt,name=schemapath_complete,json=schemapathComplete,proto3,oneof"`
}

type SubscribeTest_ValueValidation

type SubscribeTest_ValueValidation struct {
	ValueValidation *Default `protobuf:"bytes,15,opt,name=value_validation,json=valueValidation,proto3,oneof"`
}

type Test

type Test struct {

	// Description of the individual test to use for reporting purposes.
	Description string `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"`
	// Amount of time in seconds test is allowed to run before cancelled.
	Timeout int32 `protobuf:"varint,2,opt,name=timeout,proto3" json:"timeout,omitempty"`
	// The compiled schema that should be used within the test.
	Schema string `protobuf:"bytes,3,opt,name=schema,proto3" json:"schema,omitempty"`
	// Connection parameters to dial into target. If not specified, the one
	// specified by Suite proto is used.
	Connection *Connection `protobuf:"bytes,4,opt,name=connection,proto3" json:"connection,omitempty"`
	// Can be extended to include other gNMI RPCs.
	//
	// Types that are assignable to Type:
	//	*Test_Subscribe
	//	*Test_GetSet
	//	*Test_FakeTest
	Type isTest_Type `protobuf_oneof:"type"`
	// contains filtered or unexported fields
}

Test specifies a gNMI test. The type indicates the form of test that is being performed.

The authentication for the RPC(s) used in the test is specified in username_key and password_key. These values are references to an external storage of authentication data that can be retrieved by the framework.

func (*Test) Descriptor deprecated

func (*Test) Descriptor() ([]byte, []int)

Deprecated: Use Test.ProtoReflect.Descriptor instead.

func (*Test) GetConnection

func (x *Test) GetConnection() *Connection

func (*Test) GetDescription

func (x *Test) GetDescription() string

func (*Test) GetFakeTest

func (x *Test) GetFakeTest() *FakeTest

func (*Test) GetGetSet

func (x *Test) GetGetSet() *GetSetTest

func (*Test) GetSchema

func (x *Test) GetSchema() string

func (*Test) GetSubscribe

func (x *Test) GetSubscribe() *SubscribeTest

func (*Test) GetTimeout

func (x *Test) GetTimeout() int32

func (*Test) GetType

func (m *Test) GetType() isTest_Type

func (*Test) ProtoMessage

func (*Test) ProtoMessage()

func (*Test) ProtoReflect

func (x *Test) ProtoReflect() protoreflect.Message

func (*Test) Reset

func (x *Test) Reset()

func (*Test) String

func (x *Test) String() string

type Test_FakeTest

type Test_FakeTest struct {
	// fake_test is used to verify the functionality of the test running
	// framework.
	FakeTest *FakeTest `protobuf:"bytes,12,opt,name=fake_test,json=fakeTest,proto3,oneof"`
}

type Test_GetSet

type Test_GetSet struct {
	GetSet *GetSetTest `protobuf:"bytes,11,opt,name=get_set,json=getSet,proto3,oneof"`
}

type Test_Subscribe

type Test_Subscribe struct {
	Subscribe *SubscribeTest `protobuf:"bytes,10,opt,name=subscribe,proto3,oneof"`
}

Source Files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL