Query language support for child iteration & area

controller/search_blackbox_test.go

@@ -1043,13 +1043,196 @@ func (s *searchControllerTestSuite) TestSearchByJoinedData() {
 		})
 		for _, wi := range list.Data {
 			_, ok := toBeFound[*wi.ID]
-			require.True(t, ok, "unknown work item found: %s", *wi.ID)
+			require.True(t, ok, "unexpected work item found: %s", *wi.ID)
 			delete(toBeFound, *wi.ID)
 		}
 		require.Empty(t, toBeFound, "failed to found all work items: %+s", toBeFound)
 	})
 }
 
+// TestSearchWorkItemsWithChildIterationsOption verifies the child work item search for iteration
+func (s *searchControllerTestSuite) TestSearchWorkItemsWithChildIterationsOption() {
+	s.T().Run("iterations", func(t *testing.T) {
+		fxt := tf.NewTestFixture(t, s.DB,
+			tf.Iterations(3,
+				tf.SetIterationNames("Top level iteration", "Level 1 iteration", "Level 2 iteration"),
+				func(fxt *tf.TestFixture, idx int) error {
+					if idx > 0 {
+						fxt.Iterations[idx].MakeChildOf(*fxt.Iterations[idx-1])
+					}
+					return nil
+				}),
+
+			tf.WorkItems(10, func(fxt *tf.TestFixture, idx int) error {
+				switch idx {
+				case 0, 1, 2:
+					fxt.WorkItems[idx].Fields[workitem.SystemIteration] = fxt.Iterations[0].ID.String()
+				case 3, 4:
+					fxt.WorkItems[idx].Fields[workitem.SystemIteration] = fxt.Iterations[1].ID.String()
+				case 5, 6, 7, 8:
+					fxt.WorkItems[idx].Fields[workitem.SystemIteration] = fxt.Iterations[2].ID.String()
+				}
+				return nil
+			}),
+		)
+
+		spaceIDStr := fxt.Spaces[0].ID.String()
+
+		t.Run("without child iteration", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s", "child": true}`, fxt.Iterations[2].ID)
+			_, result := test.ShowSearchOK(t, nil, nil, s.controller, &filter, nil, nil, nil, nil, &spaceIDStr)
+			require.NotEmpty(t, result.Data)
+			assert.Len(t, result.Data, 4)
+			toBeFound := id.MapFromSlice(id.Slice{
+				fxt.WorkItems[5].ID,
+				fxt.WorkItems[6].ID,
+				fxt.WorkItems[7].ID,
+				fxt.WorkItems[8].ID,
+			})
+			for _, wi := range result.Data {
+				_, ok := toBeFound[*wi.ID]
+				require.True(t, ok, "unexpected work item found: %s", *wi.ID)
+				delete(toBeFound, *wi.ID)
+			}
+			require.Empty(t, toBeFound, "failed to find all work items: %+s", toBeFound)
+		})
+		t.Run("with one child iteration", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s", "child": true}`, fxt.Iterations[1].ID)
+			_, result := test.ShowSearchOK(t, nil, nil, s.controller, &filter, nil, nil, nil, nil, &spaceIDStr)
+			require.NotEmpty(t, result.Data)
+			assert.Len(t, result.Data, 6)
+			toBeFound := id.MapFromSlice(id.Slice{
+				fxt.WorkItems[3].ID,
+				fxt.WorkItems[4].ID,
+				fxt.WorkItems[5].ID,
+				fxt.WorkItems[6].ID,
+				fxt.WorkItems[7].ID,
+				fxt.WorkItems[8].ID,
+			})
+			for _, wi := range result.Data {
+				_, ok := toBeFound[*wi.ID]
+				require.True(t, ok, "unexpected work item found: %s", *wi.ID)
+				delete(toBeFound, *wi.ID)
+			}
+			require.Empty(t, toBeFound, "failed to find all work items: %+s", toBeFound)
+		})
+		t.Run("with one child iteration implicit", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s"}`, fxt.Iterations[1].ID)
+			_, result := test.ShowSearchOK(t, nil, nil, s.controller, &filter, nil, nil, nil, nil, &spaceIDStr)
+			require.NotEmpty(t, result.Data)
+			assert.Len(t, result.Data, 6)
+			toBeFound := id.MapFromSlice(id.Slice{
+				fxt.WorkItems[3].ID,
+				fxt.WorkItems[4].ID,
+				fxt.WorkItems[5].ID,
+				fxt.WorkItems[6].ID,
+				fxt.WorkItems[7].ID,
+				fxt.WorkItems[8].ID,
+			})
+			for _, wi := range result.Data {
+				_, ok := toBeFound[*wi.ID]
+				require.True(t, ok, "unexpected work item found: %s", *wi.ID)
+				delete(toBeFound, *wi.ID)
+			}
+			require.Empty(t, toBeFound, "failed to find all work items: %+s", toBeFound)
+		})
+		t.Run("with two child iteration", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s", "child": true}`, fxt.Iterations[0].ID)
+			_, result := test.ShowSearchOK(t, nil, nil, s.controller, &filter, nil, nil, nil, nil, &spaceIDStr)
+			require.NotEmpty(t, result.Data)
+			assert.Len(t, result.Data, 9)
+			toBeFound := id.MapFromSlice(id.Slice{
+				fxt.WorkItems[0].ID,
+				fxt.WorkItems[1].ID,
+				fxt.WorkItems[2].ID,
+				fxt.WorkItems[3].ID,
+				fxt.WorkItems[4].ID,
+				fxt.WorkItems[5].ID,
+				fxt.WorkItems[6].ID,
+				fxt.WorkItems[7].ID,
+				fxt.WorkItems[8].ID,
+			})
+			for _, wi := range result.Data {
+				_, ok := toBeFound[*wi.ID]
+				require.True(t, ok, "unexpected work item found: %s", *wi.ID)
+				delete(toBeFound, *wi.ID)
+			}
+			require.Empty(t, toBeFound, "failed to find all work items: %+s", toBeFound)
+		})
+
+		t.Run("without child iteration - implicit", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s"}`, fxt.Iterations[2].ID)
+			_, result := test.ShowSearchOK(t, nil, nil, s.controller, &filter, nil, nil, nil, nil, &spaceIDStr)
+			require.NotEmpty(t, result.Data)
+			assert.Len(t, result.Data, 4)
+			toBeFound := id.MapFromSlice(id.Slice{
+				fxt.WorkItems[5].ID,
+				fxt.WorkItems[6].ID,
+				fxt.WorkItems[7].ID,
+				fxt.WorkItems[8].ID,
+			})
+			for _, wi := range result.Data {
+				_, ok := toBeFound[*wi.ID]
+				require.True(t, ok, "unexpected work item found: %s", *wi.ID)
+				delete(toBeFound, *wi.ID)
+			}
+			require.Empty(t, toBeFound, "failed to find all work items: %+s", toBeFound)
+		})
+		t.Run("without child iteration - child false", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s", "child": false}`, fxt.Iterations[2].ID)
+			_, result := test.ShowSearchOK(t, nil, nil, s.controller, &filter, nil, nil, nil, nil, &spaceIDStr)
+			require.NotEmpty(t, result.Data)
+			assert.Len(t, result.Data, 4)
+			toBeFound := id.MapFromSlice(id.Slice{
+				fxt.WorkItems[5].ID,
+				fxt.WorkItems[6].ID,
+				fxt.WorkItems[7].ID,
+				fxt.WorkItems[8].ID,
+			})
+			for _, wi := range result.Data {
+				_, ok := toBeFound[*wi.ID]
+				require.True(t, ok, "unexpected work item found: %s", *wi.ID)
+				delete(toBeFound, *wi.ID)
+			}
+			require.Empty(t, toBeFound, "failed to find all work items: %+s", toBeFound)
+		})
+		t.Run("with one child iteration - child false", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s", "child": false}`, fxt.Iterations[1].ID)
+			_, result := test.ShowSearchOK(t, nil, nil, s.controller, &filter, nil, nil, nil, nil, &spaceIDStr)
+			require.NotEmpty(t, result.Data)
+			assert.Len(t, result.Data, 2)
+			toBeFound := id.MapFromSlice(id.Slice{
+				fxt.WorkItems[3].ID,
+				fxt.WorkItems[4].ID,
+			})
+			for _, wi := range result.Data {
+				_, ok := toBeFound[*wi.ID]
+				require.True(t, ok, "unexpected work item found: %s", *wi.ID)
+				delete(toBeFound, *wi.ID)
+			}
+			require.Empty(t, toBeFound, "failed to find all work items: %+s", toBeFound)
+		})
+		t.Run("with two child iteration - child false", func(t *testing.T) {
+			filter := fmt.Sprintf(`{"iteration": "%s", "child": false}`, fxt.Iterations[0].ID)
+			_, result := test.ShowSearchOK(t, nil, nil, s.controller, &filter, nil, nil, nil, nil, &spaceIDStr)
+			require.NotEmpty(t, result.Data)
+			assert.Len(t, result.Data, 3)
+			toBeFound := id.MapFromSlice(id.Slice{
+				fxt.WorkItems[0].ID,
+				fxt.WorkItems[1].ID,
+				fxt.WorkItems[2].ID,
+			})
+			for _, wi := range result.Data {
+				_, ok := toBeFound[*wi.ID]
+				require.True(t, ok, "unexpected work item found: %s", *wi.ID)
+				delete(toBeFound, *wi.ID)
+			}
+			require.Empty(t, toBeFound, "failed to found all work items: %+s", toBeFound)
+		})
+	})
+
+}
+
 // TestIncludedParents verifies the Included list of parents
 func (s *searchControllerTestSuite) TestIncludedParents() {
 

criteria/expression_child.go

@@ -0,0 +1,20 @@
+package criteria
+
+// ChildExpression represents the child operator
+type ChildExpression struct {
+	binaryExpression
+}
+
+// Ensure ChildExpression implements the Expression interface
+var _ Expression = &ChildExpression{}
+var _ Expression = (*ChildExpression)(nil)
+
+// Accept implements ExpressionVisitor
+func (t *ChildExpression) Accept(visitor ExpressionVisitor) interface{} {
+	return visitor.Child(t)
+}
+
+// Child constructs a ChildExpression
+func Child(left Expression, right Expression) Expression {
+	return reparent(&ChildExpression{binaryExpression{expression{}, left, right}})
+}

criteria/expression_visitor.go

@@ -10,5 +10,6 @@ type ExpressionVisitor interface {
 	Parameter(v *ParameterExpression) interface{}
 	Literal(c *LiteralExpression) interface{}
 	Not(e *NotExpression) interface{}
+	Child(e *ChildExpression) interface{}
 	IsNull(e *IsNullExpression) interface{}
 }

criteria/iterator.go

@@ -46,6 +46,10 @@ func (i *postOrderIterator) Not(exp *NotExpression) interface{} {
 	return i.binary(exp)
 }
 
+func (i *postOrderIterator) Child(exp *ChildExpression) interface{} {
+	return i.binary(exp)
+}
+
 func (i *postOrderIterator) IsNull(exp *IsNullExpression) interface{} {
 	return i.visit(exp)
 }

search/query_language_whitebox_test.go

@@ -232,7 +232,7 @@ func TestParseMap(t *testing.T) {
 		expected := &Query{Name: OR, Children: []Query{
 			{Name: AND, Children: []Query{
 				{Name: "space", Value: &openshiftio},
-				{Name: "area", Value: &area}}},
+				{Name: "area", Value: &area, Child: true}}},
 			{Name: AND, Children: []Query{
 				{Name: "space", Value: &rhel}}},
 		}}
@@ -260,7 +260,7 @@ func TestParseMap(t *testing.T) {
 		expected := &Query{Name: OR, Children: []Query{
 			{Name: AND, Children: []Query{
 				{Name: "space", Value: &openshiftio},
-				{Name: "area", Value: &area}}},
+				{Name: "area", Value: &area, Child: true}}},
 			{Name: AND, Children: []Query{
 				{Name: "space", Value: &rhel, Negate: true}}},
 		}}
@@ -288,7 +288,7 @@ func TestParseMap(t *testing.T) {
 		expected := &Query{Name: OR, Children: []Query{
 			{Name: AND, Children: []Query{
 				{Name: "space", Value: &openshiftio},
-				{Name: "area", Value: &area}}},
+				{Name: "area", Value: &area, Child: true}}},
 			{Name: AND, Children: []Query{
 				{Name: "space", Value: &rhel, Negate: true}}},
 		}}

search/search_repository.go

@@ -266,6 +266,7 @@ func parseSearchString(ctx context.Context, rawSearchString string) (searchKeywo
 }
 
 func parseMap(queryMap map[string]interface{}, q *Query) {
+	childSet := false
 	for key, val := range queryMap {
 		switch concreteVal := val.(type) {
 		case []interface{}:
@@ -275,9 +276,20 @@ func parseMap(queryMap map[string]interface{}, q *Query) {
 			q.Name = key
 			s := string(concreteVal)
 			q.Value = &s
+			if q.Name == "iteration" || q.Name == "area" {
+				if !childSet {
+					q.Child = true
+				}
+			}
 		case bool:
 			s := concreteVal
-			q.Negate = s
+			if key == "negate" {
+				q.Negate = s
+			} else if key == "child" {
+				q.Child = s
+				childSet = true
+			}
+
 		case nil:
 			q.Name = key
 			q.Value = nil
@@ -378,6 +390,8 @@ type Query struct {
 	Children []Query
 	// The Options represent the query options provided by the user.
 	Options *QueryOptions
+	// Consider child iteration/area
+	Child bool
 }
 
 func isOperator(str string) bool {
@@ -436,7 +450,11 @@ func (q Query) generateExpression() (criteria.Expression, error) {
 				if q.Substring {
 					myexpr = append(myexpr, criteria.Substring(left, right))
 				} else {
-					myexpr = append(myexpr, criteria.Equals(left, right))
+					if q.Child {
+						myexpr = append(myexpr, criteria.Child(left, right))
+					} else {
+						myexpr = append(myexpr, criteria.Equals(left, right))
+					}
 				}
 			}
 		} else {
@@ -477,7 +495,11 @@ func (q Query) generateExpression() (criteria.Expression, error) {
 					if child.Substring {
 						myexpr = append(myexpr, criteria.Substring(left, right))
 					} else {
-						myexpr = append(myexpr, criteria.Equals(left, right))
+						if child.Child {
+							myexpr = append(myexpr, criteria.Child(left, right))
+						} else {
+							myexpr = append(myexpr, criteria.Equals(left, right))
+						}
 					}
 				}
 			} else {