parser

package

v1.4.0 Latest Latest Go to latest Published: Mar 13, 2026 License: MIT Imports: 7 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/Issengaard/gonkey_grpc

Links

Open Source Insights

Documentation ¶

Index ¶

Constants
Variables
func New(locations []string) *fileParser
func RegisterParser(format string, parser FixtureFileParser)
type Context
- func NewContext() *Context
type Database
type Fixture
type FixtureFileParser
- func GetParser(format string) FixtureFileParser
type HashRecordValue
type HashValue
type Hashes
type KeyValue
type Keys
type ListRecordValue
type ListValue
type Lists
type SetRecordValue
type SetValue
type Sets
type Templates
type Value
- func Float(value float64) Value
- func Int(value int) Value
- func Str(value string) Value
- func (obj *Value) UnmarshalYAML(unmarshal func(interface{}) error) error
type ZSetRecordValue
type ZSetValue
type ZSets

Constants ¶

View Source

const (
	TypeInt   = "int"
	TypeStr   = "str"
	TypeFloat = "float"
)

Variables ¶

View Source

var (
	ErrFixtureNotFound  = errors.New("fixture not found")
	ErrFixtureFileLoad  = errors.New("failed to load fixture file")
	ErrFixtureParseFile = errors.New("failed to parse fixture file")
	ErrParserNotFound   = errors.New("parser not found")
)

Functions ¶

func New ¶

func New(locations []string) *fileParser

func RegisterParser ¶

func RegisterParser(format string, parser FixtureFileParser)

Types ¶

type Context ¶

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

func NewContext ¶

func NewContext() *Context

type Database ¶

type Database struct {
	Keys   *Keys   `yaml:"keys"`
	Hashes *Hashes `yaml:"hashes"`
	Sets   *Sets   `yaml:"sets"`
	Lists  *Lists  `yaml:"lists"`
	ZSets  *ZSets  `yaml:"zsets"`
}

Database contains data to load into Redis database

type Fixture ¶

type Fixture struct {
	Inherits  []string         `yaml:"inherits"`
	Templates Templates        `yaml:"templates"`
	Databases map[int]Database `yaml:"databases"`
}

Fixture is a representation of the test data, that is preloaded to a redis database before the test starts

Example (yaml):

```yaml inherits:

parent_template
child_template
other_fixture

databases:

1:
	keys:
		$name: keys1
		values:
			a:
				value: 1
				expiration: 10s
			b:
				value: 2
2:
	keys:
		$name: keys2
		values:
			c:
				value: 3
				expiration: 10s
			d:
				value: 4

```

type FixtureFileParser ¶

type FixtureFileParser interface {
	Parse(ctx *Context, filename string) (*Fixture, error)
	Copy(parser *fileParser) FixtureFileParser
}

func GetParser ¶

func GetParser(format string) FixtureFileParser

type HashRecordValue ¶

type HashRecordValue struct {
	Name       string        `yaml:"$name"`
	Extend     string        `yaml:"$extend"`
	Values     []*HashValue  `yaml:"values"`
	Expiration time.Duration `yaml:"expiration"`
}

HashRecordValue represent a single hash data structure

type HashValue ¶

type HashValue struct {
	Key   Value `yaml:"key"`
	Value Value `yaml:"value"`
}

type Hashes ¶

type Hashes struct {
	Values map[string]*HashRecordValue `yaml:"values"`
}

Hashes represent a collection of hash data structures, that will be loaded into Redis database

type KeyValue ¶

type KeyValue struct {
	Value      Value         `yaml:"value"`
	Expiration time.Duration `yaml:"expiration"`
}

KeyValue represent a redis key/value pair

type Keys ¶

type Keys struct {
	Name   string               `yaml:"$name"`
	Extend string               `yaml:"$extend"`
	Values map[string]*KeyValue `yaml:"values"`
}

Keys represent a collection of key/value pairs, that will be loaded into Redis database

type ListRecordValue ¶

type ListRecordValue struct {
	Name       string        `yaml:"$name"`
	Extend     string        `yaml:"$extend"`
	Values     []*ListValue  `yaml:"values"`
	Expiration time.Duration `yaml:"expiration"`
}

ListRecordValue represent a single list data structure

type ListValue ¶

type ListValue struct {
	Value Value `yaml:"value"`
}

ListValue represent a list value object

type Lists ¶

type Lists struct {
	Values map[string]*ListRecordValue `yaml:"values"`
}

Lists represent a collection of Redis list data structures

type SetRecordValue ¶

type SetRecordValue struct {
	Name       string        `yaml:"$name"`
	Extend     string        `yaml:"$extend"`
	Values     []*SetValue   `yaml:"values"`
	Expiration time.Duration `yaml:"expiration"`
}

SetRecordValue represent a single set data structure

type SetValue ¶

type SetValue struct {
	Value Value `yaml:"value"`
}

SetValue represent a set value object

type Sets ¶

type Sets struct {
	Values map[string]*SetRecordValue `yaml:"values"`
}

Sets represent a collection of set data structures, that will be loaded into Redis database

type Templates ¶

type Templates struct {
	Keys   []*Keys            `yaml:"keys"`
	Hashes []*HashRecordValue `yaml:"hashes"`
	Sets   []*SetRecordValue  `yaml:"sets"`
	Lists  []*ListRecordValue `yaml:"lists"`
	ZSets  []*ZSetRecordValue `yaml:"zsets"`
}

type Value ¶

type Value struct {
	Type  string
	Value interface{}
}

func Float ¶

func Float(value float64) Value

func Int ¶

func Int(value int) Value

func Str ¶

func Str(value string) Value

func (*Value) UnmarshalYAML ¶

func (obj *Value) UnmarshalYAML(unmarshal func(interface{}) error) error

type ZSetRecordValue ¶

type ZSetRecordValue struct {
	Name       string        `yaml:"$name"`
	Extend     string        `yaml:"$extend"`
	Values     []*ZSetValue  `yaml:"values"`
	Expiration time.Duration `yaml:"expiration"`
}

ZSetRecordValue represent a single sorted set data structure

type ZSetValue ¶

type ZSetValue struct {
	Value Value   `yaml:"value"`
	Score float64 `yaml:"score"`
}

ZSetValue represent a zset value object

type ZSets ¶

type ZSets struct {
	Values map[string]*ZSetRecordValue `yaml:"values"`
}

ZSets represent a collection of Redis sorted set data structure

Source Files ¶

View all Source files

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