tests

Author: Maia

internal/hud/webview/convert_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/golang/protobuf/ptypes/timestamp"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -205,8 +206,110 @@ func TestLocalResource(t *testing.T) {
 	r := v.Resources[1]
 	assert.Equal(t, "test", r.Name)
 	assert.Equal(t, model.RuntimeStatusNotApplicable, model.RuntimeStatus(r.RuntimeStatus))
+	require.Len(t, r.Specs, 1)
+	spec := r.Specs[0]
+	require.Equal(t, proto_webview.TargetType_TT_LOCAL, spec.Type)
+	require.False(t, spec.HasLiveUpdate)
 }
 
+func TestBuildHistory(t *testing.T) {
+	br1 := model.BuildRecord{
+		StartTime:  time.Now().Add(-1 * time.Hour),
+		FinishTime: time.Now().Add(-50 * time.Minute),
+		Reason:     model.BuildReasonFlagInit,
+		BuildTypes: []model.BuildType{model.BuildTypeImage, model.BuildTypeK8s},
+	}
+	br2 := model.BuildRecord{
+		Edits:      []string{"a.txt", "b.txt"},
+		StartTime:  time.Now().Add(-45 * time.Minute),
+		FinishTime: time.Now().Add(-44 * time.Minute),
+		Reason:     model.BuildReasonFlagChangedFiles,
+		BuildTypes: []model.BuildType{model.BuildTypeLiveUpdate},
+	}
+	br3 := model.BuildRecord{
+		StartTime:  time.Now().Add(-20 * time.Minute),
+		FinishTime: time.Now().Add(-19 * time.Minute),
+		Reason:     model.BuildReasonFlagCrash,
+		BuildTypes: []model.BuildType{model.BuildTypeImage, model.BuildTypeK8s},
+	}
+	buildRecords := []model.BuildRecord{br1, br2, br3}
+	expectedUpdateTypes := [][]proto_webview.UpdateType{
+		[]proto_webview.UpdateType{proto_webview.UpdateType_UT_IMAGE, proto_webview.UpdateType_UT_K8S},
+		[]proto_webview.UpdateType{proto_webview.UpdateType_UT_LIVE_UPDATE},
+		[]proto_webview.UpdateType{proto_webview.UpdateType_UT_IMAGE, proto_webview.UpdateType_UT_K8S},
+	}
+
+	m := model.Manifest{
+		Name: "foo",
+	}.WithDeployTarget(model.K8sTarget{})
+	state := newState([]model.Manifest{m})
+	state.ManifestTargets[m.Name].State.BuildHistory = buildRecords
+
+	v := stateToProtoView(t, *state)
+	require.Equal(t, 2, len(v.Resources))
+	r := v.Resources[1]
+	require.Equal(t, "foo", r.Name)
+	require.Len(t, r.BuildHistory, 3)
+
+	for i, actual := range r.BuildHistory {
+		expected := buildRecords[i]
+		require.Equal(t, expected.Edits, actual.Edits)
+		require.Equal(t, mustTimeToProto(expected.StartTime), actual.StartTime)
+		require.Equal(t, mustTimeToProto(expected.FinishTime), actual.FinishTime)
+		require.Equal(t, i == 2, actual.IsCrashRebuild)
+		require.ElementsMatch(t, expectedUpdateTypes[i], actual.UpdateTypes)
+	}
+}
+
+func TestSpecs(t *testing.T) {
+	lu, err := model.NewLiveUpdate(
+		[]model.LiveUpdateStep{model.LiveUpdateSyncStep{Source: "foo", Dest: "bar"}}, ".")
+	require.NoError(t, err)
+	luTarg := model.ImageTarget{}.WithBuildDetails(model.DockerBuild{LiveUpdate: lu})
+
+	mNoLiveUpd := model.Manifest{Name: "noLiveUpd"}.WithImageTarget(model.ImageTarget{}).WithDeployTarget(model.K8sTarget{})
+	mLiveUpd := model.Manifest{Name: "liveUpd"}.WithImageTarget(luTarg).WithDeployTarget(model.K8sTarget{})
+	mLocal := model.Manifest{Name: "local"}.WithDeployTarget(model.LocalTarget{})
+
+	expected := []struct {
+		name          string
+		targetTypes   []proto_webview.TargetType
+		hasLiveUpdate bool
+	}{
+		{"noLiveUpd", []proto_webview.TargetType{proto_webview.TargetType_TT_IMAGE, proto_webview.TargetType_TT_K8S}, false},
+		{"liveUpd", []proto_webview.TargetType{proto_webview.TargetType_TT_IMAGE, proto_webview.TargetType_TT_K8S}, true},
+		{"local", []proto_webview.TargetType{proto_webview.TargetType_TT_LOCAL}, false},
+	}
+	state := newState([]model.Manifest{mNoLiveUpd, mLiveUpd, mLocal})
+	v := stateToProtoView(t, *state)
+
+	require.Equal(t, 4, len(v.Resources))
+	for i, r := range v.Resources {
+		if i == 0 {
+			continue // skip Tiltfile
+		}
+		expected := expected[i-1]
+		require.Equal(t, expected.name, r.Name, "name mismatch for resource at index %d", i)
+		observedTypes := []proto_webview.TargetType{}
+		var iTargHasLU bool
+		for _, spec := range r.Specs {
+			observedTypes = append(observedTypes, spec.Type)
+			if spec.Type == proto_webview.TargetType_TT_IMAGE {
+				iTargHasLU = spec.HasLiveUpdate
+			}
+		}
+		require.ElementsMatch(t, expected.targetTypes, observedTypes, "for resource %q", r.Name)
+		require.Equal(t, expected.hasLiveUpdate, iTargHasLU, "for resource %q", r.Name)
+	}
+}
+
+func mustTimeToProto(t time.Time) *timestamp.Timestamp {
+	ts, err := timeToProto(t)
+	if err != nil {
+		panic(err)
+	}
+	return ts
+}
 func findResource(n model.ManifestName, view *proto_webview.View) (*proto_webview.Resource, bool) {
 	for _, res := range view.Resources {
 		if res.Name == n.String() {