testext

type CustomDuration time.Duration

type EventError struct {
	Message        string
	Error          string
	Code           int
	Status         int
	StatusCode     int
	HTTPStatusCode int
}

type FailAlwaysErrorRequest struct {
	Error         EventError
	RequestValue  string
	ResponseValue string
	Text          string
}

type FailAlwaysErrorResponse struct {
}

type FailAlwaysRequest struct {
	RequestValue string
}

type FailAlwaysResponse struct {
	ResponseValue string
}

type FreeAddress struct {
	// Host is the hostname portion of the address to generate.
	Host string
	// Port is the port number to increment each time.
	Port uint16
	// contains filtered or unexported fields
}

type MarshalToObject struct {
	// Home is supposed to be a home email address.
	Home string
	// Work is supposed to be a home email address.
	Work string
}

type MarshalToString struct {
	// Home is supposed to be a home email address.
	Home string
	// Work is supposed to be a home email address.
	Work string
}

type OtherRequest struct {
	// UniqueThing is just a field that doesn't exist in any other testing response. This ensures
	// that we can use events to decode the values like 'Text' which are present while ignoring those
	// that are not... quietly.
	UniqueThing bool
	// Text is the result of the previous call's invocation.
	Text string
}

type OtherResponse OtherRequest

type OtherService interface {
	// SpaceOut takes your input text and puts spaces in between all the letters.
	SpaceOut(context.Context, *OtherRequest) (*OtherResponse, error)

	// RPCExample invokes the TriggerUpperCase() function on the SampleService to get work done.
	// This will make sure that we can do cross-service communication.
	RPCExample(context.Context, *OtherRequest) (*OtherResponse, error)

	// ListenWell can listen for successful responses across multiple services.
	//
	// ON OtherService.SpaceOut
	// ON SampleService.TriggerUpperCase
	ListenWell(context.Context, *OtherRequest) (*OtherResponse, error)

	// ChainOne allows us to test the cascading of events to create more complex flows. When this
	// finishes it will trigger ChainTwo which will, in turn, trigger ChainThree and ChainFour.
	ChainOne(ctx context.Context, request *OtherRequest) (*OtherResponse, error)

	// ChainTwo is used to test that methods invoked via the event gateway can trigger even more events.
	//
	// ON OtherService.ChainOne
	ChainTwo(ctx context.Context, request *OtherRequest) (*OtherResponse, error)

	// ChainThree is used to test that methods invoked via the event gateway can trigger even more events.
	//
	// ON OtherService.ChainTwo
	ChainThree(ctx context.Context, request *OtherRequest) (*OtherResponse, error)

	// ChainFour is used to test that methods invoked via the event gateway can trigger even more events.
	//
	// ON OtherService.ChainTwo
	ChainFour(ctx context.Context, request *OtherRequest) (*OtherResponse, error)

	// ChainFail fires after ChainOne, but should always return an error. This will prevent ChainFailAfter
	// from ever actually running.
	//
	// ON OtherService.ChainOne
	ChainFail(ctx context.Context, request *OtherRequest) (*OtherResponse, error)

	// ChainFailAfter is dependent on a successful call to ChainFail... which always fails. So this NEVER runs.
	//
	// ON OtherService.ChainFail
	ChainFailAfter(ctx context.Context, request *OtherRequest) (*OtherResponse, error)
}

type OtherServiceHandler struct {
	Sequence      *Sequence
	SampleService SampleService
}

type SampleComplexRequest struct {
	InUser    SampleUser
	InFlag    bool
	InFloat   float64
	InTime    time.Time
	InTimePtr *time.Time
}

type SampleComplexResponse struct {
	OutFlag    bool
	OutFloat   float64
	OutUser    *SampleUser
	OutTime    time.Time
	OutTimePtr *time.Time
}

type SampleDownloadRequest struct {
	Format string
}

type SampleDownloadResponse struct {
	services.StreamResponse
}

type SampleRedirectRequest struct{}

type SampleRedirectResponse struct {
	URI string
	services.StreamResponse
}

type SampleRequest struct {
	ID   string
	Text string
}

type SampleResponse SampleRequest

type SampleSecurityRequest struct {
	ID      string
	User    SampleUser
	FancyID StringLike
}

type SampleSecurityResponse struct {
	Roles []string
}

type SampleService interface {
	// Defaults simply utilizes all of the framework's default behaviors.
	Defaults(context.Context, *SampleRequest) (*SampleResponse, error)

	// ComplexValues flexes our ability to encode/decode non-flat structs.
	ComplexValues(context.Context, *SampleComplexRequest) (*SampleComplexResponse, error)

	// ComplexValuesPath flexes our ability to encode/decode non-flat structs while
	// specifying them via path and query string.
	//
	// GET /complex/values/{InUser.ID}/{InUser.Name}/woot
	ComplexValuesPath(context.Context, *SampleComplexRequest) (*SampleComplexResponse, error)

	// Fail4XX always returns a non-nil 400-series error.
	Fail4XX(context.Context, *SampleRequest) (*SampleResponse, error)

	// Fail5XX always returns a non-nil 500-series error.
	Fail5XX(context.Context, *SampleRequest) (*SampleResponse, error)

	// CustomRoute performs a service operation where you override default behavior
	// by providing routing-related Doc Options.
	//
	// HTTP 202
	// GET /custom/route/1/{ID}/{Text}
	CustomRoute(context.Context, *SampleRequest) (*SampleResponse, error)

	// CustomRouteQuery performs a service operation where you override default behavior
	// by providing routing-related Doc Options. The input data relies on the path
	//
	// HTTP 202
	// GET /custom/route/2/{ID}
	CustomRouteQuery(context.Context, *SampleRequest) (*SampleResponse, error)

	// CustomRouteBody performs a service operation where you override default behavior
	// by providing routing-related Doc Options, but rely on body encoding rather than path.
	//
	// HTTP 201
	// PUT /custom/route/3/{ID}
	CustomRouteBody(context.Context, *SampleRequest) (*SampleResponse, error)

	// OmitMe exists in the service, but should be excluded from the public API.
	//
	// HTTP OMIT
	OmitMe(ctx context.Context, request *SampleRequest) (*SampleResponse, error)

	// Download results in a raw stream of data rather than relying on auto-encoding
	// the response value.
	//
	// GET /download
	Download(context.Context, *SampleDownloadRequest) (*SampleDownloadResponse, error)

	// DownloadResumable results in a raw stream of data rather than relying on auto-encoding
	// the response value. The stream includes Content-Range info as though you could resume
	// your stream/download progress later.
	//
	// GET /download/resumable
	DownloadResumable(context.Context, *SampleDownloadRequest) (*SampleDownloadResponse, error)

	// Redirect results in a 307-style redirect to the Download endpoint.
	//
	// GET /redirect
	Redirect(context.Context, *SampleRedirectRequest) (*SampleRedirectResponse, error)

	// Authorization regurgitates the "Authorization" metadata/header.
	Authorization(context.Context, *SampleRequest) (*SampleResponse, error)

	// Sleep successfully responds, but it will sleep for 5 seconds before doing so. Use this
	// for test cases where you want to try out timeouts.
	Sleep(context.Context, *SampleRequest) (*SampleResponse, error)

	// TriggerUpperCase ensures that events still fire as "SampleService.TriggerUpperCase" even though
	// we are going to set a different HTTP path.
	//
	// GET /Upper/Case/WootyAndTheBlowfish
	TriggerUpperCase(context.Context, *SampleRequest) (*SampleResponse, error)
	TriggerLowerCase(context.Context, *SampleRequest) (*SampleResponse, error)
	TriggerFailure(context.Context, *SampleRequest) (*SampleResponse, error)

	// ListenerA fires on only one of the triggers.
	//
	// GET /ListenerA/Woot
	// ON SampleService.TriggerUpperCase
	ListenerA(context.Context, *SampleRequest) (*SampleResponse, error)

	// ListenerB fires on multiple triggers... including another event-based endpoint. We also
	// listen for the TriggerFailure event which should never fire properly.
	//
	// HTTP OMIT
	// ON SampleService.TriggerUpperCase
	// ON SampleService.TriggerLowerCase
	// ON SampleService.TriggerFailure
	// ON SampleService.ListenerA
	// ON OtherService.SpaceOut
	ListenerB(context.Context, *SampleRequest) (*SampleResponse, error)

	// FailAlways will return an error no matter what. It's only goal in life is to trigger OnFailAlways.
	FailAlways(ctx context.Context, request *FailAlwaysRequest) (*FailAlwaysResponse, error)

	// OnFailAlways should trigger after FailAlways inevitably shits the bed.
	//
	// ON SampleService.FailAlways:Error
	OnFailAlways(ctx context.Context, request *FailAlwaysErrorRequest) (*FailAlwaysErrorResponse, error)

	// Chain1 kicks off the Chain1/Chain2/Chain3 event chain, but we expect that it's going to stop after
	Chain1(ctx context.Context, request *SampleRequest) (*SampleResponse, error)

	// Chain2 ALWAYS FAILS, SO CHAIN3 NEVER FIRES!!!
	//
	// ON SampleService.Chain1
	Chain2(ctx context.Context, request *SampleRequest) (*SampleResponse, error)

	// Chain2OnSuccess never fires. It listens for the success of Chain2, but since that always fails, this
	// should never be triggered, so tests should never have this in its output.
	//
	// HTTP OMIT
	// ON SampleService.Chain2
	Chain2OnSuccess(ctx context.Context, request *SampleRequest) (*SampleResponse, error)

	// Chain2OnError listens for errors that occur on calls to Chain2
	//
	// HTTP OMIT
	// ON SampleService.Chain2:Error
	Chain2OnError(ctx context.Context, request *FailAlwaysErrorRequest) (*FailAlwaysErrorResponse, error)

	// Chain1GroupStar listens for calls to Chain1, but rather than being part of a consumer group that only lets
	// one instance of the service run it, it should define its own group that lets EVERY instance of this service
	// react to this event.
	//
	// ON SampleService.Chain1 GROUP *
	Chain1GroupStar(ctx context.Context, request *SampleRequest) (*SampleResponse, error)

	// Chain1GroupFooBar listens for calls to Chain1, but rather than being part of a consumer group that only lets
	// one instance of the service run it, it should define its own shared group name.
	//
	// ON SampleService.Chain1 GROUP FooBar
	Chain1GroupFooBar(ctx context.Context, request *SampleRequest) (*SampleResponse, error)

	// SecureWithRoles lets us test role based security by looking at the 'roles' doc option.
	//
	// ROLES admin.write,user.{ID}.write ,   user.{User.ID}.admin, junk.{NotReal}.crap
	SecureWithRoles(context.Context, *SampleSecurityRequest) (*SampleSecurityResponse, error)

	// SecureWithRolesAliased lets us test role based security by looking at the 'roles' doc option. Specifically,
	// we make sure we can resolve role segments with string alias types, not just strings.
	//
	// ROLES admin.write,user.{FancyID}.write ,   user.{User.FancyID}.admin, junk.{NotReal}.crap
	SecureWithRolesAliased(context.Context, *SampleSecurityRequest) (*SampleSecurityResponse, error)

	// Panic um... panics. It never succeeds. It always behaves like me when I'm on a high place looking down.
	Panic(context.Context, *SampleRequest) (*SampleResponse, error)
}

type SampleServiceHandler struct {
	Sequence *Sequence
}

type SampleUser struct {
	// ID is a string value that will likely have no whitespace.
	ID string
	// FancyID makes sure that we can use aliases properly rather than just the raw primitive types.
	FancyID StringLike
	// Name is a string value that will likely have spaces.
	Name string
	// Age is a numeric value that we should support.
	Age int
	// Attention is a duration to ensure that we use epoch nanos as the format, NOT the string.
	Attention time.Duration
	// AttentionString is a custom duration alias that overrides MarshalJSON/UnmarshalJSON to use strings for transport.
	AttentionString CustomDuration
	// PhoneNumber exercises the notion that clients should refer to this field as Digits, not PhoneNumber.
	PhoneNumber string `json:"Digits"`
	// MarshalToString makes sure that we can use strings as an alternate JSON format for structs.
	MarshalToString MarshalToString
	// MarshalToString makes sure that we can use custom marshaling of struct values.
	// This is NOT globally supported in all client languages - just Go for now.
	MarshalToObject MarshalToObject
}

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

type StringLike string