// TestListWorkItemType tests if we can find the work item types
// "person" and "animal" in the list of work item types
func (s *workItemTypeSuite) TestListWorkItemType() {
defer cleaner.DeleteCreatedEntities(s.DB)()
// Create the work item type first and try to read it back in
_, witAnimal := s.createWorkItemTypeAnimal()
require.NotNil(s.T(), witAnimal)
_, witPerson := s.createWorkItemTypePerson()
require.NotNil(s.T(), witPerson)
// Fetch a single work item type
// Paging in the format <start>,<limit>"
page := "0,-1"
_, witCollection := test.ListWorkitemtypeOK(s.T(), nil, nil, s.typeCtrl, &page)
require.NotNil(s.T(), witCollection)
require.Nil(s.T(), witCollection.Validate())
// Check the number of found work item types
require.Condition(s.T(), func() bool {
return (len(witCollection) >= 2)
}, "At least two work item types must exist (animal and person), but only %d exist.", len(witCollection))
// Search for the work item types that must exist at minimum
toBeFound := 2
for i := 0; i < len(witCollection) && toBeFound > 0; i++ {
if witCollection[i].Name == "person" || witCollection[i].Name == "animal" {
s.T().Log("Found work item type in collection: ", witCollection[i].Name)
toBeFound--
}
}
require.Exactly(s.T(), 0, toBeFound, "Not all required work item types (animal and person) where found.")
}
// TestListWorkItemLinkTypeOK tests if we can find the work item link types
// "test-bug-blocker" and "test-related" in the list of work item link types
func (s *workItemLinkTypeSuite) TestListWorkItemLinkTypeOK() {
bugBlockerPayload := s.createDemoLinkType("test-bug-blocker")
_, bugBlockerType := test.CreateWorkItemLinkTypeCreated(s.T(), nil, nil, s.linkTypeCtrl, bugBlockerPayload)
require.NotNil(s.T(), bugBlockerType)
relatedPayload := CreateWorkItemLinkType("test-related", workitem.SystemBug, workitem.SystemBug, bugBlockerType.Data.Relationships.LinkCategory.Data.ID)
_, relatedType := test.CreateWorkItemLinkTypeCreated(s.T(), nil, nil, s.linkTypeCtrl, relatedPayload)
require.NotNil(s.T(), relatedType)
// Fetch a single work item link type
_, linkTypeCollection := test.ListWorkItemLinkTypeOK(s.T(), nil, nil, s.linkTypeCtrl)
require.NotNil(s.T(), linkTypeCollection)
require.Nil(s.T(), linkTypeCollection.Validate())
// Check the number of found work item link types
require.NotNil(s.T(), linkTypeCollection.Data)
require.Condition(s.T(), func() bool {
return (len(linkTypeCollection.Data) >= 2)
}, "At least two work item link types must exist (bug-blocker and related), but only %d exist.", len(linkTypeCollection.Data))
// Search for the work item types that must exist at minimum
toBeFound := 2
for i := 0; i < len(linkTypeCollection.Data) && toBeFound > 0; i++ {
if *linkTypeCollection.Data[i].Attributes.Name == "test-bug-blocker" || *linkTypeCollection.Data[i].Attributes.Name == "test-related" {
s.T().Log("Found work item link type in collection: ", *linkTypeCollection.Data[i].Attributes.Name)
toBeFound--
}
}
require.Exactly(s.T(), 0, toBeFound, "Not all required work item link types (bug-blocker and related) where found.")
// Check that the link categories are included in the response in the "included" array
require.Len(s.T(), linkTypeCollection.Included, 1, "The work item link type should include it's work item link category.")
categoryData, ok := linkTypeCollection.Included[0].(*app.WorkItemLinkCategoryData)
require.True(s.T(), ok)
require.Equal(s.T(), "test-user", *categoryData.Attributes.Name, "The work item link type's category should have the name 'test-user'.")
}
func (s *workItemLinkSuite) TestCreateAndDeleteWorkItemLink() {
createPayload := CreateWorkItemLink(s.bug1ID, s.bug2ID, s.bugBlockerLinkTypeID)
_, workItemLink := test.CreateWorkItemLinkCreated(s.T(), nil, nil, s.workItemLinkCtrl, createPayload)
require.NotNil(s.T(), workItemLink)
// Test if related resources are included in the response
toBeFound := 2
for i := 0; i < len(workItemLink.Included) && toBeFound > 0; i++ {
switch v := workItemLink.Included[i].(type) {
case *app.WorkItemLinkCategoryData:
if *v.ID == s.userLinkCategoryID {
s.T().Log("Found work item link category in \"included\" element: ", *v.ID)
toBeFound--
}
case *app.WorkItemLinkTypeData:
if *v.ID == s.bugBlockerLinkTypeID {
s.T().Log("Found work item link type in \"included\" element: ", *v.ID)
toBeFound--
}
// TODO(kwk): Check for source WI (once #559 is merged)
// TODO(kwk): Check for target WI (once #559 is merged)
// case *app.WorkItemData:
// TODO(kwk): Check for WITs (once #559 is merged)
// case *app.WorkItemTypeData:
default:
s.T().Errorf("Object of unknown type included in work item link list response: %T", workItemLink.Included[i])
}
}
require.Exactly(s.T(), 0, toBeFound, "Not all required included elements where found.")
_ = test.DeleteWorkItemLinkOK(s.T(), nil, nil, s.workItemLinkCtrl, *workItemLink.Data.ID)
}
// TestListWorkItemLinkCategoryOK tests if we can find the work item link categories
// "test-system" and "test-user" in the list of work item link categories
func (s *workItemLinkCategorySuite) TestListWorkItemLinkCategoryOK() {
_, linkCatSystem := s.createWorkItemLinkCategorySystem()
require.NotNil(s.T(), linkCatSystem)
_, linkCatUser := s.createWorkItemLinkCategoryUser()
require.NotNil(s.T(), linkCatUser)
// Fetch a single work item link category
_, linkCatCollection := test.ListWorkItemLinkCategoryOK(s.T(), nil, nil, s.linkCatCtrl)
require.NotNil(s.T(), linkCatCollection)
require.Nil(s.T(), linkCatCollection.Validate())
// Check the number of found work item link categories
require.NotNil(s.T(), linkCatCollection.Data)
require.Condition(s.T(), func() bool {
return (len(linkCatCollection.Data) >= 2)
}, "At least two work item link categories must exist (system and user), but only %d exist.", len(linkCatCollection.Data))
// Search for the work item types that must exist at minimum
toBeFound := 2
for i := 0; i < len(linkCatCollection.Data) && toBeFound > 0; i++ {
if *linkCatCollection.Data[i].Attributes.Name == "test-system" || *linkCatCollection.Data[i].Attributes.Name == "test-user" {
s.T().Log("Found work item link category in collection: ", *linkCatCollection.Data[i].Attributes.Name)
toBeFound--
}
}
require.Exactly(s.T(), 0, toBeFound, "Not all required work item link categories (system and user) where found.")
}
// validateSomeLinks validates that workItemLink1 and workItemLink2 are in the
// linkCollection and that all resources are included
func (s *workItemLinkSuite) validateSomeLinks(linkCollection *app.WorkItemLinkList, workItemLink1, workItemLink2 *app.WorkItemLinkSingle) {
require.NotNil(s.T(), linkCollection)
require.Nil(s.T(), linkCollection.Validate())
// Check the number of found work item links
require.NotNil(s.T(), linkCollection.Data)
require.Condition(s.T(), func() bool {
return (len(linkCollection.Data) >= 2)
}, "At least two work item links must exist (%s and %s), but only %d exist.", *workItemLink1.Data.ID, *workItemLink2.Data.ID, len(linkCollection.Data))
// Search for the work item types that must exist at minimum
toBeFound := 2
for i := 0; i < len(linkCollection.Data) && toBeFound > 0; i++ {
actualLink := *linkCollection.Data[i]
var expectedLink *app.WorkItemLinkData
switch *actualLink.ID {
case *workItemLink1.Data.ID:
expectedLink = workItemLink1.Data
case *workItemLink2.Data.ID:
expectedLink = workItemLink2.Data
}
if expectedLink != nil {
s.T().Log("Found work item link in collection: ", *expectedLink.ID)
toBeFound--
// Check JSONAPI "type"" field (should be "workitemlinks")
require.Equal(s.T(), expectedLink.Type, actualLink.Type)
// Check work item link type
require.Equal(s.T(), expectedLink.Relationships.LinkType.Data.ID, actualLink.Relationships.LinkType.Data.ID)
require.Equal(s.T(), expectedLink.Relationships.LinkType.Data.Type, actualLink.Relationships.LinkType.Data.Type)
// Check source type
require.Equal(s.T(), expectedLink.Relationships.Source.Data.ID, actualLink.Relationships.Source.Data.ID, "Wrong source ID for the link")
require.Equal(s.T(), expectedLink.Relationships.Source.Data.Type, actualLink.Relationships.Source.Data.Type, "Wrong source JSONAPI type for the link")
// Check target type
require.Equal(s.T(), expectedLink.Relationships.Target.Data.ID, actualLink.Relationships.Target.Data.ID, "Wrong target ID for the link")
require.Equal(s.T(), expectedLink.Relationships.Target.Data.Type, actualLink.Relationships.Target.Data.Type, "Wrong target JSONAPI type for the link")
}
}
require.Exactly(s.T(), 0, toBeFound, "Not all required work item links (%s and %s) where found.", *workItemLink1.Data.ID, *workItemLink2.Data.ID)
toBeFound = 5 // 1 x link category, 1 x link type, 3 x work items
for i := 0; i < len(linkCollection.Included) && toBeFound > 0; i++ {
switch v := linkCollection.Included[i].(type) {
case *app.WorkItemLinkCategoryData:
if *v.ID == s.userLinkCategoryID {
s.T().Log("Found work item link category in \"included\" element: ", *v.ID)
toBeFound--
}
case *app.WorkItemLinkTypeData:
if *v.ID == s.bugBlockerLinkTypeID {
s.T().Log("Found work item link type in \"included\" element: ", *v.ID)
toBeFound--
}
case *app.WorkItem2:
wid, err := strconv.ParseUint(*v.ID, 10, 64)
require.Nil(s.T(), err)
if wid == s.bug1ID || wid == s.bug2ID || wid == s.bug3ID {
s.T().Log("Found work item in \"included\" element: ", *v.ID)
toBeFound--
}
// TODO(kwk): Check for WITs (once #559 is merged)
// case *app.WorkItemTypeData:
default:
s.T().Errorf("Object of unknown type included in work item link list response: %T", linkCollection.Included[i])
}
}
require.Exactly(s.T(), 0, toBeFound, "Not all required included elements where found.")
}