models

package

v2.3.0-beta18 Latest Latest Go to latest Published: Sep 6, 2024 License: Apache-2.0 Imports: 13 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/keploy/keploy

README ¶

Models Package Documentation

This package defines all the Go structs used for storing the captured data. It is designed as an independent module.

Documentation ¶

Overview ¶

Package models provides data models for the keploy.

Index ¶

Constants
Variables
func SetMode(m Mode) error
func SetTestMode()
func SetVersion(V1 string)
type AbsResult
type AccessTokenResponse
type AppError
- func (e AppError) Error() string
type AppErrorType
type AuthReq
type AuthResp
type Backend
type BodyResult
type BodyType
type Class
type Cobertura
type Counter
type CoverageResult
type DepMetaResult
type DepResult
type DeviceCodeResponse
type DrivenMode
- func (d DrivenMode) String() string
type FailedUT
type FormData
type Frame
type Frontend
type GenericSchema
type GlobalNoise
type GrpcHeaders
type GrpcLengthPrefixedMessage
type GrpcReq
type GrpcResp
type GrpcSpec
type GrpcStream
- func NewGrpcStream(streamID uint32) GrpcStream
type HTTPDoc
type HTTPReq
type HTTPResp
type HTTPSchema
type Header
type HeaderResult
type HookOptions
type IncomingOptions
type Info
type IntResult
type Jacoco
type JacocoClass
type JacocoLine
type JacocoMethod
type JacocoPackage
type JacocoSourceFile
type KctxType
type Kind
type Line
type MediaType
type Method
type Mock
- func (m *Mock) GetKind() string
type MockMapping
type MockRegistry
type MockSpec
type Mode
- func GetMode() Mode
- func (m Mode) Valid() bool
type ModeKey
type MongoHeader
type MongoOpMessage
type MongoOpQuery
type MongoOpReply
type MongoRequest
- func (mr *MongoRequest) MarshalJSON() ([]byte, error)
- func (mr *MongoRequest) UnmarshalBSON(data []byte) error
- func (mr *MongoRequest) UnmarshalJSON(data []byte) error
type MongoResponse
- func (mr *MongoResponse) MarshalJSON() ([]byte, error)
- func (mr *MongoResponse) UnmarshalBSON(data []byte) error
- func (mr *MongoResponse) UnmarshalJSON(data []byte) error
type MongoSpec
type Noise
type NoiseParams
type OpenAPI
type Operation
type OriginType
type OutgoingOptions
type OutputBinary
type Package
type ParamSchema
type Parameter
type Params
type PathItem
type Payload
type PostgresSpec
type RedisSchema
type RegularPacket
type ReqCompare
type RequestBody
type RequestYaml
type RespCompare
type ResponseItem
type ResponseYaml
type Result
type RunOptions
type Schema
type SchemaInfo
type SchemaMatchMode
- func (s SchemaMatchMode) String() string
type ServiceSummary
type SessionInfo
type SetupOptions
type Spec
type StartupPacket
type Status
type StringResult
type Summary
type TeleEvent
type TestCase
- func (tc *TestCase) GetKind() string
type TestCoverage
type TestModeInfo
type TestReport
- func (tr *TestReport) GetKind() string
type TestResult
- func (tr *TestResult) GetKind() string
type TestSet
type TestSetStatus
- func StringToTestSetStatus(s string) (TestSetStatus, error)
type TestStatus
type TestingOptions
type TestsetNoise
type URLParamsResult
type UT
type UTDetails
type UTIndentationInfo
type UTInsertionInfo
type UTResult
type Version
- func GetVersion() (V1 Version)

Constants ¶

View Source

const (
	NoSQLDB             string = "NO_SQL_DB"
	SQLDB               string = "SQL_DB"
	GRPC                string = "GRPC"
	HTTPClient          string = "HTTP_CLIENT"
	TestSetPattern      string = "test-set-"
	String              string = "string"
	TestRunTemplateName string = "test-run-"
)

Patterns for different usecases in keploy

View Source

const (
	Unknown    config.Language = "Unknown"    // Unknown language
	Go         config.Language = "go"         // Go language
	Java       config.Language = "java"       // Java language
	Python     config.Language = "python"     // Python language
	Javascript config.Language = "javascript" // Javascript language
)

View Source

const (
	DeviceCodeURL = "https://github.com/login/device/code"
	TokenURL      = "https://github.com/login/oauth/access_token"
)

GitHub URLs

View Source

const (
	MODE_RECORD Mode     = "record"
	MODE_TEST   Mode     = "test"
	MODE_OFF    Mode     = "off"
	KCTX        KctxType = "KeployContext"
	KTime       KctxType = "KeployTime"
)

constants for keploy mode

View Source

const (
	HTTP           Kind     = "Http"
	GENERIC        Kind     = "Generic"
	REDIS          Kind     = "Redis"
	MySQL          Kind     = "MySQL"
	Postgres       Kind     = "Postgres"
	GRPC_EXPORT    Kind     = "gRPC"
	Mongo          Kind     = "Mongo"
	BodyTypeUtf8   BodyType = "utf-8"
	BodyTypeBinary BodyType = "binary"
	BodyTypePlain  BodyType = "PLAIN"
	BodyTypeJSON   BodyType = "JSON"
	BodyTypeError  BodyType = "ERROR"
)

mocks types

View Source

const (
	OpsAdd    = "ADD"
	OpsRemove = "REMOVE"
)

enum for ops

View Source

const ClientConnectionIDKey contextKey = "clientConnectionId"

View Source

const DestConnectionIDKey contextKey = "destConnectionId"

View Source

const ErrGroupKey contextKey = "errGroup"

View Source

const ProtocolVersionNumber uint32 = 196608

ProtocolVersionNumber should be replaced with actual version number if different

View Source

const V1Beta1 = Version("api.keploy.io/v1beta1")

Variables ¶

View Source

var BaseTime = time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)

View Source

var GetFailingColorScheme = func() pp.ColorScheme {
	if IsAnsiDisabled {
		return defaultColorScheme
	}
	return pp.ColorScheme{
		Bool:            pp.Cyan | pp.Bold,
		Integer:         pp.Blue | pp.Bold,
		Float:           pp.Magenta | pp.Bold,
		String:          pp.Red,
		StringQuotation: pp.Red | pp.Bold,
		EscapedChar:     pp.Magenta | pp.Bold,
		FieldName:       pp.Yellow,
		PointerAdress:   pp.Blue | pp.Bold,
		Nil:             pp.Cyan | pp.Bold,
		Time:            pp.Blue | pp.Bold,
		StructName:      pp.White,
		ObjectLength:    pp.Blue,
	}
}

View Source

var GetPassingColorScheme = func() pp.ColorScheme {
	if IsAnsiDisabled {
		return defaultColorScheme
	}
	return pp.ColorScheme{
		String:          pp.Green,
		StringQuotation: pp.Green | pp.Bold,
		FieldName:       pp.White,
		Integer:         pp.Blue | pp.Bold,
		StructName:      pp.NoColor,
		Bool:            pp.Cyan | pp.Bold,
		Float:           pp.Magenta | pp.Bold,
		EscapedChar:     pp.Magenta | pp.Bold,
		PointerAdress:   pp.Blue | pp.Bold,
		Nil:             pp.Cyan | pp.Bold,
		Time:            pp.Blue | pp.Bold,
		ObjectLength:    pp.Blue,
	}
}

View Source

var HighlightFailingString = func(a ...interface{}) string {
	if IsAnsiDisabled {
		return fmt.Sprint(a)
	}
	return color.New(color.FgRed).SprintFunc()(a)
}

View Source

var HighlightGrayString = func(a ...interface{}) string {
	if IsAnsiDisabled {
		return fmt.Sprint(a)
	}
	return color.New(color.FgHiBlack).SprintFunc()(a)
}

View Source

var HighlightPassingString = func(a ...interface{}) string {
	if IsAnsiDisabled {
		return fmt.Sprint(a)
	}
	return color.New(color.FgGreen).SprintFunc()(a)
}

View Source

var HighlightString = func(a ...interface{}) string {
	if IsAnsiDisabled {
		return fmt.Sprint(a)
	}
	return color.New(orangeColorSGR...).SprintFunc()(a)
}

View Source

var IsAnsiDisabled = false

View Source

var (
	PassThroughHosts = []string{"^dc\\.services\\.visualstudio\\.com$"}
)

Functions ¶

func SetMode ¶

func SetMode(m Mode) error

SetMode sets the keploy SDK mode error is returned if the mode is invalid

func SetTestMode ¶

func SetTestMode()

SetTestMode sets the keploy SDK mode to MODE_TEST

func SetVersion ¶

func SetVersion(V1 string)

Types ¶

type AbsResult ¶

type AbsResult struct {
	Kind StringResult `json:"kind" bson:"kind" yaml:"kind"`
	Name StringResult `json:"name" bson:"name" yaml:"name"`
	Req  ReqCompare   `json:"req" bson:"req" yaml:"req"`
	Resp RespCompare  `json:"resp" bson:"resp" yaml:"resp"`
}

type AccessTokenResponse ¶

type AccessTokenResponse struct {
	AccessToken string `json:"access_token"`
	TokenType   string `json:"token_type"`
	Scope       string `json:"scope"`
}

type AppError ¶

type AppError struct {
	AppErrorType AppErrorType
	Err          error
}

func (AppError) Error ¶

func (e AppError) Error() string

type AppErrorType ¶

type AppErrorType string

const (
	ErrCommandError   AppErrorType = "exited due to command error"
	ErrUnExpected     AppErrorType = "an unexpected error occurred"
	ErrInternal       AppErrorType = "an internal error occurred"
	ErrAppStopped     AppErrorType = "app stopped"
	ErrCtxCanceled    AppErrorType = "context canceled"
	ErrTestBinStopped AppErrorType = "test binary stopped"
)

AppErrorType is a type of error that can be returned by the application

type AuthReq ¶

type AuthReq struct {
	InstallationID string `json:"installationID"`
	GitHubToken    string `json:"gitHubtoken"`
}

type AuthResp ¶

type AuthResp struct {
	IsValid  bool   `json:"isValid"`
	EmailID  string `json:"email"`
	JwtToken string `json:"jwtToken"`
	Error    string `json:"error"`
}

type BodyResult ¶

type BodyResult struct {
	Normal   bool     `json:"normal" bson:"normal" yaml:"normal"`
	Type     BodyType `json:"type" bson:"type" yaml:"type"`
	Expected string   `json:"expected" bson:"expected" yaml:"expected"`
	Actual   string   `json:"actual" bson:"actual" yaml:"actual"`
}

type BodyType ¶

type BodyType string

type Class ¶

type Class struct {
	Name     string `xml:"name,attr"`
	FileName string `xml:"filename,attr"`
	Lines    []Line `xml:"lines>line"`
}

type Cobertura ¶

type Cobertura struct {
	XMLName  xml.Name  `xml:"coverage"`
	Sources  []string  `xml:"sources>source"`
	Packages []Package `xml:"packages>package"`
}

type Counter ¶

type Counter struct {
	Type    string `xml:"type,attr"`
	Missed  string `xml:"missed,attr"`
	Covered string `xml:"covered,attr"`
}

type CoverageResult ¶

type CoverageResult struct {
	LinesCovered  []int
	LinesMissed   []int
	Coverage      float64
	Files         []string
	ReportContent string
}

type DepMetaResult ¶

type DepMetaResult struct {
	Normal   bool   `json:"normal" bson:"normal" yaml:"normal"`
	Key      string `json:"key" bson:"key" yaml:"key"`
	Expected string `json:"expected" bson:"expected" yaml:"expected"`
	Actual   string `json:"actual" bson:"actual" yaml:"actual"`
}

type DepResult ¶

type DepResult struct {
	Name string          `json:"name" bson:"name" yaml:"name"`
	Type string          `json:"type" bson:"type" yaml:"type"`
	Meta []DepMetaResult `json:"meta" bson:"meta" yaml:"meta"`
}

type DeviceCodeResponse ¶

type DeviceCodeResponse struct {
	DeviceCode      string `json:"device_code"`
	UserCode        string `json:"user_code"`
	VerificationURI string `json:"verification_uri"`
	Interval        int    `json:"interval"`
}

type DrivenMode ¶

type DrivenMode int

DrivenMode defines the possible modes for driven contexts.

const (
	// ConsumerMode is used for a consumer context.
	ConsumerMode DrivenMode = iota

	// ProviderMode is used for a provider context.
	ProviderMode
)

func (DrivenMode) String ¶

func (d DrivenMode) String() string

String returns the string representation of the DrivenMode.

type FailedUT ¶

type FailedUT struct {
	TestCode string `yaml:"test_code"`
	ErrorMsg string `yaml:"error_msg"`
}

type FormData ¶

type FormData struct {
	Key    string   `json:"key" bson:"key" yaml:"key"`
	Values []string `json:"values" bson:"values,omitempty" yaml:"values,omitempty"`
	Paths  []string `json:"paths" bson:"paths,omitempty" yaml:"paths,omitempty"`
}

type Frame ¶

type Frame struct {
	Version Version     `json:"version" yaml:"version"`
	Kind    Kind        `json:"kind" yaml:"kind"`
	Name    string      `json:"name" yaml:"name"`
	Spec    interface{} `json:"spec" yaml:"spec"`
	Curl    string      `json:"curl" yaml:"curl,omitempty"`
}

type Frontend ¶

type Frontend struct {
	PacketTypes                     []string                                 `json:"header,omitempty" yaml:"header,omitempty,flow"`
	Identfier                       string                                   `json:"identifier,omitempty" yaml:"identifier,omitempty"`
	Length                          uint32                                   `json:"length,omitempty" yaml:"length,omitempty"`
	Payload                         string                                   `json:"payload,omitempty" yaml:"payload,omitempty"`
	AuthenticationOk                pgproto3.AuthenticationOk                `json:"authentication_ok,omitempty" yaml:"authentication_ok,omitempty"`
	AuthenticationCleartextPassword pgproto3.AuthenticationCleartextPassword `json:"authentication_cleartext_password,omitempty" yaml:"authentication_cleartext_password,omitempty"`
	AuthenticationMD5Password       pgproto3.AuthenticationMD5Password       `json:"authentication_md5_password,omitempty" yaml:"authentication_md5_password,omitempty"`
	AuthenticationGSS               pgproto3.AuthenticationGSS               `json:"authentication_gss,omitempty" yaml:"authentication_gss,omitempty"`
	AuthenticationGSSContinue       pgproto3.AuthenticationGSSContinue       `json:"authentication_gss_continue,omitempty" yaml:"authentication_gss_continue,omitempty"`
	AuthenticationSASL              pgproto3.AuthenticationSASL              `json:"authentication_sasl,omitempty" yaml:"authentication_sasl,omitempty"`
	AuthenticationSASLContinue      pgproto3.AuthenticationSASLContinue      `json:"authentication_sasl_continue,omitempty" yaml:"authentication_sasl_continue,omitempty,flow"`
	AuthenticationSASLFinal         pgproto3.AuthenticationSASLFinal         `json:"authentication_sasl_final,omitempty" yaml:"authentication_sasl_final,omitempty,flow"`
	BackendKeyData                  pgproto3.BackendKeyData                  `json:"backend_key_data,omitempty" yaml:"backend_key_data,omitempty"`
	BindComplete                    pgproto3.BindComplete                    `yaml:"-"`
	BindCompletes                   []pgproto3.BindComplete                  `json:"bind_complete,omitempty" yaml:"bind_complete,omitempty"`
	CloseComplete                   pgproto3.CloseComplete                   `json:"close_complete,omitempty" yaml:"close_complete,omitempty"`
	CommandComplete                 pgproto3.CommandComplete                 `yaml:"-"`
	CommandCompletes                []pgproto3.CommandComplete               `json:"command_complete,omitempty" yaml:"command_complete,omitempty"`
	CopyBothResponse                pgproto3.CopyBothResponse                `json:"copy_both_response,omitempty" yaml:"copy_both_response,omitempty"`
	CopyData                        pgproto3.CopyData                        `json:"copy_data,omitempty" yaml:"copy_data,omitempty"`
	CopyInResponse                  pgproto3.CopyInResponse                  `json:"copy_in_response,omitempty" yaml:"copy_in_response,omitempty"`
	CopyOutResponse                 pgproto3.CopyOutResponse                 `json:"copy_out_response,omitempty" yaml:"copy_out_response,omitempty"`
	CopyDone                        pgproto3.CopyDone                        `json:"copy_done,omitempty" yaml:"copy_done,omitempty"`
	DataRow                         pgproto3.DataRow                         `yaml:"-"`
	DataRows                        []pgproto3.DataRow                       `json:"data_row,omitempty" yaml:"data_row,omitempty,flow"`
	EmptyQueryResponse              pgproto3.EmptyQueryResponse              `json:"empty_query_response,omitempty" yaml:"empty_query_response,omitempty"`
	ErrorResponse                   pgproto3.ErrorResponse                   `json:"error_response,omitempty" yaml:"error_response,omitempty"`
	FunctionCallResponse            pgproto3.FunctionCallResponse            `json:"function_call_response,omitempty" yaml:"function_call_response,omitempty"`
	NoData                          pgproto3.NoData                          `json:"no_data,omitempty" yaml:"no_data,omitempty"`
	NoticeResponse                  pgproto3.NoticeResponse                  `json:"notice_response,omitempty" yaml:"notice_response,omitempty"`
	NotificationResponse            pgproto3.NotificationResponse            `json:"notification_response,omitempty" yaml:"notification_response,omitempty"`
	ParameterDescription            pgproto3.ParameterDescription            `json:"parameter_description,omitempty" yaml:"parameter_description,omitempty"`
	ParameterStatus                 pgproto3.ParameterStatus                 `yaml:"-"`
	ParameterStatusCombined         []pgproto3.ParameterStatus               `json:"parameter_status,omitempty" yaml:"parameter_status,omitempty"`
	ParseComplete                   pgproto3.ParseComplete                   `yaml:"-"`
	ParseCompletes                  []pgproto3.ParseComplete                 `json:"parse_complete,omitempty" yaml:"parse_complete,omitempty"`
	ReadyForQuery                   pgproto3.ReadyForQuery                   `json:"ready_for_query,omitempty" yaml:"ready_for_query,omitempty"`
	RowDescription                  pgproto3.RowDescription                  `json:"row_description,omitempty" yaml:"row_description,omitempty,flow"`
	PortalSuspended                 pgproto3.PortalSuspended                 `json:"portal_suspended,omitempty" yaml:"portal_suspended,omitempty"`
	MsgType                         byte                                     `json:"msg_type,omitempty" yaml:"msg_type,omitempty"`
	AuthType                        int32                                    `json:"auth_type" yaml:"auth_type"`
	// AuthMechanism                   string                                   `json:"auth_mechanism,omitempty" yaml:"auth_mechanism,omitempty"`
	BodyLen int `json:"body_len,omitempty" yaml:"body_len,omitempty"`
}

type GenericSchema ¶

type GenericSchema struct {
	Metadata         map[string]string `json:"metadata" yaml:"metadata"`
	GenericRequests  []Payload         `json:"RequestBin,omitempty"`
	GenericResponses []Payload         `json:"ResponseBin,omitempty"`
	ReqTimestampMock time.Time         `json:"reqTimestampMock,omitempty"`
	ResTimestampMock time.Time         `json:"resTimestampMock,omitempty"`
}

type GlobalNoise ¶

type GlobalNoise map[string]map[string][]string

type GrpcHeaders ¶

type GrpcHeaders struct {
	PseudoHeaders   map[string]string `json:"pseudo_headers" yaml:"pseudo_headers"`
	OrdinaryHeaders map[string]string `json:"ordinary_headers" yaml:"ordinary_headers"`
}

type GrpcLengthPrefixedMessage ¶

type GrpcLengthPrefixedMessage struct {
	CompressionFlag uint   `json:"compression_flag" yaml:"compression_flag"`
	MessageLength   uint32 `json:"message_length" yaml:"message_length"`
	DecodedData     string `json:"decoded_data" yaml:"decoded_data"`
}

type GrpcReq ¶

type GrpcReq struct {
	Headers GrpcHeaders               `json:"headers" yaml:"headers"`
	Body    GrpcLengthPrefixedMessage `json:"body" yaml:"body"`
}

type GrpcResp ¶

type GrpcResp struct {
	Headers  GrpcHeaders               `json:"headers" yaml:"headers"`
	Body     GrpcLengthPrefixedMessage `json:"body" yaml:"body"`
	Trailers GrpcHeaders               `json:"trailers" yaml:"trailers"`
}

type GrpcSpec ¶

type GrpcSpec struct {
	GrpcReq          GrpcReq   `json:"grpcReq" yaml:"grpcReq"`
	GrpcResp         GrpcResp  `json:"grpcResp" yaml:"grpcResp"`
	ReqTimestampMock time.Time `json:"reqTimestampMock" yaml:"reqTimestampMock,omitempty"`
	ResTimestampMock time.Time `json:"resTimestampMock" yaml:"resTimestampMock,omitempty"`
}

type GrpcStream ¶

type GrpcStream struct {
	StreamID uint32
	GrpcReq  GrpcReq
	GrpcResp GrpcResp
}

GrpcStream is a helper function to combine the request-response model in a single struct.

func NewGrpcStream ¶

func NewGrpcStream(streamID uint32) GrpcStream

NewGrpcStream returns a GrpcStream with all the nested maps initialised.

type HTTPDoc ¶

type HTTPDoc struct {
	Version string     `json:"version" yaml:"version"`
	Kind    string     `json:"kind" yaml:"kind"`
	Name    string     `json:"name" yaml:"name"`
	Spec    HTTPSchema `json:"spec" yaml:"spec"`
}

type HTTPReq ¶

type HTTPReq struct {
	Method     Method            `json:"method" yaml:"method"`
	ProtoMajor int               `json:"proto_major" yaml:"proto_major"` // e.g. 1
	ProtoMinor int               `json:"proto_minor" yaml:"proto_minor"` // e.g. 0
	URL        string            `json:"url" yaml:"url"`
	URLParams  map[string]string `json:"url_params" yaml:"url_params,omitempty"`
	Header     map[string]string `json:"header" yaml:"header"`
	Body       string            `json:"body" yaml:"body"`
	Binary     string            `json:"binary" yaml:"binary,omitempty"`
	Form       []FormData        `json:"form" yaml:"form,omitempty"`
	Timestamp  time.Time         `json:"timestamp" yaml:"timestamp"`
}

type HTTPResp ¶

type HTTPResp struct {
	StatusCode    int               `json:"status_code" yaml:"status_code"` // e.g. 200
	Header        map[string]string `json:"header" yaml:"header"`
	Body          string            `json:"body" yaml:"body"`
	StatusMessage string            `json:"status_message" yaml:"status_message"`
	ProtoMajor    int               `json:"proto_major" yaml:"proto_major"`
	ProtoMinor    int               `json:"proto_minor" yaml:"proto_minor"`
	Binary        string            `json:"binary" yaml:"binary,omitempty"`
	Timestamp     time.Time         `json:"timestamp" yaml:"timestamp"`
}

type HTTPSchema ¶

type HTTPSchema struct {
	Metadata         map[string]string      `json:"metadata" yaml:"metadata"`
	Request          HTTPReq                `json:"req" yaml:"req"`
	Response         HTTPResp               `json:"resp" yaml:"resp"`
	Objects          []*OutputBinary        `json:"objects" yaml:"objects"`
	Assertions       map[string]interface{} `json:"assertions" yaml:"assertions,omitempty"`
	Created          int64                  `json:"created" yaml:"created,omitempty"`
	ReqTimestampMock time.Time              `json:"reqTimestampMock" yaml:"reqTimestampMock,omitempty"`
	ResTimestampMock time.Time              `json:"resTimestampMock" yaml:"resTimestampMock,omitempty"`
}

type Header ¶

type Header struct {
	Key   string   `json:"key" bson:"key" yaml:"key"`
	Value []string `json:"value" bson:"value" yaml:"value"`
}

type HeaderResult ¶

type HeaderResult struct {
	Normal   bool   `json:"normal" bson:"normal" yaml:"normal"`
	Expected Header `json:"expected" bson:"expected" yaml:"expected"`
	Actual   Header `json:"actual" bson:"actual" yaml:"actual"`
}

type HookOptions ¶

type HookOptions struct {
	Mode          Mode
	EnableTesting bool
}

type IncomingOptions ¶

type IncomingOptions struct {
	Filters []config.Filter
}

type Info ¶

type Info struct {
	Title       string `json:"title" yaml:"title"`
	Version     string `json:"version" yaml:"version"`
	Description string `json:"description" yaml:"description"`
}

type IntResult ¶

type IntResult struct {
	Normal   bool `json:"normal" bson:"normal" yaml:"normal"`
	Expected int  `json:"expected" bson:"expected" yaml:"expected"`
	Actual   int  `json:"actual" bson:"actual" yaml:"actual"`
}

type Jacoco ¶

type Jacoco struct {
	Name        string          `xml:"name,attr"`
	XMLName     xml.Name        `xml:"report"`
	Packages    []JacocoPackage `xml:"package"`
	SessionInfo []SessionInfo   `xml:"sessioninfo"`
}

type JacocoClass ¶

type JacocoClass struct {
	Name       string         `xml:"name,attr"`
	SourceFile string         `xml:"sourcefilename,attr"`
	Methods    []JacocoMethod `xml:"method"`
	Lines      []JacocoLine   `xml:"line"` // This is where JacocoLine is used
}

type JacocoLine ¶

type JacocoLine struct {
	Number              string `xml:"nr,attr"`
	MissedInstructions  string `xml:"mi,attr"`
	CoveredInstructions string `xml:"ci,attr"`
	MissedBranches      string `xml:"mb,attr"`
	CoveredBranches     string `xml:"cb,attr"`
}

type JacocoMethod ¶

type JacocoMethod struct {
	Name       string    `xml:"name,attr"`
	Descriptor string    `xml:"desc,attr"`
	Line       string    `xml:"line,attr"`
	Counters   []Counter `xml:"counter"`
}

type JacocoPackage ¶

type JacocoPackage struct {
	Name        string             `xml:"name,attr"`
	Classes     []JacocoClass      `xml:"class"`
	Counters    []Counter          `xml:"counter"`
	SourceFiles []JacocoSourceFile `xml:"sourcefile"` // Adding this field to capture source files
}

type JacocoSourceFile ¶

type JacocoSourceFile struct {
	Name     string       `xml:"name,attr"`
	Lines    []JacocoLine `xml:"line"`
	Counters []Counter    `xml:"counter"`
}

type KctxType ¶

type KctxType string

type Kind ¶

type Kind string

type Line ¶

type Line struct {
	Number int `xml:"number,attr"`
	Hits   int `xml:"hits,attr"`
}

type MediaType ¶

type MediaType struct {
	Schema  Schema                 `json:"schema" yaml:"schema"`
	Example map[string]interface{} `json:"example" yaml:"example"`
}

type Method ¶

type Method string

type Mock ¶

type Mock struct {
	Version      Version      `json:"Version,omitempty" bson:"Version,omitempty"`
	Name         string       `json:"Name,omitempty" bson:"Name,omitempty"`
	Kind         Kind         `json:"Kind,omitempty" bson:"Kind,omitempty"`
	Spec         MockSpec     `json:"Spec,omitempty" bson:"Spec,omitempty"`
	TestModeInfo TestModeInfo `json:"TestModeInfo,omitempty"  bson:"TestModeInfo,omitempty"` // Map for additional test mode information
	ConnectionID string       `json:"ConnectionId,omitempty" bson:"ConnectionId,omitempty"`
}

func (*Mock) GetKind ¶

func (m *Mock) GetKind() string

type MockMapping ¶

type MockMapping struct {
	Service   string     `json:"service" yaml:"service"`
	TestSetID string     `json:"testSetId" yaml:"testSetId"`
	Mocks     []*OpenAPI `json:"mocks" yaml:"mocks"`
}

type MockRegistry ¶

type MockRegistry struct {
	Mock string `json:"mock" bson:"mock" yaml:"mock,omitempty"`
	App  string `json:"app" bson:"app" yaml:"app,omitempty"`
	User string `json:"user" bson:"user" yaml:"user,omitempty"`
}

type MockSpec ¶

type MockSpec struct {
	Metadata          map[string]string `` /* 139-byte string literal not displayed */
	GenericRequests   []Payload         `json:"RequestBin,omitempty" bson:"generic_requests,omitempty"`
	GenericResponses  []Payload         `json:"ResponseBin,omitempty" bson:"generic_responses,omitempty"`
	RedisRequests     []Payload         `json:"redisRequests,omitempty" bson:"redis_requests,omitempty"`
	RedisResponses    []Payload         `json:"redisResponses,omitempty" bson:"redis_responses,omitempty"`
	HTTPReq           *HTTPReq          `json:"Req,omitempty" bson:"http_req,omitempty"`
	HTTPResp          *HTTPResp         `json:"Res,omitempty" bson:"http_resp,omitempty"`
	Created           int64             `json:"Created,omitempty" bson:"created,omitempty"`
	MongoRequests     []MongoRequest    `json:"MongoRequests,omitempty" bson:"mongo_requests,omitempty"`
	MongoResponses    []MongoResponse   `json:"MongoResponses,omitempty" bson:"mongo_responses,omitempty"`
	PostgresRequests  []Backend         `json:"postgresRequests,omitempty" bson:"postgres_requests,omitempty"`
	PostgresResponses []Frontend        `json:"postgresResponses,omitempty" bson:"postgres_responses,omitempty"`
	GRPCReq           *GrpcReq          `json:"gRPCRequest,omitempty" bson:"grpc_req,omitempty"`
	GRPCResp          *GrpcResp         `json:"grpcResponse,omitempty" bson:"grpc_resp,omitempty"`
	MySQLRequests     []mysql.Request   `json:"MySqlRequests,omitempty" bson:"my_sql_requests,omitempty"`
	MySQLResponses    []mysql.Response  `json:"MySqlResponses,omitempty" bson:"my_sql_responses,omitempty"`
	ReqTimestampMock  time.Time         `json:"ReqTimestampMock,omitempty" bson:"req_timestamp_mock,omitempty"`
	ResTimestampMock  time.Time         `json:"ResTimestampMock,omitempty" bson:"res_timestamp_mock,omitempty"`
}

type Mode ¶

type Mode string

Mode represents the mode at which the SDK is operating MODE_RECORD is for recording API calls to generate testcases MODE_TEST is for testing the application on previous recorded testcases MODE_OFF disables keploy SDK automatically from the application

func GetMode ¶

func GetMode() Mode

GetMode returns the mode of the keploy SDK

func (Mode) Valid ¶

func (m Mode) Valid() bool

Valid checks if the provided mode is valid

type ModeKey ¶

type ModeKey uint32

const (
	RecordKey ModeKey = 0
	TestKey   ModeKey = 1
)

These are the keys used to send the keploy record and test ports and pids to the ebpf program when testbench is enabled

type MongoHeader ¶

type MongoHeader struct {
	Length     int32              `json:"length" yaml:"length" bson:"length"`
	RequestID  int32              `json:"requestId" yaml:"requestId" bson:"request_id"`
	ResponseTo int32              `json:"responseTo" yaml:"responseTo" bson:"response_to"`
	Opcode     wiremessage.OpCode `json:"Opcode" yaml:"Opcode" bson:"opcode"`
}

type MongoOpMessage ¶

type MongoOpMessage struct {
	FlagBits int      `json:"flagBits" yaml:"flagBits" bson:"flagBits"`
	Sections []string `json:"sections" yaml:"sections" bson:"sections"`
	Checksum int      `json:"checksum" yaml:"checksum" bson:"checksum"`
}

type MongoOpQuery ¶

type MongoOpQuery struct {
	Flags                int32  `json:"flags" yaml:"flags" bson:"flags"`
	FullCollectionName   string `json:"collection_name" yaml:"collection_name" bson:"collection_name"`
	NumberToSkip         int32  `json:"number_to_skip" yaml:"number_to_skip" bson:"number_to_skip"`
	NumberToReturn       int32  `json:"number_to_return" yaml:"number_to_return" bson:"number_to_return"`
	Query                string `json:"query" yaml:"query" bson:"query"`
	ReturnFieldsSelector string `json:"return_fields_selector" yaml:"return_fields_selector" bson:"return_fields_selector"`
}

type MongoOpReply ¶

type MongoOpReply struct {
	ResponseFlags  int32    `json:"response_flags" yaml:"response_flags" bson:"response_flags"`
	CursorID       int64    `json:"cursor_id" yaml:"cursor_id" bson:"cursor_id"`
	StartingFrom   int32    `json:"starting_from" yaml:"starting_from" bson:"starting_from"`
	NumberReturned int32    `json:"number_returned" yaml:"number_returned" bson:"number_returned"`
	Documents      []string `json:"documents" yaml:"documents" bson:"documents"`
}

type MongoRequest ¶

type MongoRequest struct {
	Header    *MongoHeader `json:"header,omitempty" yaml:"header,omitempty" bson:"header,omitempty"`
	Message   interface{}  `json:"message,omitempty" yaml:"message,omitempty" bson:"message,omitempty"`
	ReadDelay int64        `json:"read_delay,omitempty" yaml:"read_delay,omitempty" bson:"read_delay,omitempty"`
}

func (*MongoRequest) MarshalJSON ¶

func (mr *MongoRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler for mongoRequests because of interface typeof field

func (*MongoRequest) UnmarshalBSON ¶

func (mr *MongoRequest) UnmarshalBSON(data []byte) error

UnmarshalBSON implements bson.Unmarshaler for mongoRequests because of interface typeof field

func (*MongoRequest) UnmarshalJSON ¶

func (mr *MongoRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements json.Unmarshaler for mongoRequests because of interface typeof field

type MongoResponse ¶

type MongoResponse struct {
	Header    *MongoHeader `json:"header,omitempty" yaml:"header,omitempty" bson:"header,omitempty"`
	Message   interface{}  `json:"message,omitempty" yaml:"message,omitempty" bson:"message,omitempty"`
	ReadDelay int64        `json:"read_delay,omitempty" yaml:"read_delay,omitempty" bson:"read_delay,omitempty"`
}

func (*MongoResponse) MarshalJSON ¶

func (mr *MongoResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler for mongoResponses because of interface typeof field

func (*MongoResponse) UnmarshalBSON ¶

func (mr *MongoResponse) UnmarshalBSON(data []byte) error

UnmarshalBSON implements bson.Unmarshaler for mongoResponses because of interface typeof field

func (*MongoResponse) UnmarshalJSON ¶

func (mr *MongoResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements json.Unmarshaler for mongoResponses because of interface typeof field

type MongoSpec ¶

type MongoSpec struct {
	Metadata         map[string]string `json:"metadata" yaml:"metadata"`
	Requests         []RequestYaml     `json:"requests" yaml:"requests"`
	Response         []ResponseYaml    `json:"responses" yaml:"responses"`
	CreatedAt        int64             `json:"created" yaml:"created,omitempty"`
	ReqTimestampMock time.Time         `json:"reqTimestampMock" yaml:"reqTimestampMock,omitempty"`
	ResTimestampMock time.Time         `json:"resTimestampMock" yaml:"resTimestampMock,omitempty"`
}

type Noise ¶

type Noise map[string][]string

type NoiseParams ¶

type NoiseParams struct {
	TestCaseID string              `json:"testCaseID"`
	EditedBy   string              `json:"editedBy"`
	Assertion  map[string][]string `json:"assertion"`
	Ops        string              `json:"ops"`
	AfterNoise map[string][]string `json:"afterNoise"`
}

type OpenAPI ¶

type OpenAPI struct {
	OpenAPI    string                 `json:"openapi" yaml:"openapi"`
	Info       Info                   `json:"info" yaml:"info"`
	Servers    []map[string]string    `json:"servers" yaml:"servers"`
	Paths      map[string]PathItem    `json:"paths" yaml:"paths"`
	Components map[string]interface{} `json:"components" yaml:"components"`
}

type Operation ¶

type Operation struct {
	Summary     string                  `json:"summary" yaml:"summary"`
	Description string                  `json:"description" yaml:"description"`
	Parameters  []Parameter             `json:"parameters" yaml:"parameters"`
	OperationID string                  `json:"operationId" yaml:"operationId"`
	RequestBody *RequestBody            `json:"requestBody,omitempty" yaml:"requestBody,omitempty"`
	Responses   map[string]ResponseItem `json:"responses" yaml:"responses"`
}

type OriginType ¶

type OriginType string

const (
	FromServer OriginType = "server"
	FromClient OriginType = "client"
)

constant for mock origin

type OutgoingOptions ¶

type OutgoingOptions struct {
	Rules         []config.BypassRule
	MongoPassword string
	// TODO: role of SQLDelay should be mentioned in the comments.
	SQLDelay       time.Duration // This is the same as Application delay.
	FallBackOnMiss bool          // this enables to pass the request to the actual server if no mock is found during test mode.
	Mocking        bool          // used to enable/disable mocking
}

type OutputBinary ¶

type OutputBinary struct {
	Type string `json:"type" bson:"type" yaml:"type"`
	Data string `json:"data" bson:"data" yaml:"data"`
}

OutputBinary store the encoded binary output of the egress calls as base64-encoded strings

type Package ¶

type Package struct {
	Name    string  `xml:"name,attr"`
	Classes []Class `xml:"classes>class"`
}

type ParamSchema ¶

type ParamSchema struct {
	Type string `json:"type" yaml:"type"`
}

type Parameter ¶

type Parameter struct {
	Name     string      `json:"name" yaml:"name"`
	In       string      `json:"in" yaml:"in"`
	Required bool        `json:"required" yaml:"required"`
	Schema   ParamSchema `json:"schema" yaml:"schema"`
	Example  string      `json:"example" yaml:"example"`
}

type Params ¶

type Params struct {
	Key   string `json:"key" bson:"key" yaml:"key"`
	Value string `json:"value" bson:"value" yaml:"value"`
}

type PathItem ¶

type PathItem struct {
	Get    *Operation `json:"get,omitempty" yaml:"get,omitempty"`
	Post   *Operation `json:"post,omitempty" yaml:"post,omitempty"`
	Put    *Operation `json:"put,omitempty" yaml:"put,omitempty"`
	Delete *Operation `json:"delete,omitempty" yaml:"delete,omitempty"`
	Patch  *Operation `json:"patch,omitempty" yaml:"patch,omitempty"`
}

type Payload ¶

type Payload struct {
	Origin  OriginType     `json:"Origin,omitempty" yaml:"origin" bson:"origin,omitempty"`
	Message []OutputBinary `json:"Message,omitempty" yaml:"message" bson:"message,omitempty"`
}

type PostgresSpec ¶

type PostgresSpec struct {
	Metadata map[string]string `json:"metadata" yaml:"metadata"`

	// Objects  []*models.OutputBinary          `json:"objects" yaml:"objects"`
	PostgresRequests  []Backend  `json:"RequestBin,omitempty"`
	PostgresResponses []Frontend `json:"ResponseBin,omitempty"`

	ReqTimestampMock time.Time `json:"ReqTimestampMock,omitempty"`
	ResTimestampMock time.Time `json:"ResTimestampMock,omitempty"`
}

type RedisSchema ¶

type RedisSchema struct {
	Metadata         map[string]string `json:"metadata" yaml:"metadata"`
	RedisRequests    []Payload         `json:"RequestBin,omitempty"`
	RedisResponses   []Payload         `json:"ResponseBin,omitempty"`
	ReqTimestampMock time.Time         `json:"reqTimestampMock,omitempty"`
	ResTimestampMock time.Time         `json:"resTimestampMock,omitempty"`
}

type RegularPacket ¶

type RegularPacket struct {
	Identifier byte
	Length     uint32
	Payload    []byte
}

type ReqCompare ¶

type ReqCompare struct {
	MethodResult    StringResult      `json:"method_result" bson:"method_result" yaml:"method_result"`
	URLResult       StringResult      `json:"url_result" bson:"url_result" yaml:"url_result"`
	URLParamsResult []URLParamsResult `json:"url_params_result" bson:"url_params_result" yaml:"url_params_result"`
	ProtoMajor      IntResult         `json:"proto_major" bson:"proto_major" yaml:"proto_major"`
	ProtoMinor      IntResult         `json:"proto_minor" bson:"proto_minor" yaml:"proto_minor"`
	HeaderResult    []HeaderResult    `json:"headers_result" bson:"headers_result" yaml:"headers_result"`
	BodyResult      BodyResult        `json:"body_result" bson:"body_result" yaml:"body_result"`
}

type RequestBody ¶

type RequestBody struct {
	Content map[string]MediaType `json:"content" yaml:"content"`
}

type RequestYaml ¶

type RequestYaml struct {
	Header    *MongoHeader `json:"header,omitempty" yaml:"header"`
	Message   yaml.Node    `json:"message,omitempty" yaml:"message"`
	ReadDelay int64        `json:"read_delay,omitempty" yaml:"read_delay,omitempty"`
}

type RespCompare ¶

type RespCompare struct {
	StatusCode    IntResult      `json:"status_code" bson:"status_code" yaml:"status_code"`
	HeadersResult []HeaderResult `json:"headers_result" bson:"headers_result" yaml:"headers_result"`
	BodyResult    BodyResult     `json:"body_result" bson:"body_result" yaml:"body_result"`
}

type ResponseItem ¶

type ResponseItem struct {
	Description string               `json:"description" yaml:"description"`
	Content     map[string]MediaType `json:"content" yaml:"content"`
}

type ResponseYaml ¶

type ResponseYaml struct {
	Header    *MongoHeader `json:"header,omitempty" yaml:"header"`
	Message   yaml.Node    `json:"message,omitempty" yaml:"message"`
	ReadDelay int64        `json:"read_delay,omitempty" yaml:"read_delay,omitempty"`
}

type Result ¶

type Result struct {
	StatusCode    IntResult      `json:"status_code" bson:"status_code" yaml:"status_code"`
	HeadersResult []HeaderResult `json:"headers_result" bson:"headers_result" yaml:"headers_result"`
	BodyResult    []BodyResult   `json:"body_result" bson:"body_result" yaml:"body_result"`
	DepResult     []DepResult    `json:"dep_result" bson:"dep_result" yaml:"dep_result"`
}

type RunOptions ¶

type RunOptions struct {
}

type Schema ¶

type Schema struct {
	Type       string                            `json:"type" yaml:"type"`
	Properties map[string]map[string]interface{} `json:"properties" yaml:"properties"`
}

type SchemaInfo ¶

type SchemaInfo struct {
	Service   string  `json:"service" yaml:"service"`
	TestSetID string  `json:"testSetId" yaml:"testSetId"`
	Name      string  `json:"name" yaml:"name"`
	Score     float64 `json:"score" yaml:"score"`
	Data      OpenAPI `json:"data" yaml:"data"`
}

type SchemaMatchMode ¶

type SchemaMatchMode int

SchemaMatchMode defines the possible modes for schema matching.

const (
	// IdentifyMode is used for identifying schema.
	IdentifyMode SchemaMatchMode = iota

	// CompareMode is used for comparing schemas.
	CompareMode
)

func (SchemaMatchMode) String ¶

func (s SchemaMatchMode) String() string

String returns the string representation of the SchemaMatchMode.

type ServiceSummary ¶

type ServiceSummary struct {
	Service     string            `json:"service" yaml:"service"`
	TestSets    map[string]Status `json:"testSets" yaml:"testSets"`
	PassedCount int               `json:"passedCount" yaml:"passedCount"`
	FailedCount int               `json:"failedCount" yaml:"failedCount"`
	MissedCount int               `json:"missedCount" yaml:"missedCount"`
}

type SessionInfo ¶

type SessionInfo struct {
	ID    string `xml:"id,attr"`
	Start string `xml:"start,attr"`
	Dump  string `xml:"dump,attr"`
}

type SetupOptions ¶

type SetupOptions struct {
	Container     string
	DockerNetwork string
	DockerDelay   uint64
}

type Spec ¶

type Spec struct {
}

type StartupPacket ¶

type StartupPacket struct {
	Length          uint32
	ProtocolVersion uint32
}

type Status ¶

type Status struct {
	Failed []string `json:"failed" yaml:"failed"`
	Passed []string `json:"passed" yaml:"passed"`
	Missed []string `json:"missed" yaml:"missed"`
}

type StringResult ¶

type StringResult struct {
	Normal   bool   `json:"normal" bson:"normal" yaml:"normal"`
	Expected string `json:"expected" bson:"expected" yaml:"expected"`
	Actual   string `json:"actual" bson:"actual" yaml:"actual"`
}

type Summary ¶

type Summary struct {
	ServicesSummary []ServiceSummary `json:"servicesSummary" yaml:"servicesSummary"`
}

type TeleEvent ¶

type TeleEvent struct {
	InstallationID string                 `json:"installationId"`
	EventType      string                 `json:"eventType"`
	Meta           map[string]interface{} `json:"meta"`
	CreatedAt      int64                  `json:"createdAt"`
	TeleCheck      bool                   `json:"tele_check"`
	OS             string                 `json:"os"`
	KeployVersion  string                 `json:"keploy_version"`
	Arch           string                 `json:"arch"`
}

type TestCase ¶

type TestCase struct {
	Version  Version             `json:"version" bson:"version"`
	Kind     Kind                `json:"kind" bson:"kind"`
	Name     string              `json:"name" bson:"name"`
	Created  int64               `json:"created" bson:"created"`
	Updated  int64               `json:"updated" bson:"updated"`
	Captured int64               `json:"captured" bson:"captured"`
	HTTPReq  HTTPReq             `json:"http_req" bson:"http_req"`
	HTTPResp HTTPResp            `json:"http_resp" bson:"http_resp"`
	AllKeys  map[string][]string `json:"all_keys" bson:"all_keys"`
	GrpcResp GrpcResp            `json:"grpcResp" bson:"grpcResp"`
	GrpcReq  GrpcReq             `json:"grpcReq" bson:"grpcReq"`
	Anchors  map[string][]string `json:"anchors" bson:"anchors"`
	Noise    map[string][]string `json:"noise" bson:"noise"`
	Mocks    []*Mock             `json:"mocks" bson:"mocks"`
	Type     string              `json:"type" bson:"type"`
	Curl     string              `json:"curl" bson:"curl"`
}

func (*TestCase) GetKind ¶

func (tc *TestCase) GetKind() string

type TestCoverage ¶

type TestCoverage struct {
	FileCov  map[string]string `json:"fileCoverage" yaml:"file_coverage"`
	TotalCov string            `json:"totalCoverage" yaml:"total_coverage"`
}

type TestModeInfo ¶

type TestModeInfo struct {
	ID         int  `json:"Id,omitempty" bson:"Id,omitempty"`
	IsFiltered bool `json:"isFiltered,omitempty" bson:"isFiltered,omitempty"`
	SortOrder  int  `json:"sortOrder,omitempty" bson:"SortOrder,omitempty"`
}

type TestReport ¶

type TestReport struct {
	Version Version      `json:"version" yaml:"version"`
	Name    string       `json:"name" yaml:"name"`
	Status  string       `json:"status" yaml:"status"`
	Success int          `json:"success" yaml:"success"`
	Failure int          `json:"failure" yaml:"failure"`
	Ignored int          `json:"ignored" yaml:"ignored"`
	Total   int          `json:"total" yaml:"total"`
	Tests   []TestResult `json:"tests" yaml:"tests,omitempty"`
	TestSet string       `json:"testSet" yaml:"test_set"`
}

func (*TestReport) GetKind ¶

func (tr *TestReport) GetKind() string

type TestResult ¶

type TestResult struct {
	Kind         Kind       `json:"kind" yaml:"kind"`
	Name         string     `json:"name" yaml:"name"`
	Status       TestStatus `json:"status" yaml:"status"`
	Started      int64      `json:"started" yaml:"started"`
	Completed    int64      `json:"completed" yaml:"completed"`
	TestCasePath string     `json:"testCasePath" yaml:"test_case_path"`
	MockPath     string     `json:"mockPath" yaml:"mock_path"`
	TestCaseID   string     `json:"testCaseID" yaml:"test_case_id"`
	Req          HTTPReq    `json:"req" yaml:"req,omitempty"`
	Res          HTTPResp   `json:"resp" yaml:"resp,omitempty"`
	Noise        Noise      `json:"noise" yaml:"noise,omitempty"`
	Result       Result     `json:"result" yaml:"result"`
}

func (*TestResult) GetKind ¶

func (tr *TestResult) GetKind() string

type TestSet ¶

type TestSet struct {
	PreScript    string                 `json:"pre_script" bson:"pre_script" yaml:"preScript"`
	PostScript   string                 `json:"post_script" bson:"post_script" yaml:"postScript"`
	Template     map[string]interface{} `json:"template" bson:"template" yaml:"template"`
	MockRegistry *MockRegistry          `yaml:"mockRegistry" bson:"mock_registry" json:"mockRegistry,omitempty"`
}

type TestSetStatus ¶

type TestSetStatus string

const (
	TestSetStatusRunning      TestSetStatus = "RUNNING"
	TestSetStatusFailed       TestSetStatus = "FAILED"
	TestSetStatusPassed       TestSetStatus = "PASSED"
	TestSetStatusAppHalted    TestSetStatus = "APP_HALTED"
	TestSetStatusUserAbort    TestSetStatus = "USER_ABORT"
	TestSetStatusFaultUserApp TestSetStatus = "APP_FAULT"
	TestSetStatusInternalErr  TestSetStatus = "INTERNAL_ERR"
	TestSetStatusFaultScript  TestSetStatus = "SCRIPT_FAULT"
	TestSetStatusIgnored      TestSetStatus = "IGNORED"
)

constants for testSet status

func StringToTestSetStatus ¶

func StringToTestSetStatus(s string) (TestSetStatus, error)

type TestStatus ¶

type TestStatus string

const (
	TestStatusPending TestStatus = "PENDING"
	TestStatusRunning TestStatus = "RUNNING"
	TestStatusFailed  TestStatus = "FAILED"
	TestStatusPassed  TestStatus = "PASSED"
	TestStatusIgnored TestStatus = "IGNORED"
)

constants for test status

type TestingOptions ¶

type TestingOptions struct {
	Mode Mode
}

type TestsetNoise ¶

type TestsetNoise map[string]map[string]map[string][]string

type URLParamsResult ¶

type URLParamsResult struct {
	Normal   bool   `json:"normal" bson:"normal" yaml:"normal"`
	Expected Params `json:"expected" bson:"expected" yaml:"expected"`
	Actual   Params `json:"actual" bson:"actual" yaml:"actual"`
}

type UT ¶

type UT struct {
	TestBehavior   string `yaml:"test_behavior"`
	TestName       string `yaml:"test_name"`
	TestCode       string `yaml:"test_code"`
	NewImportsCode string `yaml:"new_imports_code"`
	TestsTags      string `yaml:"tests_tags"`
}

type UTDetails ¶

type UTDetails struct {
	Language      string `yaml:"language"`
	TestSignature string `yaml:"existing_test_function_signature"`
	NewTests      []UT   `yaml:"new_tests"`
}

type UTIndentationInfo ¶

type UTIndentationInfo struct {
	Language         string `yaml:"language"`
	TestingFramework string `yaml:"testing_framework"`
	NumberOfTests    int    `yaml:"number_of_tests"`
	Indentation      int    `yaml:"test_headers_indentation"`
}

type UTInsertionInfo ¶

type UTInsertionInfo struct {
	Language         string `yaml:"language"`
	TestingFramework string `yaml:"testing_framework"`
	NumberOfTests    int    `yaml:"number_of_tests"`
	Line             int    `yaml:"relevant_line_number_to_insert_after"`
}

type UTResult ¶

type UTResult struct {
	Status   string `yaml:"status"`
	Reason   string `yaml:"reason"`
	ExitCode int    `yaml:"exit_code"`
	Stderr   string `yaml:"stderr"`
	Stdout   string `yaml:"stdout"`
	Test     string `yaml:"test"`
}

type Version ¶

type Version string

func GetVersion ¶

func GetVersion() (V1 Version)

Directories ¶

Path	Synopsis
mysql Package mysql in models provides realted structs for mysql protocol	Package mysql in models provides realted structs for mysql protocol

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

README ¶

Models Package Documentation

Documentation ¶

Overview ¶

Index ¶

Constants ¶

Variables ¶

Functions ¶

func SetMode ¶

func SetTestMode ¶

func SetVersion ¶

Types ¶

type AbsResult ¶

type AccessTokenResponse ¶

type AppError ¶

func (AppError) Error ¶

type AppErrorType ¶

type AuthReq ¶

type AuthResp ¶

type Backend ¶

type BodyResult ¶

type BodyType ¶

type Class ¶

type Cobertura ¶

type Counter ¶

type CoverageResult ¶

type DepMetaResult ¶

type DepResult ¶

type DeviceCodeResponse ¶

type DrivenMode ¶

func (DrivenMode) String ¶

type FailedUT ¶

type FormData ¶

type Frame ¶

type Frontend ¶

type GenericSchema ¶

type GlobalNoise ¶

type GrpcHeaders ¶

type GrpcLengthPrefixedMessage ¶

type GrpcReq ¶

type GrpcResp ¶

type GrpcSpec ¶

type GrpcStream ¶

func NewGrpcStream ¶

type HTTPDoc ¶

type HTTPReq ¶

type HTTPResp ¶

type HTTPSchema ¶

type Header ¶

type HeaderResult ¶

type HookOptions ¶

type IncomingOptions ¶

type Info ¶

type IntResult ¶

type Jacoco ¶

type JacocoClass ¶

type JacocoLine ¶

type JacocoMethod ¶

type JacocoPackage ¶

type JacocoSourceFile ¶

type KctxType ¶

type Kind ¶

type Line ¶

type MediaType ¶

type Method ¶

type Mock ¶

func (*Mock) GetKind ¶

type MockMapping ¶

type MockRegistry ¶

type MockSpec ¶

type Mode ¶

func GetMode ¶

func (Mode) Valid ¶

type ModeKey ¶

type MongoHeader ¶

type MongoOpMessage ¶

type MongoOpQuery ¶

type MongoOpReply ¶

type MongoRequest ¶

func (*MongoRequest) MarshalJSON ¶