91 lines
1.6 KiB
Go
91 lines
1.6 KiB
Go
package packer
|
|
|
|
import (
|
|
"cgl.tideland.biz/asserts"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// A helper Hook implementation for testing cancels.
|
|
type CancelHook struct {
|
|
sync.Mutex
|
|
cancelCh chan struct{}
|
|
doneCh chan struct{}
|
|
|
|
Cancelled bool
|
|
}
|
|
|
|
func (h *CancelHook) Run(string, Ui, Communicator, interface{}) error {
|
|
h.Lock()
|
|
h.cancelCh = make(chan struct{})
|
|
h.doneCh = make(chan struct{})
|
|
h.Unlock()
|
|
|
|
defer close(h.doneCh)
|
|
|
|
select {
|
|
case <-h.cancelCh:
|
|
h.Cancelled = true
|
|
case <-time.After(1 * time.Second):
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (h *CancelHook) Cancel() {
|
|
h.Lock()
|
|
close(h.cancelCh)
|
|
h.Unlock()
|
|
|
|
<-h.doneCh
|
|
}
|
|
|
|
func TestDispatchHook_Implements(t *testing.T) {
|
|
assert := asserts.NewTestingAsserts(t, true)
|
|
|
|
var r Hook
|
|
c := &DispatchHook{}
|
|
|
|
assert.Implementor(c, &r, "should be a Hook")
|
|
}
|
|
|
|
func TestDispatchHook_Run_NoHooks(t *testing.T) {
|
|
// Just make sure nothing blows up
|
|
dh := &DispatchHook{}
|
|
dh.Run("foo", nil, nil, nil)
|
|
}
|
|
|
|
func TestDispatchHook_Run(t *testing.T) {
|
|
assert := asserts.NewTestingAsserts(t, true)
|
|
|
|
hook := &MockHook{}
|
|
|
|
mapping := make(map[string][]Hook)
|
|
mapping["foo"] = []Hook{hook}
|
|
dh := &DispatchHook{Mapping: mapping}
|
|
dh.Run("foo", nil, nil, 42)
|
|
|
|
assert.True(hook.RunCalled, "run should be called")
|
|
assert.Equal(hook.RunName, "foo", "should be proper event")
|
|
assert.Equal(hook.RunData, 42, "should be correct data")
|
|
}
|
|
|
|
func TestDispatchHook_cancel(t *testing.T) {
|
|
hook := new(CancelHook)
|
|
|
|
dh := &DispatchHook{
|
|
Mapping: map[string][]Hook{
|
|
"foo": []Hook{hook},
|
|
},
|
|
}
|
|
|
|
go dh.Run("foo", nil, nil, 42)
|
|
time.Sleep(100 * time.Millisecond)
|
|
dh.Cancel()
|
|
|
|
if !hook.Cancelled {
|
|
t.Fatal("hook should've cancelled")
|
|
}
|
|
}
|