am/go/incident/incident_test.go - buildbot - Git at Google

 package incident

 import (
 	"testing"
 	"time"

 	"github.com/stretchr/testify/assert"
 	"go.skia.org/infra/am/go/note"
 	"go.skia.org/infra/am/go/silence"
 	"go.skia.org/infra/go/alerts"
 	"go.skia.org/infra/go/ds"
 	"go.skia.org/infra/go/ds/testutil"
 	"go.skia.org/infra/go/paramtools"
 	"go.skia.org/infra/go/testutils/unittest"
 )

 func TestAreIncidentsFlaky(t *testing.T) {
 	unittest.SmallTest(t)

 	now := time.Now().Unix()

 	// Add 10 incidents with duration = 10 mins and 10 with duration < 10 mins.
 	incidents := []Incident{}
 	for i := 0; i < 10; i++ {
 		incidents = append(incidents, Incident{LastSeen: now, Start: now - 600})
 		incidents = append(incidents, Incident{LastSeen: now, Start: now - 10})
 	}
 	// Should not be flaky because 50% are flaky not matching the specified 60%.
 	assert.False(t, AreIncidentsFlaky(incidents, 10, 600, 0.60))
 	// Should be flaky because 50% are flaky matching the specifeid 50%.
 	assert.True(t, AreIncidentsFlaky(incidents, 10, 600, 0.50))

 	// Add 4 incidents with duration = 10 mins and 6 with duration < 10 mins.
 	incidents = []Incident{}
 	for i := 0; i < 4; i++ {
 		incidents = append(incidents, Incident{LastSeen: now, Start: now - 600})
 	}
 	for i := 0; i < 6; i++ {
 		incidents = append(incidents, Incident{LastSeen: now, Start: now - 10})
 	}
 	// Should not be flaky because 60% are flaky not matching the specified 61%.
 	assert.False(t, AreIncidentsFlaky(incidents, 10, 600, 0.61))
 	// Should be flaky because 60% are flaky matching the specified 60%.
 	assert.True(t, AreIncidentsFlaky(incidents, 10, 600, 0.60))

 	// Add 9 incidents with duration < 10 mins.
 	incidents = []Incident{}
 	for i := 0; i < 9; i++ {
 		incidents = append(incidents, Incident{LastSeen: now, Start: now - 10})
 	}
 	// Should not be flaky because num incidents did not meet the specified threshold of 10.
 	assert.False(t, AreIncidentsFlaky(incidents, 10, 600, 1.00))
 	// Should be flaky because num incidents do meet the specified threshold of 9 and 100%.
 	assert.True(t, AreIncidentsFlaky(incidents, 9, 600, 1.00))
 }

 func TestIsSilenced(t *testing.T) {
 	unittest.SmallTest(t)

 	i := Incident{
 		Params: map[string]string{
 			"foo": "2123",
 			"bar": "aa",
 		},
 	}

 	// Test with simple silences

 	silences := []silence.Silence{
 		{
 			Active:   true,
 			ParamSet: paramtools.ParamSet{"foo": []string{"2123"}},
 		},
 	}
 	assert.True(t, i.IsSilenced(silences))

 	silences = []silence.Silence{
 		{
 			Active:   true,
 			ParamSet: paramtools.ParamSet{"foo": []string{"abc", "xyz", "2123"}},
 		},
 		{
 			Active:   true,
 			ParamSet: paramtools.ParamSet{"blah": []string{"abc", "xyz", "2123"}},
 		},
 	}
 	assert.True(t, i.IsSilenced(silences))

 	silences = []silence.Silence{
 		{
 			Active:   true,
 			ParamSet: paramtools.ParamSet{"foo": []string{"abc", "xyz", "32"}},
 		},
 		{
 			Active:   true,
 			ParamSet: paramtools.ParamSet{"blah": []string{"abc", "xyz", "2123"}},
 		},
 	}
 	assert.False(t, i.IsSilenced(silences))

 	// Test with ignore.
 	silences = []silence.Silence{
 		{
 			Active:   false,
 			ParamSet: paramtools.ParamSet{"foo": []string{"2123"}},
 		},
 	}
 	assert.False(t, i.IsSilenced(silences))

 	// Tests with regexes.

 	silences = []silence.Silence{
 		{
 			Active:   true,
 			ParamSet: paramtools.ParamSet{"foo": []string{"2.*"}},
 		},
 	}
 	assert.True(t, i.IsSilenced(silences))

 	silences = []silence.Silence{
 		{
 			Active:   true,
 			ParamSet: paramtools.ParamSet{"foo": []string{"3.*"}},
 		},
 		{
 			Active:   true,
 			ParamSet: paramtools.ParamSet{"bar": []string{"aa"}},
 		},
 	}
 	assert.True(t, i.IsSilenced(silences))

 	silences = []silence.Silence{
 		{
 			Active:   true,
 			ParamSet: paramtools.ParamSet{"foo": []string{"3.*"}},
 		},
 		{
 			Active:   true,
 			ParamSet: paramtools.ParamSet{"bar": []string{"bb"}},
 		},
 	}
 	assert.False(t, i.IsSilenced(silences))

 	// Test with paramset with both regex and non-regex by adding another value to existing key.
 	silences = []silence.Silence{
 		{
 			Active:   true,
 			ParamSet: paramtools.ParamSet{"foo": []string{"3.*"}},
 		},
 		{
 			Active:   true,
 			ParamSet: paramtools.ParamSet{"bar": []string{"bb", "aa", "cc"}},
 		},
 	}
 	assert.True(t, i.IsSilenced(silences))

 	// Test with silence that does not apply.
 	silences = []silence.Silence{
 		{
 			Active:   true,
 			ParamSet: paramtools.ParamSet{"foo": []string{"3.*"}},
 		},
 		{
 			Active:   true,
 			ParamSet: paramtools.ParamSet{"bar": []string{"bb", "aa", "cc"}, "blah": []string{"abc"}},
 		},
 	}
 	assert.False(t, i.IsSilenced(silences))
 }

 func TestAlertArrival(t *testing.T) {
 	unittest.LargeTest(t)

 	cleanup := testutil.InitDatastore(t, ds.INCIDENT_AM, ds.INCIDENT_ACTIVE_PARENT_AM)
 	defer cleanup()

 	st := NewStore(ds.DS, []string{"ignore"})

 	m := map[string]string{
 		"ignore":     "pod_123",
 		alerts.TYPE:  alerts.TYPE_ALERTS,
 		alerts.STATE: alerts.STATE_ACTIVE,
 		ALERT_NAME:   "BotUnemployed",
 		"bot":        "skia-rpi-064",
 		CATEGORY:     "infra",
 	}
 	a, err := st.AlertArrival(m)
 	assert.NoError(t, err)
 	assert.Equal(t, true, a.Active)
 	assert.NotEqual(t, "", a.Key)

 	// A second alert arrival with the same config doesn't create
 	// a new Incident.
 	a, err = st.AlertArrival(m)
 	assert.NoError(t, err)
 	assert.Equal(t, true, a.Active)
 	assert.NotEqual(t, "", a.Key)

 	all, err := st.GetAll()
 	assert.NoError(t, err)
 	assert.Equal(t, 1, len(all))

 	// But an alert arrival with a different config does create
 	// a new incident.
 	m[ALERT_NAME] = "BotMissing"
 	delete(m, ID)
 	b, err := st.AlertArrival(m)
 	assert.NoError(t, err)
 	assert.Equal(t, true, b.Active)
 	assert.NotEqual(t, "", b.Key)
 	assert.NotEqual(t, a.ID, b.ID)

 	// Add a note.
 	bb, err := st.AddNote(b.Key, note.Note{
 		Text:   "Stuff happened.",
 		Author: "fred@example.com",
 		TS:     time.Now().Unix(),
 	})
 	assert.NoError(t, err)
 	assert.Equal(t, "Stuff happened.", bb.Notes[0].Text)
 	assert.Equal(t, b.Key, bb.Key)

 	// Fail to add note, bad key.
 	_, err = st.AddNote("badkey", note.Note{})
 	assert.Error(t, err)

 	// Delete note, bad index.
 	_, err = st.DeleteNote(b.Key, 1)
 	assert.Error(t, err)

 	// Delete note.
 	b, err = st.DeleteNote(b.Key, 0)
 	assert.NoError(t, err)
 	assert.Equal(t, 0, len(b.Notes))

 	// Assign
 	b, err = st.Assign(b.Key, "barney@example.org")
 	assert.NoError(t, err)
 	assert.Equal(t, "barney@example.org", b.Params[ASSIGNED_TO])

 	m[alerts.STATE] = alerts.STATE_RESOLVED
 	b, err = st.AlertArrival(m)
 	assert.NoError(t, err)
 	assert.False(t, b.Active)

 	// Archive
 	b, err = st.Archive(b.Key)
 	assert.NoError(t, err)

 	recent, err := st.GetRecentlyResolvedForID(b.ID, "")
 	assert.NoError(t, err)
 	assert.Len(t, recent, 1)

 	recent, err = st.GetRecentlyResolvedForID(b.ID, b.Key)
 	assert.NoError(t, err)
 	assert.Len(t, recent, 0)
 }

 func TestIdForAlert(t *testing.T) {
 	unittest.LargeTest(t)
 	m := map[string]string{
 		"__name__":   "ALERTS",
 		"alertname":  "BotMissing",
 		"alertstate": "firing",
 		"bot":        "skia-rpi-064",
 		"category":   "infra",
 		"instance":   "skia-datahopper2:20000",
 		"job":        "datahopper",
 		"pool":       "Skia",
 		"severity":   "critical",
 		"swarming":   "chromium-swarm.appspot.com",
 	}
 	st := NewStore(nil, []string{})

 	id1, err := st.idForAlert(m)
 	assert.NoError(t, err)
 	id2, err := st.idForAlert(m)
 	assert.NoError(t, err)
 	assert.Equal(t, id1, id2)

 	m[alerts.STATE] = alerts.STATE_ACTIVE
 	id2, err = st.idForAlert(m)
 	assert.NoError(t, err)
 	assert.Equal(t, id1, id2)
 }

 func TestGetRegexesToOwners(t *testing.T) {
 	unittest.SmallTest(t)

 	ownersRegexesStr := "owner1:abbr_regex1,abbr_regex2;owner2:abbr_regex3"
 	m1, err := getRegexesToOwners(ownersRegexesStr)
 	assert.NoError(t, err)
 	assert.Equal(t, 3, len(m1))
 	assert.Equal(t, "owner1", m1["abbr_regex1"])
 	assert.Equal(t, "owner1", m1["abbr_regex2"])
 	assert.Equal(t, "owner2", m1["abbr_regex3"])

 	// Test badly formed regex with missing owner1.
 	m2, err := getRegexesToOwners("abbr_regex1,abbr2_regex;owner2:abbr_regex3")
 	assert.Error(t, err)
 	assert.Nil(t, m2)
 }

 func TestGetOwnerIfMatch(t *testing.T) {
 	unittest.SmallTest(t)

 	// Test matches.
 	ownersRegexesStr := "superman@krypton.com:Bizarro.*,^Kryptonite.*Asteroid.*$;batman@gotham.com:Joker.*"

 	ownerTest1, err := getOwnerIfMatch(ownersRegexesStr, "something Bizarro something")
 	assert.NoError(t, err)
 	assert.Equal(t, "superman@krypton.com", ownerTest1)

 	ownerTest2, err := getOwnerIfMatch(ownersRegexesStr, "Kryptonite really big Asteroid thing")
 	assert.NoError(t, err)
 	assert.Equal(t, "superman@krypton.com", ownerTest2)

 	ownerTest3, err := getOwnerIfMatch(ownersRegexesStr, "Joker is here!!!")
 	assert.NoError(t, err)
 	assert.Equal(t, "batman@gotham.com", ownerTest3)

 	ownerTest4, err := getOwnerIfMatch(ownersRegexesStr, "Joker")
 	assert.NoError(t, err)
 	assert.Equal(t, "batman@gotham.com", ownerTest4)

 	// Test misses.
 	ownerMiss1, err := getOwnerIfMatch(ownersRegexesStr, "bizarro")
 	assert.NoError(t, err)
 	assert.Equal(t, "", ownerMiss1)

 	ownerMiss2, err := getOwnerIfMatch(ownersRegexesStr, "wrong start Kryptonite really big Asteroid thing")
 	assert.NoError(t, err)
 	assert.Equal(t, "", ownerMiss2)

 	ownerMiss3, err := getOwnerIfMatch(ownersRegexesStr, "joker")
 	assert.NoError(t, err)
 	assert.Equal(t, "", ownerMiss3)

 	// Test badly formed regex.
 	badRegex := "superman@krypton:.***"
 	ownerBadTest, err := getOwnerIfMatch(badRegex, "Anything")
 	assert.Error(t, err)
 	assert.Equal(t, "", ownerBadTest)
 }
	package incident

	import (
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"go.skia.org/infra/am/go/note"
	"go.skia.org/infra/am/go/silence"
	"go.skia.org/infra/go/alerts"
	"go.skia.org/infra/go/ds"
	"go.skia.org/infra/go/ds/testutil"
	"go.skia.org/infra/go/paramtools"
	"go.skia.org/infra/go/testutils/unittest"
	)

	func TestAreIncidentsFlaky(t *testing.T) {
	unittest.SmallTest(t)

	now := time.Now().Unix()

	// Add 10 incidents with duration = 10 mins and 10 with duration < 10 mins.
	incidents := []Incident{}
	for i := 0; i < 10; i++ {
	incidents = append(incidents, Incident{LastSeen: now, Start: now - 600})
	incidents = append(incidents, Incident{LastSeen: now, Start: now - 10})
	}
	// Should not be flaky because 50% are flaky not matching the specified 60%.
	assert.False(t, AreIncidentsFlaky(incidents, 10, 600, 0.60))
	// Should be flaky because 50% are flaky matching the specifeid 50%.
	assert.True(t, AreIncidentsFlaky(incidents, 10, 600, 0.50))

	// Add 4 incidents with duration = 10 mins and 6 with duration < 10 mins.
	incidents = []Incident{}
	for i := 0; i < 4; i++ {
	incidents = append(incidents, Incident{LastSeen: now, Start: now - 600})
	}
	for i := 0; i < 6; i++ {
	incidents = append(incidents, Incident{LastSeen: now, Start: now - 10})
	}
	// Should not be flaky because 60% are flaky not matching the specified 61%.
	assert.False(t, AreIncidentsFlaky(incidents, 10, 600, 0.61))
	// Should be flaky because 60% are flaky matching the specified 60%.
	assert.True(t, AreIncidentsFlaky(incidents, 10, 600, 0.60))

	// Add 9 incidents with duration < 10 mins.
	incidents = []Incident{}
	for i := 0; i < 9; i++ {
	incidents = append(incidents, Incident{LastSeen: now, Start: now - 10})
	}
	// Should not be flaky because num incidents did not meet the specified threshold of 10.
	assert.False(t, AreIncidentsFlaky(incidents, 10, 600, 1.00))
	// Should be flaky because num incidents do meet the specified threshold of 9 and 100%.
	assert.True(t, AreIncidentsFlaky(incidents, 9, 600, 1.00))
	}

	func TestIsSilenced(t *testing.T) {
	unittest.SmallTest(t)

	i := Incident{
	Params: map[string]string{
	"foo": "2123",
	"bar": "aa",
	},
	}

	// Test with simple silences

	silences := []silence.Silence{
	{
	Active: true,
	ParamSet: paramtools.ParamSet{"foo": []string{"2123"}},
	},
	}
	assert.True(t, i.IsSilenced(silences))

	silences = []silence.Silence{
	{
	Active: true,
	ParamSet: paramtools.ParamSet{"foo": []string{"abc", "xyz", "2123"}},
	},
	{
	Active: true,
	ParamSet: paramtools.ParamSet{"blah": []string{"abc", "xyz", "2123"}},
	},
	}
	assert.True(t, i.IsSilenced(silences))

	silences = []silence.Silence{
	{
	Active: true,
	ParamSet: paramtools.ParamSet{"foo": []string{"abc", "xyz", "32"}},
	},
	{
	Active: true,
	ParamSet: paramtools.ParamSet{"blah": []string{"abc", "xyz", "2123"}},
	},
	}
	assert.False(t, i.IsSilenced(silences))

	// Test with ignore.
	silences = []silence.Silence{
	{
	Active: false,
	ParamSet: paramtools.ParamSet{"foo": []string{"2123"}},
	},
	}
	assert.False(t, i.IsSilenced(silences))

	// Tests with regexes.

	silences = []silence.Silence{
	{
	Active: true,
	ParamSet: paramtools.ParamSet{"foo": []string{"2.*"}},
	},
	}
	assert.True(t, i.IsSilenced(silences))

	silences = []silence.Silence{
	{
	Active: true,
	ParamSet: paramtools.ParamSet{"foo": []string{"3.*"}},
	},
	{
	Active: true,
	ParamSet: paramtools.ParamSet{"bar": []string{"aa"}},
	},
	}
	assert.True(t, i.IsSilenced(silences))

	silences = []silence.Silence{
	{
	Active: true,
	ParamSet: paramtools.ParamSet{"foo": []string{"3.*"}},
	},
	{
	Active: true,
	ParamSet: paramtools.ParamSet{"bar": []string{"bb"}},
	},
	}
	assert.False(t, i.IsSilenced(silences))

	// Test with paramset with both regex and non-regex by adding another value to existing key.
	silences = []silence.Silence{
	{
	Active: true,
	ParamSet: paramtools.ParamSet{"foo": []string{"3.*"}},
	},
	{
	Active: true,
	ParamSet: paramtools.ParamSet{"bar": []string{"bb", "aa", "cc"}},
	},
	}
	assert.True(t, i.IsSilenced(silences))

	// Test with silence that does not apply.
	silences = []silence.Silence{
	{
	Active: true,
	ParamSet: paramtools.ParamSet{"foo": []string{"3.*"}},
	},
	{
	Active: true,
	ParamSet: paramtools.ParamSet{"bar": []string{"bb", "aa", "cc"}, "blah": []string{"abc"}},
	},
	}
	assert.False(t, i.IsSilenced(silences))
	}

	func TestAlertArrival(t *testing.T) {
	unittest.LargeTest(t)

	cleanup := testutil.InitDatastore(t, ds.INCIDENT_AM, ds.INCIDENT_ACTIVE_PARENT_AM)
	defer cleanup()

	st := NewStore(ds.DS, []string{"ignore"})

	m := map[string]string{
	"ignore": "pod_123",
	alerts.TYPE: alerts.TYPE_ALERTS,
	alerts.STATE: alerts.STATE_ACTIVE,
	ALERT_NAME: "BotUnemployed",
	"bot": "skia-rpi-064",
	CATEGORY: "infra",
	}
	a, err := st.AlertArrival(m)
	assert.NoError(t, err)
	assert.Equal(t, true, a.Active)
	assert.NotEqual(t, "", a.Key)

	// A second alert arrival with the same config doesn't create
	// a new Incident.
	a, err = st.AlertArrival(m)
	assert.NoError(t, err)
	assert.Equal(t, true, a.Active)
	assert.NotEqual(t, "", a.Key)

	all, err := st.GetAll()
	assert.NoError(t, err)
	assert.Equal(t, 1, len(all))

	// But an alert arrival with a different config does create
	// a new incident.
	m[ALERT_NAME] = "BotMissing"
	delete(m, ID)
	b, err := st.AlertArrival(m)
	assert.NoError(t, err)
	assert.Equal(t, true, b.Active)
	assert.NotEqual(t, "", b.Key)
	assert.NotEqual(t, a.ID, b.ID)

	// Add a note.
	bb, err := st.AddNote(b.Key, note.Note{
	Text: "Stuff happened.",
	Author: "fred@example.com",
	TS: time.Now().Unix(),
	})
	assert.NoError(t, err)
	assert.Equal(t, "Stuff happened.", bb.Notes[0].Text)
	assert.Equal(t, b.Key, bb.Key)

	// Fail to add note, bad key.
	_, err = st.AddNote("badkey", note.Note{})
	assert.Error(t, err)

	// Delete note, bad index.
	_, err = st.DeleteNote(b.Key, 1)
	assert.Error(t, err)

	// Delete note.
	b, err = st.DeleteNote(b.Key, 0)
	assert.NoError(t, err)
	assert.Equal(t, 0, len(b.Notes))

	// Assign
	b, err = st.Assign(b.Key, "barney@example.org")
	assert.NoError(t, err)
	assert.Equal(t, "barney@example.org", b.Params[ASSIGNED_TO])

	m[alerts.STATE] = alerts.STATE_RESOLVED
	b, err = st.AlertArrival(m)
	assert.NoError(t, err)
	assert.False(t, b.Active)

	// Archive
	b, err = st.Archive(b.Key)
	assert.NoError(t, err)

	recent, err := st.GetRecentlyResolvedForID(b.ID, "")
	assert.NoError(t, err)
	assert.Len(t, recent, 1)

	recent, err = st.GetRecentlyResolvedForID(b.ID, b.Key)
	assert.NoError(t, err)
	assert.Len(t, recent, 0)
	}

	func TestIdForAlert(t *testing.T) {
	unittest.LargeTest(t)
	m := map[string]string{
	"__name__": "ALERTS",
	"alertname": "BotMissing",
	"alertstate": "firing",
	"bot": "skia-rpi-064",
	"category": "infra",
	"instance": "skia-datahopper2:20000",
	"job": "datahopper",
	"pool": "Skia",
	"severity": "critical",
	"swarming": "chromium-swarm.appspot.com",
	}
	st := NewStore(nil, []string{})

	id1, err := st.idForAlert(m)
	assert.NoError(t, err)
	id2, err := st.idForAlert(m)
	assert.NoError(t, err)
	assert.Equal(t, id1, id2)

	m[alerts.STATE] = alerts.STATE_ACTIVE
	id2, err = st.idForAlert(m)
	assert.NoError(t, err)
	assert.Equal(t, id1, id2)
	}

	func TestGetRegexesToOwners(t *testing.T) {
	unittest.SmallTest(t)

	ownersRegexesStr := "owner1:abbr_regex1,abbr_regex2;owner2:abbr_regex3"
	m1, err := getRegexesToOwners(ownersRegexesStr)
	assert.NoError(t, err)
	assert.Equal(t, 3, len(m1))
	assert.Equal(t, "owner1", m1["abbr_regex1"])
	assert.Equal(t, "owner1", m1["abbr_regex2"])
	assert.Equal(t, "owner2", m1["abbr_regex3"])

	// Test badly formed regex with missing owner1.
	m2, err := getRegexesToOwners("abbr_regex1,abbr2_regex;owner2:abbr_regex3")
	assert.Error(t, err)
	assert.Nil(t, m2)
	}

	func TestGetOwnerIfMatch(t *testing.T) {
	unittest.SmallTest(t)

	// Test matches.
	ownersRegexesStr := "superman@krypton.com:Bizarro.,^Kryptonite.Asteroid.$;batman@gotham.com:Joker."

	ownerTest1, err := getOwnerIfMatch(ownersRegexesStr, "something Bizarro something")
	assert.NoError(t, err)
	assert.Equal(t, "superman@krypton.com", ownerTest1)

	ownerTest2, err := getOwnerIfMatch(ownersRegexesStr, "Kryptonite really big Asteroid thing")
	assert.NoError(t, err)
	assert.Equal(t, "superman@krypton.com", ownerTest2)

	ownerTest3, err := getOwnerIfMatch(ownersRegexesStr, "Joker is here!!!")
	assert.NoError(t, err)
	assert.Equal(t, "batman@gotham.com", ownerTest3)

	ownerTest4, err := getOwnerIfMatch(ownersRegexesStr, "Joker")
	assert.NoError(t, err)
	assert.Equal(t, "batman@gotham.com", ownerTest4)

	// Test misses.
	ownerMiss1, err := getOwnerIfMatch(ownersRegexesStr, "bizarro")
	assert.NoError(t, err)
	assert.Equal(t, "", ownerMiss1)

	ownerMiss2, err := getOwnerIfMatch(ownersRegexesStr, "wrong start Kryptonite really big Asteroid thing")
	assert.NoError(t, err)
	assert.Equal(t, "", ownerMiss2)

	ownerMiss3, err := getOwnerIfMatch(ownersRegexesStr, "joker")
	assert.NoError(t, err)
	assert.Equal(t, "", ownerMiss3)

	// Test badly formed regex.
	badRegex := "superman@krypton:.***"
	ownerBadTest, err := getOwnerIfMatch(badRegex, "Anything")
	assert.Error(t, err)
	assert.Equal(t, "", ownerBadTest)
	}