make listener configurable - and use for delaying client access in tests

config/config.go

@@ -42,11 +42,15 @@ func (cfg *defcfg) Add(c ...lib.Config) {
 	cfg.children = append(cfg.children, c...)
 }
 
-func (cfg *defcfg) Starter() lib.StartProc {
+func (cfg *defcfg) Starter() lib.Proc {
 	return DefaultStart
 }
 
-func (cfg *defcfg) Step() lib.StepProc {
+func (cfg *defcfg) Listener() lib.Proc {
+	return DefaultListen
+}
+
+func (cfg *defcfg) Step() lib.Step {
 	return DefaultStep
 }
 
@@ -54,7 +58,7 @@ func (cfg *defcfg) MessageHandler() lib.MessageHandler {
 	return DefaultMsgHandler
 }
 
-func (cfg *defcfg) DoneHandler() lib.StepProc {
+func (cfg *defcfg) DoneHandler() lib.Step {
 	return DefaultDoneHandler
 }
 
@@ -70,17 +74,22 @@ type BaseCfg = base
 
 type base struct {
 	*defcfg
-	starter     lib.StartProc
-	step        lib.StepProc
+	starter     lib.Proc
+	listener    lib.Proc
+	step        lib.Step
 	msgHandler  lib.MessageHandler
-	doneHandler lib.StepProc
+	doneHandler lib.Step
 }
 
-func (cfg *base) Starter() lib.StartProc {
+func (cfg *base) Starter() lib.Proc {
 	return cfg.starter
 }
 
-func (cfg *base) Step() lib.StepProc {
+func (cfg *base) Listener() lib.Proc {
+	return cfg.listener
+}
+
+func (cfg *base) Step() lib.Step {
 	return cfg.step
 }
 
@@ -88,13 +97,18 @@ func (cfg *base) MessageHandler() lib.MessageHandler {
 	return cfg.msgHandler
 }
 
-func (cfg *base) DoneHandler() lib.StepProc {
+func (cfg *base) DoneHandler() lib.Step {
 	return cfg.doneHandler
 }
 
 // implementation-specific methods and functions
 
-func (cfg *base) WithStep(step lib.StepProc) *base {
+func (cfg *base) WithListener(listener lib.Proc) *base {
+	cfg.listener = listener
+	return cfg
+}
+
+func (cfg *base) WithStep(step lib.Step) *base {
 	cfg.step = step
 	return cfg
 }
@@ -104,17 +118,18 @@ func (cfg *base) WithMessageHandler(hdlr lib.MessageHandler) *base {
 	return cfg
 }
 
-func (cfg *base) WithDoneHandler(hdlr lib.StepProc) *base {
+func (cfg *base) WithDoneHandler(hdlr lib.Step) *base {
 	cfg.doneHandler = hdlr
 	return cfg
 }
 
-func Base(name string, starter lib.StartProc) *base {
+func Base(name string, starter lib.Proc) *base {
 	return &base{
 		defcfg: &defcfg{
 			name: name,
 		},
 		starter:     starter,
+		listener:    DefaultListen,
 		step:        DefaultStep,
 		msgHandler:  DefaultMsgHandler,
 		doneHandler: DefaultDoneHandler,
@@ -122,10 +137,11 @@ func Base(name string, starter lib.StartProc) *base {
 }
 
 // will be set by core.init()
-var DefaultStart lib.StartProc
-var DefaultStep lib.StepProc
+var DefaultStart lib.Proc
+var DefaultListen lib.Proc
+var DefaultStep lib.Step
 var DefaultMsgHandler lib.MessageHandler
-var DefaultDoneHandler lib.StepProc
+var DefaultDoneHandler lib.Step
 
 // action configuration
 

core/core.go

@@ -12,7 +12,7 @@ import (
 
 func Delayed(proc lib.Proc, delay time.Duration) lib.Proc {
 	return func(ctx lib.Context) {
-		logging.Debug(ctx).Int("delay", int(delay)).Msg("lib.Delayed")
+		logging.Debug(ctx).Int("delay", int(delay)).Msg("core.Delayed")
 		time.Sleep(delay * time.Millisecond)
 		proc(ctx)
 	}
@@ -22,7 +22,7 @@ func None(_ lib.Context) {}
 
 func Start(ctx lib.Context) {
 	logging.Debug(ctx).Msg("core.Start")
-	lib.RunCtx(ctx, Listen)
+	lib.RunCtx(ctx, ctx.Config().Listener())
 }
 
 func Listen(ctx lib.Context) {
@@ -72,6 +72,7 @@ func Recover(ctx lib.Context, txt string) interface{} {
 
 func init() {
 	config.DefaultStart = Start // avoid import cycle
+	config.DefaultListen = Listen
 	config.DefaultStep = Step
 	config.DefaultMsgHandler = HandleMessage
 	config.DefaultDoneHandler = HandleDone

scopes.go

@@ -90,8 +90,7 @@ type ActionSpec interface {
 // procedures and handlers
 
 type Proc = func(Context)
-type StartProc = Proc
-type StepProc = func(Context) bool
+type Step = func(Context) bool
 type MessageHandler = func(Context, Message) bool
 type ActionHandler = func(Action) bool
 
@@ -100,10 +99,11 @@ type ActionHandler = func(Action) bool
 type Config interface {
 	Name() string
 	SetName(string)
-	Starter() StartProc
-	Step() StepProc
+	Starter() Proc
+	Listener() Proc
+	Step() Step
 	MessageHandler() MessageHandler
-	DoneHandler() StepProc
+	DoneHandler() Step
 	Actions() []ActionConfig
 	AddAction(string, ...ActionSpec)
 	Children() []Config

server/server.go

@@ -45,7 +45,7 @@ func Serve(ctx lib.Context) {
 	}
 	srv := &http.Server{Addr: cfg.Addr, Handler: r}
 	ctx.WithState(&ServerState{server: srv})
-	logging.Debug(ctx).Str("addr", cfg.Addr).Msg("server.Serve")
+	logging.Info(ctx).Str("addr", cfg.Addr).Msg("server.Serve")
 	lib.RunCtx(ctx, func(ctx lib.Context) {
 		srv.ListenAndServe()
 	})

tests/etc/etc.go

@@ -35,8 +35,9 @@ func Config() lib.Config {
 	server_c.AddRoute("/api", server.MsgHandler("demo", nil, "test-receiver"))
 
 	test_client := &client.Cfg{
-		BaseCfg: b("test-client", core.Delayed(core.Start, 50)),
-		Url:     ovr("http://localhost:8123/api", SERVER_URL),
+		BaseCfg: b("test-client", core.Start).
+			WithListener(core.Delayed(core.Listen, 50)),
+		Url: ovr("http://localhost:8123/api", SERVER_URL),
 	}
 	test_client.AddAction("demo", action.Base(client.Send))