Beispiel #1
0
func TestNewActions(t *testing.T) {
	a := NewActions(nil)

	assert.IsType(t, a, &ActionRepository{})
	assert.Equal(t, a.EnabledActions, Actions())
	assert.Equal(t, a, repository)

	ClearActions()

	assert.Nil(t, repository.EnabledActions)
	assert.Nil(t, Actions())
}
Beispiel #2
0
func TestBroadCast(t *testing.T) {
	l := listener.NewMockListener()

	e := NewEmitter(l)

	e.actions = make(map[string]actions.Action)

	msg := "message"
	actionNum := 10

	var count uint64

	var wg sync.WaitGroup

	// Prepare mock actions
	for i := 1; i <= actionNum; i++ {
		actionName := fmt.Sprintf("receiver_%d", i)
		a := actions.NewMockAction().(*actions.MockAction)
		a.SetName(actionName)

		e.actions[fmt.Sprintf("mock_%d", i)] = a
	}

	for i := 1; i <= actionNum; i++ {
		wg.Add(1)
		go func(j int) {
			defer wg.Done()
			select {
			case ev, ok := <-e.actions[fmt.Sprintf("mock_%d", j)].Ch():
				if ok {
					assert.Equal(t, ev, msg, "received broadcasted message")
					atomic.AddUint64(&count, 1)
				}
			}
		}(i)
	}

	e.BroadCast()
	e.l.(*listener.MockListener).Ch <- msg
	close(e.l.Stopped())

	wg.Wait()

	expected := strconv.Itoa(actionNum)
	actual := strconv.FormatUint(atomic.LoadUint64(&count), 10)

	assert.Equal(t, expected, actual, "All Actions received message")
}
Beispiel #3
0
func TestApplyConfig(t *testing.T) {
	NewActions(nil)
	actionName := "mock"

	configKey := "mock-config-value"
	configValue := "value"

	addr := &ActionAddress{
		NewFunc: NewMockAction,
		ConfigUnits: []*ConfigUnit{
			&ConfigUnit{
				Name: configKey,
			},
		},
	}

	addr.SetConfig(configKey, configValue)

	RegisterAction(addr)

	cfg := make(map[string]string)
	cfg[configKey] = configValue

	ApplyConfig(cfg)

	registered := repository.EnabledActions[actionName]

	configured := registered.(*MockAction).ConfigValue

	assert.Equal(t, configured, configValue)

	ClearActions()
}
Beispiel #4
0
func TestSystemWithDockerEvents(t *testing.T) {
	l := listener.NewMockListener()
	l.StartProduceDockerEvents()
	e := emitter.NewEmitter(l)
	as := actions.NewActions(nil).EnabledActions

	// Setup actions
	addr := &actions.ActionAddress{
		NewFunc: actions.NewMockAction,
	}
	actions.RegisterAction(addr)
	actions.ActivateActions()

	// Load actions to Emitter
	e.LoadActions(as)

	// BroadCast message
	e.BroadCast()

	<-e.Stopped()
	<-actions.Actions()["mock"].(*actions.MockAction).Stopped

	assert.Len(t, actions.Actions()["mock"].(*actions.MockAction).Memory, 10, "produced message size")

	event := actions.Actions()["mock"].(*actions.MockAction).Memory[0].(*docker.APIEvents)

	assert.Equal(t, event.From, "base:latest")

	actions.ClearActions()
}
Beispiel #5
0
func TestParseActionsConfig(t *testing.T) {
	config := NewConfig()

	args := []string{"-mock-config-value=testvalue"}

	config.Parse(args)

	assert.Equal(t, config.actionsConfig["mock-config-value"], "testvalue")
}
Beispiel #6
0
func TestParseEnabledActions(t *testing.T) {
	config := NewConfig()

	args := []string{"--actions=a,b,c"}

	config.Parse(args)

	assert.Equal(t, config.enabledActions[0], "a")
}
Beispiel #7
0
func TestEnabledActionsFromFlags(t *testing.T) {
	args := []string{"-actions=mock"}
	fs := flag.NewFlagSet("test", flag.PanicOnError)
	fs.Var(NewActionNames(), "actions", "")

	fs.Parse(args)

	enabledActions, _ := EnabledActionsFromFlags(fs, "actions")

	assert.Equal(t, enabledActions, []string{"mock"})
}