test

README

Preparation

1. Install godotenv tool

$ go get -v -t github.com/joho/godotenv/cmd/godotenv 

2. Configurate Your .env File from .env.sample

$ cp .env.sample .env

⚠️ Don't modify the .env.sample as your go test source

$ vim .env

---

Run Test

$ godotenv -f .env go test -v

Documentation

Index

• Variables
• type App
  • func (app *App) ConfigureLogger(l *log.Logger)
  • func (app *App) ConfigureTextMapPropagator()
  • func (app *App) ConfigureTracerProvider()
  • func (app *App) Init()
  • func (app *App) Logger() *log.Logger
  • func (app *App) OnInit()
  • func (app *App) OnInitComplete()
  • func (app *App) OnStart(ctx context.Context)
  • func (app *App) OnStop(ctx context.Context)
  • func (app *App) TextMapPropagator() propagation.TextMapPropagator
  • func (app *App) TracerProvider() *trace.SeverityTracerProvider
• type BlackholeEventLog
  • func (l *BlackholeEventLog) Flush()
  • func (l *BlackholeEventLog) OnError(message *redis.Message, err interface{}, stackTrace []byte)
  • func (l *BlackholeEventLog) OnProcessMessage(message *redis.Message)
  • func (l *BlackholeEventLog) OnProcessMessageComplete(message *redis.Message, reply redis.ReplyCode)
• type BlackholeLoggerService
  • func (*BlackholeLoggerService) ConfigureLogger(l *log.Logger)
  • func (s *BlackholeLoggerService) CreateEventLog(ev redis.EventEvidence) redis.EventLog
• type Config
• type EventLog
  • func (l EventLog) Flush()
  • func (l EventLog) OnError(message *redis.Message, err interface{}, stackTrace []byte)
  • func (l EventLog) OnProcessMessage(message *redis.Message)
  • func (l EventLog) OnProcessMessageComplete(message *redis.Message, reply redis.ReplyCode)
• type GoTestStreamMessageCounter
• type GoTestStreamMessageHandler
  • func (h *GoTestStreamMessageHandler) Init()
  • func (*GoTestStreamMessageHandler) MessageObserverTypes() []reflect.Type
  • func (h *GoTestStreamMessageHandler) ProcessMessage(ctx *redis.Context, message *redis.Message)
• type GoTestStreamMessageObserver
  • func (*GoTestStreamMessageObserver) Init()
  • func (o *GoTestStreamMessageObserver) OnAck(ctx *redis.Context, message *redis.Message)
  • func (o *GoTestStreamMessageObserver) OnDel(ctx *redis.Context, message *redis.Message)
  • func (o *GoTestStreamMessageObserver) Type() reflect.Type
• type Host
  • func (h *Host) Init(conf *Config)
  • func (h *Host) OnError(err error) (disposed bool)
• type InvalidMessageHandler
  • func (h *InvalidMessageHandler) Init()
  • func (h *InvalidMessageHandler) ProcessMessage(ctx *redis.Context, message *redis.Message)
• type LoggingService
  • func (s *LoggingService) ConfigureLogger(l *log.Logger)
  • func (s *LoggingService) CreateEventLog(ev redis.EventEvidence) redis.EventLog
• type MockComponent
  • func (c *MockComponent) Runner() host.Runner
• type MockComponentRunner
  • func (c *MockComponentRunner) Start()
  • func (c *MockComponentRunner) Stop()
• type ServiceProvider
  • func (p *ServiceProvider) Init(conf *Config)
  • func (p *ServiceProvider) Logger() *log.Logger
  • func (p *ServiceProvider) TextMapPropagator() propagation.TextMapPropagator
  • func (p *ServiceProvider) TracerProvider() *trace.SeverityTracerProvider

Variables

var MessageObserverManager = struct {
	*GoTestStreamMessageObserver
}{}

Types

type App

type App struct {
	Host            *Host
	Config          *Config
	ServiceProvider *ServiceProvider

	Component       *MockComponent
	ComponentRunner *MockComponentRunner
}

func (*App) ConfigureLogger

func (app *App) ConfigureLogger(l *log.Logger)

func (*App) ConfigureTextMapPropagator

func (app *App) ConfigureTextMapPropagator()

func (*App) ConfigureTracerProvider

func (app *App) ConfigureTracerProvider()

func (*App) Init

func (app *App) Init()

func (*App) Logger

func (app *App) Logger() *log.Logger

func (*App) OnInit

func (app *App) OnInit()

func (*App) OnInitComplete

func (app *App) OnInitComplete()

func (*App) OnStart

func (app *App) OnStart(ctx context.Context)

func (*App) OnStop

func (app *App) OnStop(ctx context.Context)

func (*App) TextMapPropagator

func (app *App) TextMapPropagator() propagation.TextMapPropagator

func (*App) TracerProvider

func (app *App) TracerProvider() *trace.SeverityTracerProvider

type BlackholeEventLog

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

func (*BlackholeEventLog) Flush

func (l *BlackholeEventLog) Flush()

func (*BlackholeEventLog) OnError

func (l *BlackholeEventLog) OnError(message *redis.Message, err interface{}, stackTrace []byte)

func (*BlackholeEventLog) OnProcessMessage

func (l *BlackholeEventLog) OnProcessMessage(message *redis.Message)

func (*BlackholeEventLog) OnProcessMessageComplete

func (l *BlackholeEventLog) OnProcessMessageComplete(message *redis.Message, reply redis.ReplyCode)

type BlackholeLoggerService

type BlackholeLoggerService struct {
	Buffer *bytes.Buffer
}

func (*BlackholeLoggerService) ConfigureLogger

func (*BlackholeLoggerService) ConfigureLogger(l *log.Logger)

func (*BlackholeLoggerService) CreateEventLog

func (s *BlackholeLoggerService) CreateEventLog(ev redis.EventEvidence) redis.EventLog

type Config

type Config struct {
	// redis
	RedisAddresses           []string      `env:"*REDIS_SERVER"        yaml:"-"`
	RedisConsumerGroup       string        `env:"-"                    yaml:"RedisConsumerGroup"`
	RedisConsumerName        string        `env:"-"                    yaml:"RedisConsumerName"`
	RedisMaxInFlight         int64         `env:"-"                    yaml:"RedisMaxInFlight"`
	RedisMaxPollingTimeout   time.Duration `env:"-"                    yaml:"RedisMaxPollingTimeout"`
	RedisClaimMinIdleTime    time.Duration `env:"-"                    yaml:"RedisClaimMinIdleTime"`
	RedisIdlingTimeout       time.Duration `env:"-"                    yaml:"RedisIdlingTimeout"`
	RedisClaimSensitivity    int           `env:"-"                    yaml:"RedisClaimSensitivity"`
	RedisClaimOccurrenceRate int32         `env:"-"                    yaml:"RedisClaimOccurrenceRate"`

	// jaeger
	JaegerTraceUrl string `yaml:"jaegerTraceUrl"`
	JaegerQueryUrl string `yaml:"jaegerQueryUrl"`
}

type EventLog

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

func (EventLog) Flush

func (l EventLog) Flush()

Flush implements middleware.EventLog.

func (EventLog) OnError

func (l EventLog) OnError(message *redis.Message, err interface{}, stackTrace []byte)

LogError implements middleware.EventLog.

func (EventLog) OnProcessMessage

func (l EventLog) OnProcessMessage(message *redis.Message)

BeforeProcessMessage implements middleware.EventLog.

func (EventLog) OnProcessMessageComplete

func (l EventLog) OnProcessMessageComplete(message *redis.Message, reply redis.ReplyCode)

AfterProcessMessage implements middleware.EventLog.

type GoTestStreamMessageCounter

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

type GoTestStreamMessageHandler

type GoTestStreamMessageHandler struct {
	ServiceProvider *ServiceProvider
	// contains filtered or unexported fields
}

func (*GoTestStreamMessageHandler) Init

func (h *GoTestStreamMessageHandler) Init()

func (*GoTestStreamMessageHandler) MessageObserverTypes

func (*GoTestStreamMessageHandler) MessageObserverTypes() []reflect.Type

MessageObserverTypes implements internal.MessageObserverAffair.

func (*GoTestStreamMessageHandler) ProcessMessage

func (h *GoTestStreamMessageHandler) ProcessMessage(ctx *redis.Context, message *redis.Message)

ProcessMessage implements internal.MessageHandler.

type GoTestStreamMessageObserver

type GoTestStreamMessageObserver struct {
	ServiceProvider *ServiceProvider
}

func (*GoTestStreamMessageObserver) Init

func (*GoTestStreamMessageObserver) Init()

func (*GoTestStreamMessageObserver) OnAck

func (o *GoTestStreamMessageObserver) OnAck(ctx *redis.Context, message *redis.Message)

OnAck implements internal.MessageObserver.

func (*GoTestStreamMessageObserver) OnDel

func (o *GoTestStreamMessageObserver) OnDel(ctx *redis.Context, message *redis.Message)

OnDel implements internal.MessageObserver.

func (*GoTestStreamMessageObserver) Type

func (o *GoTestStreamMessageObserver) Type() reflect.Type

type Host

type Host redis.Worker

func (*Host) Init

func (h *Host) Init(conf *Config)

func (*Host) OnError

func (h *Host) OnError(err error) (disposed bool)

type InvalidMessageHandler

type InvalidMessageHandler struct {
	ServiceProvider *ServiceProvider
}

func (*InvalidMessageHandler) Init

func (h *InvalidMessageHandler) Init()

func (*InvalidMessageHandler) ProcessMessage

func (h *InvalidMessageHandler) ProcessMessage(ctx *redis.Context, message *redis.Message)

type LoggingService

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

func (*LoggingService) ConfigureLogger

func (s *LoggingService) ConfigureLogger(l *log.Logger)

ConfigureLogger implements middleware.LoggingService.

func (*LoggingService) CreateEventLog

func (s *LoggingService) CreateEventLog(ev redis.EventEvidence) redis.EventLog

CreateEventLog implements middleware.LoggingService.

type MockComponent

type MockComponent struct {
}

func (*MockComponent) Runner

func (c *MockComponent) Runner() host.Runner

type MockComponentRunner

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

func (*MockComponentRunner) Start

func (c *MockComponentRunner) Start()

func (*MockComponentRunner) Stop

func (c *MockComponentRunner) Stop()

type ServiceProvider

type ServiceProvider struct {
	ResourceName string
}

func (*ServiceProvider) Init

func (p *ServiceProvider) Init(conf *Config)

func (*ServiceProvider) Logger

func (p *ServiceProvider) Logger() *log.Logger

func (*ServiceProvider) TextMapPropagator

func (p *ServiceProvider) TextMapPropagator() propagation.TextMapPropagator

func (*ServiceProvider) TracerProvider

func (p *ServiceProvider) TracerProvider() *trace.SeverityTracerProvider