forge

type App interface {
	// The Logger to be used
	Logger() Logger
}

type AssertFailure struct {
	Expected interface{}
	Actual   interface{}
}

type Environment map[string]string

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

type HTTPClientInterceptor interface {
	ModRequest(request *http.Request) error
	ErrorCheck(response *http.Response) error
}

type HTTPLogger struct {
	Logger  Logger
	Handler http.Handler
}

type HTTPRouter struct {
	Routes          map[string]http.Handler
	NotFoundHandler http.Handler
}

type HTTPStatic struct {
	FileSystem      http.FileSystem
	NotFoundHandler http.Handler
	CacheControl    string
}

type Log struct {
	Severity string                 `json:"severity"`
	Message  string                 `json:"message"`
	Context  map[string]interface{} `json:"context"`
}

type Logger interface {
	Emergency(message string, context map[string]interface{})
	Alert(message string, context map[string]interface{})
	Critical(message string, context map[string]interface{})
	Error(message string, context map[string]interface{})
	Warning(message string, context map[string]interface{})
	Notice(message string, context map[string]interface{})
	Info(message string, context map[string]interface{})
	Debug(message string, context map[string]interface{})
	StandardLogger() *log.Logger
}

type LoggerJSON struct {
	Encoder *json.Encoder
}

type MockRoundTripFunc func(t *testing.T, request *http.Request) (*http.Response, error)

type MockableRoundTripper struct {
	RoundTripFunc func(*http.Request) (*http.Response, error)
}

type Resources struct {
	FileSystems []fs.FS
}

type Runtime struct {
	Environment Environment
	Stdout      io.Writer
	Stderr      io.Writer
	Stdin       io.Reader
	FS          fs.FS
}

type WebApp interface {
	App
	// How it responds to web requests
	Handler() http.Handler
	// What address the webserver should listen on
	ListenAddress() string
	// Tasks to run in the background (a Go routine)
	Background(ctx context.Context)
}