move internal package to types (#23)

Author: bivas

engine/actions/trigger/template_test.go

@@ -43,3 +43,20 @@ func TestTemplate(t *testing.T) {
 		}`)
 	assert.Equal(t, expected, buf.String(), "json")
 }
+
+func TestTemplateWithOrigin(t *testing.T) {
+	temp, e := template.New("test").Parse(`{{.Origin.Ref}}`)
+	assert.NoError(t, e, "should not error")
+	msg := message{
+		Time:   time.Now(),
+		Number: 1,
+		Title:  "title1",
+		State:  "open",
+		Owner:  "my",
+		Repo:   "repo",
+		Origin: types.Origin{User: "self", Ref: "test"}}
+	var buf bytes.Buffer
+	temp.Execute(&buf, msg)
+	expected := "test"
+	assert.Equal(t, expected, buf.String(), "json")
+}

runner/hook_listener.go

@@ -4,15 +4,15 @@ import (
 	"net/http"
 
 	"github.com/bivas/rivi/config/client"
-	"github.com/bivas/rivi/runner/internal"
+	"github.com/bivas/rivi/runner/types"
 	"github.com/bivas/rivi/types/builder"
 	"github.com/bivas/rivi/util/log"
 	"github.com/spf13/viper"
 )
 
 type hookListener struct {
 	conf  client.ClientConfig
-	queue internal.HookListenerQueue
+	queue types.HookListenerQueue
 
 	logger log.Logger
 }
@@ -22,21 +22,25 @@ func (h *hookListener) HandleEvent(r *http.Request) *HandledEventResult {
 	if !ok {
 		return &HandledEventResult{Message: "Skipping hook processing"}
 	}
-	h.queue.Enqueue(internal.NewMessage(h.conf, data))
+	h.queue.Enqueue(types.NewMessage(h.conf, data))
 	return &HandledEventResult{Message: "Processing " + data.GetShortName()}
 }
 
 func NewHookListener(clientConfiguration string) (Runner, error) {
-	logger := runnerLog.Get("hook.listener")
 	var conf client.ClientConfig
 	if clientConfiguration == "" {
 		conf = client.NewClientConfig(viper.New())
 	} else {
 		conf = client.NewClientConfigFromFile(clientConfiguration)
 	}
+	return NewHookListenerWithClientConfig(conf), nil
+}
+
+func NewHookListenerWithClientConfig(config client.ClientConfig) Runner {
+	logger := runnerLog.Get("hook.listener")
 	return &hookListener{
-		conf:   conf,
+		conf:   config,
 		queue:  CreateHookListenerQueue(),
 		logger: logger,
-	}, nil
+	}
 }

runner/hook_listener_queue.go

@@ -1,16 +1,16 @@
 package runner
 
 import (
-	"github.com/bivas/rivi/runner/internal"
 	"github.com/bivas/rivi/runner/local"
+	"github.com/bivas/rivi/runner/types"
 )
 
-var defaultHookListenerQueueProvider internal.HookListenerQueueProvider = local.CreateHookListenerQueue
+var defaultHookListenerQueueProvider types.HookListenerQueueProvider = local.CreateHookListenerQueue
 
-func SetHookListenerQueueProvider(fn internal.HookListenerQueueProvider) {
+func SetHookListenerQueueProvider(fn types.HookListenerQueueProvider) {
 	defaultHookListenerQueueProvider = fn
 }
 
-func CreateHookListenerQueue() internal.HookListenerQueue {
+func CreateHookListenerQueue() types.HookListenerQueue {
 	return defaultHookListenerQueueProvider()
 }

runner/hook_listener_queue_test.go

@@ -0,0 +1,30 @@
+package runner
+
+import (
+	"testing"
+
+	"github.com/bivas/rivi/runner/types"
+	"github.com/stretchr/testify/assert"
+)
+
+type testHookListenerQueue struct {
+	Created bool
+}
+
+func (*testHookListenerQueue) Enqueue(*types.Message) {
+	panic("implement me")
+}
+
+func TestSetHookListenerQueueProvider(t *testing.T) {
+	queue := &testHookListenerQueue{false}
+	SetHookListenerQueueProvider(func() types.HookListenerQueue {
+		queue.Created = true
+		return queue
+	})
+	assert.False(t, queue.Created, "created should be false")
+	result := CreateHookListenerQueue()
+	assert.NotNil(t, result, "test result")
+	_, ok := result.(*testHookListenerQueue)
+	assert.True(t, ok, "same type")
+	assert.True(t, queue.Created, "created")
+}

runner/hook_listener_test.go

@@ -0,0 +1,15 @@
+package runner
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewHookListener(t *testing.T) {
+	result, err := NewHookListener("")
+	assert.NoError(t, err, "new failed")
+	assert.NotNil(t, result, "nil runner")
+	_, ok := result.(*hookListener)
+	assert.True(t, ok, "must be of type hook lisetner")
+}

runner/local/hook_handler.go

@@ -3,14 +3,14 @@ package local
 import (
 	"time"
 
-	"github.com/bivas/rivi/runner/internal"
+	"github.com/bivas/rivi/runner/types"
 	"github.com/bivas/rivi/util/log"
 
 	"github.com/patrickmn/go-cache"
 )
 
 type channelHookHandler struct {
-	incoming <-chan *internal.Message
+	incoming <-chan *types.Message
 	logger   log.Logger
 
 	processingCache *cache.Cache
@@ -38,14 +38,14 @@ func (h *channelHookHandler) Run() {
 			log.MetaFields{
 				log.F("issue", key),
 			}, "Sending data to job handler")
-		c.(internal.JobHandler).Send(msg)
+		c.(types.JobHandler).Send(msg)
 	}
 }
 
-func NewChannelHookHandler(incoming <-chan *internal.Message) internal.HookHandler {
+func NewChannelHookHandler(incoming <-chan *types.Message) types.HookHandler {
 	processingCache := cache.New(time.Minute, 2*time.Minute)
 	processingCache.OnEvicted(func(key string, value interface{}) {
-		value.(internal.JobHandler).Send(nil)
+		value.(types.JobHandler).Send(nil)
 	})
 	return &channelHookHandler{
 		incoming:        incoming,

runner/local/hook_listener_queue.go

@@ -1,32 +1,32 @@
 package local
 
 import (
-	"github.com/bivas/rivi/runner/internal"
+	"github.com/bivas/rivi/runner/types"
 	"github.com/bivas/rivi/util/log"
 )
 
 type channelHookListenerQueue struct {
-	incoming chan *internal.Message
+	incoming chan *types.Message
 }
 
-func (c *channelHookListenerQueue) Enqueue(data *internal.Message) {
+func (c *channelHookListenerQueue) Enqueue(data *types.Message) {
 	if data == nil {
 		close(c.incoming)
 		return
 	}
 	c.incoming <- data
 }
 
-func channelHookListenerQueueProvider() internal.HookListenerQueue {
+func channelHookListenerQueueProvider() types.HookListenerQueue {
 	log.Get("hook.listener.queue").DebugWith(
 		log.MetaFields{
 			log.F("type", "channel")}, "Creating hook listener queue provider")
-	incomingHooks := make(chan *internal.Message)
+	incomingHooks := make(chan *types.Message)
 	handler := NewChannelHookHandler(incomingHooks)
 	go handler.Run()
 	return &channelHookListenerQueue{incomingHooks}
 }
 
-func CreateHookListenerQueue() internal.HookListenerQueue {
+func CreateHookListenerQueue() types.HookListenerQueue {
 	return channelHookListenerQueueProvider()
 }

runner/local/job_handler.go

@@ -1,18 +1,18 @@
 package local
 
 import (
-	"github.com/bivas/rivi/runner/internal"
+	"github.com/bivas/rivi/runner/types"
 	"github.com/bivas/rivi/util/log"
 )
 
 type jobHandler struct {
-	channel chan *internal.Message
+	channel chan *types.Message
 	work    *workUnit
 
 	logger log.Logger
 }
 
-func (h *jobHandler) Send(data *internal.Message) {
+func (h *jobHandler) Send(data *types.Message) {
 	if data == nil {
 		h.logger.Debug("Closing channel")
 		close(h.channel)
@@ -25,8 +25,8 @@ func (h *jobHandler) Start() {
 	go h.work.Handle()
 }
 
-func NewJobHandler() internal.JobHandler {
-	c := make(chan *internal.Message)
+func NewJobHandler() types.JobHandler {
+	c := make(chan *types.Message)
 	h := &jobHandler{
 		channel: c,
 		work: &workUnit{

runner/local/work_unit.go

@@ -6,18 +6,18 @@ import (
 	"github.com/bivas/rivi/config"
 	"github.com/bivas/rivi/engine"
 	"github.com/bivas/rivi/runner/env"
-	"github.com/bivas/rivi/runner/internal"
+	"github.com/bivas/rivi/runner/types"
 	"github.com/bivas/rivi/types/builder"
 	"github.com/bivas/rivi/util/log"
 	"github.com/bivas/rivi/util/state"
 )
 
 type workUnit struct {
-	incoming <-chan *internal.Message
+	incoming <-chan *types.Message
 	logger   log.Logger
 }
 
-func (w *workUnit) internalHandle(msg *internal.Message) error {
+func (w *workUnit) internalHandle(msg *types.Message) error {
 	environment, err := env.GetEnvironment()
 	if err != nil {
 		w.logger.ErrorWith(

runner/internal/hook_handler.go renamed to runner/types/hook_handler.go

@@ -1,4 +1,4 @@
-package internal
+package types
 
 type HookHandler interface {
 	Run()