feat(models): make NamedFilterable implement Faulty and add default IsFaulty() to all subtypes

Author: jingle2008

internal/collections/filter_test.go

@@ -14,6 +14,7 @@ type testStruct struct {
 
 func (t testStruct) GetName() string               { return t.name }
 func (t testStruct) GetFilterableFields() []string { return []string{t.name, t.value} }
+func (testStruct) IsFaulty() bool                  { return false }
 
 func TestFilterSlice_Basic(t *testing.T) {
 	t.Parallel()

internal/domain/category.go

@@ -130,6 +130,10 @@ func (e Category) GetFilterableFields() []string {
 	return e.GetAliases()
 }
 
+func (e Category) IsFaulty() bool {
+	return false
+}
+
 func GetInitials(s string) string {
 	re := regexp.MustCompile(`[A-Z]`)
 	initials := re.FindAllString(s, -1)

internal/ui/tui/row_builders_test.go

@@ -46,6 +46,7 @@ func (f fakeDef) GetName() string               { return f.name }
 func (f fakeDef) GetDescription() string        { return f.desc }
 func (f fakeDef) GetValue() string              { return f.value }
 func (f fakeDef) GetFilterableFields() []string { return []string{f.name, f.desc, f.value} }
+func (fakeDef) IsFaulty() bool                  { return false }
 
 func Test_definitionToRow(t *testing.T) {
 	def := fakeDef{"n", "d", "v"}
@@ -109,6 +110,7 @@ func (f fakeDefOverride) GetName() string               { return f.name }
 func (f fakeDefOverride) GetValue() string              { return f.value }
 func (f fakeDefOverride) GetRegions() []string          { return f.regions }
 func (f fakeDefOverride) GetFilterableFields() []string { return append(f.regions, f.name, f.value) }
+func (fakeDefOverride) IsFaulty() bool                  { return false }
 
 func Test_propertyTenancyOverrideToRow(t *testing.T) {
 	def := fakeDefOverride{"PD1", "val", []string{"us", "eu"}}

internal/ui/tui/table_utils.go

@@ -15,71 +15,59 @@ func faultyPred[T models.Faulty](t T) bool {
 }
 
 var categoryHandlers = map[domain.Category]func(logging.Logger, *models.Dataset, *domain.ToolkitContext, string, bool) []table.Row{
-	domain.Alias: func(_ logging.Logger, _ *models.Dataset, _ *domain.ToolkitContext, filter string, _ bool) []table.Row {
-		return filterRows(domain.Categories, filter, nil, aliasToRow)
+	domain.Alias: func(_ logging.Logger, _ *models.Dataset, _ *domain.ToolkitContext, filter string, faultyOnly bool) []table.Row {
+		return filterRows(domain.Categories, filter, faultyOnly, aliasToRow)
 	},
 	domain.Tenant: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, faultyOnly bool) []table.Row {
-		var pred func(models.Tenant) bool
-		if faultyOnly {
-			pred = faultyPred
-		}
-		return filterRows(dataset.Tenants, filter, pred, tenantToRow)
+		return filterRows(dataset.Tenants, filter, faultyOnly, tenantToRow)
 	},
-	domain.LimitDefinition: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, _ bool) []table.Row {
-		return filterRows(dataset.LimitDefinitionGroup.Values, filter, nil, limitDefinitionToRow)
+	domain.LimitDefinition: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, faultyOnly bool) []table.Row {
+		return filterRows(dataset.LimitDefinitionGroup.Values, filter, faultyOnly, limitDefinitionToRow)
 	},
-	domain.ConsolePropertyDefinition: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, _ bool) []table.Row {
-		return filterRows(dataset.ConsolePropertyDefinitionGroup.Values, filter, nil, definitionToRow)
+	domain.ConsolePropertyDefinition: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, faultyOnly bool) []table.Row {
+		return filterRows(dataset.ConsolePropertyDefinitionGroup.Values, filter, faultyOnly, definitionToRow)
 	},
-	domain.PropertyDefinition: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, _ bool) []table.Row {
-		return filterRows(dataset.PropertyDefinitionGroup.Values, filter, nil, definitionToRow)
+	domain.PropertyDefinition: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, faultyOnly bool) []table.Row {
+		return filterRows(dataset.PropertyDefinitionGroup.Values, filter, faultyOnly, definitionToRow)
 	},
-	domain.LimitTenancyOverride: func(logger logging.Logger, dataset *models.Dataset, context *domain.ToolkitContext, filter string, _ bool) []table.Row {
-		return GetScopedItems(dataset.LimitTenancyOverrideMap, domain.Tenant, context, filter, nil, limitTenancyOverrideToRow)
+	domain.LimitTenancyOverride: func(logger logging.Logger, dataset *models.Dataset, context *domain.ToolkitContext, filter string, faultyOnly bool) []table.Row {
+		return filterRowsScoped(dataset.LimitTenancyOverrideMap, domain.Tenant, context, filter, faultyOnly, limitTenancyOverrideToRow)
 	},
-	domain.ConsolePropertyTenancyOverride: func(logger logging.Logger, dataset *models.Dataset, context *domain.ToolkitContext, filter string, _ bool) []table.Row {
-		return GetScopedItems(dataset.ConsolePropertyTenancyOverrideMap, domain.Tenant, context, filter, nil, propertyTenancyOverrideToRow)
+	domain.ConsolePropertyTenancyOverride: func(logger logging.Logger, dataset *models.Dataset, context *domain.ToolkitContext, filter string, faultyOnly bool) []table.Row {
+		return filterRowsScoped(dataset.ConsolePropertyTenancyOverrideMap, domain.Tenant, context, filter, faultyOnly, propertyTenancyOverrideToRow)
 	},
-	domain.PropertyTenancyOverride: func(logger logging.Logger, dataset *models.Dataset, context *domain.ToolkitContext, filter string, _ bool) []table.Row {
-		return GetScopedItems(dataset.PropertyTenancyOverrideMap, domain.Tenant, context, filter, nil, propertyTenancyOverrideToRow)
+	domain.PropertyTenancyOverride: func(logger logging.Logger, dataset *models.Dataset, context *domain.ToolkitContext, filter string, faultyOnly bool) []table.Row {
+		return filterRowsScoped(dataset.PropertyTenancyOverrideMap, domain.Tenant, context, filter, faultyOnly, propertyTenancyOverrideToRow)
 	},
-	domain.LimitRegionalOverride: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, _ bool) []table.Row {
-		return filterRows(dataset.LimitRegionalOverrides, filter, nil, limitRegionalOverrideToRow)
+	domain.LimitRegionalOverride: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, faultyOnly bool) []table.Row {
+		return filterRows(dataset.LimitRegionalOverrides, filter, faultyOnly, limitRegionalOverrideToRow)
 	},
-	domain.ConsolePropertyRegionalOverride: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, _ bool) []table.Row {
-		return filterRows(dataset.ConsolePropertyRegionalOverrides, filter, nil, propertyRegionalOverrideToRow)
+	domain.ConsolePropertyRegionalOverride: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, faultyOnly bool) []table.Row {
+		return filterRows(dataset.ConsolePropertyRegionalOverrides, filter, faultyOnly, propertyRegionalOverrideToRow)
 	},
-	domain.PropertyRegionalOverride: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, _ bool) []table.Row {
-		return filterRows(dataset.PropertyRegionalOverrides, filter, nil, propertyRegionalOverrideToRow)
+	domain.PropertyRegionalOverride: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, faultyOnly bool) []table.Row {
+		return filterRows(dataset.PropertyRegionalOverrides, filter, faultyOnly, propertyRegionalOverrideToRow)
 	},
-	domain.BaseModel: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, _ bool) []table.Row {
-		return getBaseModels(dataset.BaseModelMap, filter)
+	domain.BaseModel: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, faultyOnly bool) []table.Row {
+		return getBaseModels(dataset.BaseModelMap, filter, faultyOnly)
 	},
-	domain.ModelArtifact: func(logger logging.Logger, dataset *models.Dataset, context *domain.ToolkitContext, filter string, _ bool) []table.Row {
-		return GetScopedItems(dataset.ModelArtifactMap, domain.BaseModel, context, filter, nil, modelArtifactToRow)
+	domain.ModelArtifact: func(logger logging.Logger, dataset *models.Dataset, context *domain.ToolkitContext, filter string, faultyOnly bool) []table.Row {
+		return filterRowsScoped(dataset.ModelArtifactMap, domain.BaseModel, context, filter, faultyOnly, modelArtifactToRow)
 	},
-	domain.Environment: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, _ bool) []table.Row {
-		return filterRows(dataset.Environments, filter, nil, environmentToRow)
+	domain.Environment: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, faultyOnly bool) []table.Row {
+		return filterRows(dataset.Environments, filter, faultyOnly, environmentToRow)
 	},
-	domain.ServiceTenancy: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, _ bool) []table.Row {
-		return filterRows(dataset.ServiceTenancies, filter, nil, serviceTenancyToRow)
+	domain.ServiceTenancy: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, faultyOnly bool) []table.Row {
+		return filterRows(dataset.ServiceTenancies, filter, faultyOnly, serviceTenancyToRow)
 	},
-	domain.GpuPool: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, _ bool) []table.Row {
-		return filterRows(dataset.GpuPools, filter, nil, gpuPoolToRow)
+	domain.GpuPool: func(_ logging.Logger, dataset *models.Dataset, _ *domain.ToolkitContext, filter string, faultyOnly bool) []table.Row {
+		return filterRows(dataset.GpuPools, filter, faultyOnly, gpuPoolToRow)
 	},
 	domain.GpuNode: func(logger logging.Logger, dataset *models.Dataset, context *domain.ToolkitContext, filter string, faultyOnly bool) []table.Row {
-		var pred func(models.GpuNode) bool
-		if faultyOnly {
-			pred = faultyPred
-		}
-		return GetScopedItems(dataset.GpuNodeMap, domain.GpuPool, context, filter, pred, gpuNodeToRow)
+		return filterRowsScoped(dataset.GpuNodeMap, domain.GpuPool, context, filter, faultyOnly, gpuNodeToRow)
 	},
 	domain.DedicatedAICluster: func(logger logging.Logger, dataset *models.Dataset, context *domain.ToolkitContext, filter string, faultyOnly bool) []table.Row {
-		var pred func(models.DedicatedAICluster) bool
-		if faultyOnly {
-			pred = faultyPred
-		}
-		return GetScopedItems(dataset.DedicatedAIClusterMap, domain.Tenant, context, filter, pred, dedicatedAIClusterToRow)
+		return filterRowsScoped(dataset.DedicatedAIClusterMap, domain.Tenant, context, filter, faultyOnly, dedicatedAIClusterToRow)
 	},
 }
 
@@ -119,7 +107,12 @@ func getTableRows(logger logging.Logger, dataset *models.Dataset, category domai
 filterRows filters a slice of items using the provided filter and row function.
 It returns a slice of table.Row for items that match the filter.
 */
-func filterRows[T models.NamedFilterable](items []T, filter string, pred func(T) bool, rowFn func(T) table.Row) []table.Row {
+func filterRows[T models.NamedFilterable](items []T, filter string, faultyOnly bool, rowFn func(T) table.Row) []table.Row {
+	var pred func(T) bool
+	if faultyOnly {
+		pred = faultyPred
+	}
+
 	matches := collections.FilterSlice(items, nil, filter, pred)
 	results := make([]table.Row, 0, len(matches))
 	for _, m := range matches {
@@ -131,23 +124,23 @@ func filterRows[T models.NamedFilterable](items []T, filter string, pred func(T)
 /*
 getBaseModels returns table rows for a map of BaseModel, filtered by the provided filter string.
 */
-func getBaseModels(m map[string]*models.BaseModel, filter string) []table.Row {
+func getBaseModels(m map[string]*models.BaseModel, filter string, faultyOnly bool) []table.Row {
 	baseModels := make([]*models.BaseModel, 0, len(m))
 	for _, model := range m {
 		baseModels = append(baseModels, model)
 	}
 
-	return filterRows(baseModels, filter, nil, baseModelToRow)
+	return filterRows(baseModels, filter, faultyOnly, baseModelToRow)
 }
 
-// GetScopedItems is used for tenancy and other scoped overrides.
+// filterRowsScoped is used for tenancy and other scoped overrides.
 // Accepts a Logger interface for decoupling from zap.
-func GetScopedItems[T models.NamedFilterable](
+func filterRowsScoped[T models.NamedFilterable](
 	g map[string][]T,
 	scopeCategory domain.Category,
 	ctx *domain.ToolkitContext,
 	filter string,
-	pred func(T) bool,
+	faultyOnly bool,
 	rowFn func(T, string) table.Row,
 ) []table.Row {
 	var (
@@ -163,6 +156,10 @@ func GetScopedItems[T models.NamedFilterable](
 		}
 	}
 
+	var pred func(T) bool
+	if faultyOnly {
+		pred = faultyPred
+	}
 	matches := collections.FilterMap(g, key, name, filter, pred)
 	results := make([]table.Row, 0, len(matches))
 	for key, m := range matches {

internal/ui/tui/table_utils_test.go

@@ -39,7 +39,7 @@ func Test_getBaseModels_returns_rows(t *testing.T) {
 			LifeCyclePhase:      "DEPRECATED",
 		},
 	}
-	rows := getBaseModels(baseModels, "")
+	rows := getBaseModels(baseModels, "", false)
 	assert.Len(t, rows, 1)
 	assert.Equal(t, table.Row{
 		"BM1", "bm1", "v1", "", "C/C*2", "1024", "EXP/INT/LTS/RTD",
@@ -326,7 +326,7 @@ func TestFilterRows(t *testing.T) {
 		{Type: "foo", Region: "us-phx-1"},
 		{Type: "bar", Region: "us-ashburn-1"},
 	}
-	rows := filterRows(items, "foo", nil, func(e models.Environment) table.Row {
+	rows := filterRows(items, "foo", false, func(e models.Environment) table.Row {
 		return table.Row{e.Type, e.Region}
 	})
 	assert.Len(t, rows, 1)
@@ -355,7 +355,7 @@ func TestGetBaseModels_SortsAndFilters(t *testing.T) {
 		"a": {InternalName: "a", Name: "A"},
 		"b": {InternalName: "b", Name: "B"},
 	}
-	rows := getBaseModels(m, "a")
+	rows := getBaseModels(m, "a", false)
 	assert.Len(t, rows, 1)
 	assert.Contains(t, rows[0][0], "A")
 }

pkg/models/base_model.go

@@ -151,6 +151,11 @@ func (m BaseModel) GetFilterableFields() []string {
 		m.GetFlags(), shapeName)
 }
 
+// IsFaulty returns false by default for BaseModel.
+func (m BaseModel) IsFaulty() bool {
+	return false
+}
+
 // GetFlags returns the flags for the base model.
 func (m BaseModel) GetFlags() string {
 	flags := []string{}

pkg/models/console_property.go

@@ -27,6 +27,11 @@ func (c ConsolePropertyDefinition) GetFilterableFields() []string {
 	return []string{c.Name, c.Description}
 }
 
+// IsFaulty returns false by default for ConsolePropertyDefinition.
+func (c ConsolePropertyDefinition) IsFaulty() bool {
+	return false
+}
+
 // ConsolePropertyRegionalOverride represents a regional override for a console property.
 type ConsolePropertyRegionalOverride struct {
 	Realms  []string `json:"realms"`
@@ -58,6 +63,11 @@ func (o ConsolePropertyRegionalOverride) GetFilterableFields() []string {
 	return append(o.Regions, o.Name)
 }
 
+// IsFaulty returns false by default for ConsolePropertyRegionalOverride.
+func (o ConsolePropertyRegionalOverride) IsFaulty() bool {
+	return false
+}
+
 // ConsolePropertyTenancyOverride represents a tenancy override for a console property.
 type ConsolePropertyTenancyOverride struct {
 	TenantID string `json:"tenant_id"`
@@ -73,3 +83,8 @@ func (o ConsolePropertyTenancyOverride) GetTenantID() string {
 func (o ConsolePropertyTenancyOverride) GetFilterableFields() []string {
 	return append(o.Regions, o.Name, o.TenantID)
 }
+
+// IsFaulty returns false by default for ConsolePropertyTenancyOverride.
+func (o ConsolePropertyTenancyOverride) IsFaulty() bool {
+	return false
+}

pkg/models/definitions.go

@@ -14,6 +14,7 @@ type NamedItem interface {
 type NamedFilterable interface {
 	NamedItem
 	Filterable
+	Faulty
 }
 
 // Definition represents a definition item with description and value.

pkg/models/definitions_test.go

@@ -15,6 +15,7 @@ func (testImpl) GetRegions() []string          { return []string{"r"} }
 func (testImpl) GetValue() string              { return "v" }
 func (testImpl) Environments() []Environment   { return nil }
 func (testImpl) GetDescription() string        { return "desc" }
+func (testImpl) IsFaulty() bool                { return false }
 
 func TestDefinitionInterfaces(t *testing.T) {
 	t.Parallel()

pkg/models/environment.go

@@ -21,6 +21,11 @@ func (e Environment) GetFilterableFields() []string {
 	return []string{e.Type, e.Region, e.Realm, e.GetName()}
 }
 
+// IsFaulty returns false by default for Environment.
+func (e Environment) IsFaulty() bool {
+	return false
+}
+
 // Equals returns true if the environment is equal to another environment.
 func (e Environment) Equals(o Environment) bool {
 	return e.Realm == o.Realm && e.GetName() == o.GetName()