func (test *TestCommentRepository) TestDeleteComment() {
t := test.T()
resource.Require(t, resource.Database)
defer cleaner.DeleteCreatedEntities(test.DB)()
repo := comment.NewCommentRepository(test.DB)
parentID := "AA"
c := &comment.Comment{
ParentID: parentID,
Body: "Test AA",
CreatedBy: uuid.NewV4(),
ID: uuid.NewV4(),
}
repo.Create(context.Background(), c)
if c.ID == uuid.Nil {
t.Errorf("Comment was not created, ID nil")
}
c.Body = "Test AB"
err := repo.Delete(context.Background(), c.ID)
if err != nil {
t.Error("Failed to Delete", err.Error())
}
}
func (s *trackerQueryRepoBlackBoxTest) TestFailSaveZeroID() {
defer cleaner.DeleteCreatedEntities(s.DB)()
// Create at least 1 item to avoid RowsEffectedCheck
tr, err := s.trRepo.Create(
context.Background(),
"http://api.github.com",
remoteworkitem.ProviderGithub)
if err != nil {
s.T().Error("Could not create tracker", err)
}
tq, err := s.repo.Create(
context.Background(),
"project = ARQ AND text ~ 'arquillian'",
"15 * * * * *",
tr.ID)
if err != nil {
s.T().Error("Could not create tracker query", err)
}
tq.ID = "0"
_, err = s.repo.Save(context.Background(), *tq)
require.IsType(s.T(), remoteworkitem.NotFoundError{}, err)
}
func TestSpacesSearchOK(t *testing.T) {
resource.Require(t, resource.Database)
tester := TestSearchSpaces{}
tester.db = gormapplication.NewGormDB(DB)
tester.clean = cleaner.DeleteCreatedEntities(DB)
idents, err := tester.createTestData()
if err != nil {
t.Fatal(err)
}
defer tester.cleanTestData()
tests := []okScenario{
{"With uppercase fullname query", args{offset("0"), limit(10), "TEST_AB"}, expects{totalCount(1)}},
{"With lowercase fullname query", args{offset("0"), limit(10), "TEST_AB"}, expects{totalCount(1)}},
{"With uppercase description query", args{offset("0"), limit(10), "DESCRIPTION FOR TEST_AB"}, expects{totalCount(1)}},
{"With lowercase description query", args{offset("0"), limit(10), "description for test_ab"}, expects{totalCount(1)}},
{"with special chars", args{offset("0"), limit(10), "&:\n!#%?*"}, expects{totalCount(0)}},
{"with * to list all", args{offset("0"), limit(10), "*"}, expects{totalCountAtLeast(len(idents))}},
{"with multi page", args{offset("0"), limit(10), "TEST"}, expects{hasLinks("Next")}},
{"with last page", args{offset(strconv.Itoa(len(idents) - 1)), limit(10), "TEST"}, expects{hasNoLinks("Next"), hasLinks("Prev")}},
{"with different values", args{offset("0"), limit(10), "TEST"}, expects{differentValues()}},
}
service := goa.New("TestSpacesSearch-Service")
controller := NewSearchController(service, tester.db)
for _, tt := range tests {
_, result := test.SpacesSearchOK(t, context.Background(), service, controller, tt.args.pageLimit, tt.args.pageOffset, tt.args.q)
for _, expect := range tt.expects {
expect(t, tt, result)
}
}
}
func TestGetTrackerQuery(t *testing.T) {
resource.Require(t, resource.Database)
defer cleaner.DeleteCreatedEntities(DB)()
controller := TrackerController{Controller: nil, db: gormapplication.NewGormDB(DB), scheduler: RwiScheduler}
payload := app.CreateTrackerAlternatePayload{
URL: "http://api.github.com",
Type: "github",
}
_, result := test.CreateTrackerCreated(t, nil, nil, &controller, &payload)
tqController := TrackerqueryController{Controller: nil, db: gormapplication.NewGormDB(DB), scheduler: RwiScheduler}
tqpayload := app.CreateTrackerQueryAlternatePayload{
Query: "is:open is:issue user:arquillian author:aslakknutsen",
Schedule: "15 * * * * *",
TrackerID: result.ID,
}
fmt.Printf("tq payload %#v", tqpayload)
_, tqresult := test.CreateTrackerqueryCreated(t, nil, nil, &tqController, &tqpayload)
test.ShowTrackerqueryOK(t, nil, nil, &tqController, tqresult.ID)
_, tqr := test.ShowTrackerqueryOK(t, nil, nil, &tqController, tqresult.ID)
if tqr == nil {
t.Fatalf("Tracker Query '%s' not present", tqresult.ID)
}
if tqr.ID != tqresult.ID {
t.Errorf("Id should be %s, but is %s", tqresult.ID, tqr.ID)
}
}
// This test ensures that List does not return NIL items.
func TestTrackerQueryListItemsNotNil(t *testing.T) {
resource.Require(t, resource.Database)
defer cleaner.DeleteCreatedEntities(DB)()
controller := TrackerController{Controller: nil, db: gormapplication.NewGormDB(DB), scheduler: RwiScheduler}
payload := app.CreateTrackerAlternatePayload{
URL: "http://api.github.com",
Type: "github",
}
_, result := test.CreateTrackerCreated(t, nil, nil, &controller, &payload)
t.Log(result.ID)
tqController := TrackerqueryController{Controller: nil, db: gormapplication.NewGormDB(DB), scheduler: RwiScheduler}
tqpayload := app.CreateTrackerQueryAlternatePayload{
Query: "is:open is:issue user:arquillian author:aslakknutsen",
Schedule: "15 * * * * *",
TrackerID: result.ID,
}
test.CreateTrackerqueryCreated(t, nil, nil, &tqController, &tqpayload)
test.CreateTrackerqueryCreated(t, nil, nil, &tqController, &tqpayload)
_, list := test.ListTrackerqueryOK(t, nil, nil, &tqController)
for _, tq := range list {
if tq == nil {
t.Error("Returned Tracker Query found nil")
}
}
}
func TestUnregisteredURLWithPort(t *testing.T) {
resource.Require(t, resource.Database)
defer cleaner.DeleteCreatedEntities(DB)()
service := getServiceAsUser()
wiRepo := workitem.NewWorkItemRepository(DB)
description := "Related to http://some-other-domain:8080/different-path/154687364529310/ok issue"
expectedDescription := rendering.NewMarkupContentFromLegacy(description)
_, err := wiRepo.Create(
context.Background(),
workitem.SystemBug,
map[string]interface{}{
workitem.SystemTitle: "specialwordforsearch_new",
workitem.SystemDescription: expectedDescription,
workitem.SystemCreator: "baijum",
workitem.SystemState: workitem.SystemStateClosed,
},
"")
require.Nil(t, err)
controller := NewSearchController(service, gormapplication.NewGormDB(DB))
q := `http://some-other-domain:8080/different-path/`
_, sr := test.ShowSearchOK(t, nil, nil, controller, nil, nil, q)
require.NotEmpty(t, sr.Data)
r := sr.Data[0]
assert.Equal(t, description, r.Attributes[workitem.SystemDescription])
}
func TestGetTracker(t *testing.T) {
resource.Require(t, resource.Database)
defer cleaner.DeleteCreatedEntities(DB)()
controller := TrackerController{Controller: nil, db: gormapplication.NewGormDB(DB), scheduler: RwiScheduler}
payload := app.CreateTrackerAlternatePayload{
URL: "http://issues.jboss.com",
Type: "jira",
}
_, result := test.CreateTrackerCreated(t, nil, nil, &controller, &payload)
test.ShowTrackerOK(t, nil, nil, &controller, result.ID)
_, tr := test.ShowTrackerOK(t, nil, nil, &controller, result.ID)
if tr == nil {
t.Fatalf("Tracker '%s' not present", result.ID)
}
if tr.ID != result.ID {
t.Errorf("Id should be %s, but is %s", result.ID, tr.ID)
}
payload2 := app.UpdateTrackerAlternatePayload{
URL: tr.URL,
Type: tr.Type,
}
_, updated := test.UpdateTrackerOK(t, nil, nil, &controller, tr.ID, &payload2)
if updated.ID != result.ID {
t.Errorf("Id has changed from %s to %s", result.ID, updated.ID)
}
if updated.URL != result.URL {
t.Errorf("URL has changed from %s to %s", result.URL, updated.URL)
}
if updated.Type != result.Type {
t.Errorf("Type has changed has from %s to %s", result.Type, updated.Type)
}
}
func TestSearchURLWithoutPort(t *testing.T) {
resource.Require(t, resource.Database)
defer cleaner.DeleteCreatedEntities(DB)()
service := getServiceAsUser()
wiRepo := workitem.NewWorkItemRepository(DB)
description := "This issue is related to http://localhost/detail/876394"
expectedDescription := rendering.NewMarkupContentFromLegacy(description)
_, err := wiRepo.Create(
context.Background(),
workitem.SystemBug,
map[string]interface{}{
workitem.SystemTitle: "specialwordforsearch_without_port",
workitem.SystemDescription: expectedDescription,
workitem.SystemCreator: "baijum",
workitem.SystemState: workitem.SystemStateClosed,
},
"")
require.Nil(t, err)
controller := NewSearchController(service, gormapplication.NewGormDB(DB))
q := `"http://localhost/detail/876394"`
_, sr := test.ShowSearchOK(t, nil, nil, controller, nil, nil, q)
require.NotEmpty(t, sr.Data)
r := sr.Data[0]
assert.Equal(t, description, r.Attributes[workitem.SystemDescription])
}
func TestUnwantedCharactersRelatedToSearchLogic(t *testing.T) {
resource.Require(t, resource.Database)
defer cleaner.DeleteCreatedEntities(DB)()
service := getServiceAsUser()
wiRepo := workitem.NewWorkItemRepository(DB)
expectedDescription := rendering.NewMarkupContentFromLegacy("Related to http://example-domain:8080/different-path/ok issue")
_, err := wiRepo.Create(
context.Background(),
workitem.SystemBug,
map[string]interface{}{
workitem.SystemTitle: "specialwordforsearch_new",
workitem.SystemDescription: expectedDescription,
workitem.SystemCreator: "baijum",
workitem.SystemState: workitem.SystemStateClosed,
},
"")
require.Nil(t, err)
controller := NewSearchController(service, gormapplication.NewGormDB(DB))
// add url: in the query, that is not expected by the code hence need to make sure it gives expected result.
q := `http://url:some-random-other-domain:8080/different-path/`
_, sr := test.ShowSearchOK(t, nil, nil, controller, nil, nil, q)
require.NotNil(t, sr.Data)
assert.Empty(t, sr.Data)
}
func TestSearch(t *testing.T) {
resource.Require(t, resource.Database)
defer cleaner.DeleteCreatedEntities(DB)()
service := getServiceAsUser()
wiRepo := workitem.NewWorkItemRepository(DB)
_, err := wiRepo.Create(
context.Background(),
workitem.SystemBug,
map[string]interface{}{
workitem.SystemTitle: "specialwordforsearch",
workitem.SystemDescription: nil,
workitem.SystemCreator: "baijum",
workitem.SystemState: workitem.SystemStateClosed,
},
"")
require.Nil(t, err)
controller := NewSearchController(service, gormapplication.NewGormDB(DB))
q := "specialwordforsearch"
_, sr := test.ShowSearchOK(t, nil, nil, controller, nil, nil, q)
require.NotEmpty(t, sr.Data)
r := sr.Data[0]
assert.Equal(t, "specialwordforsearch", r.Attributes[workitem.SystemTitle])
}
func TestSearchPagination(t *testing.T) {
resource.Require(t, resource.Database)
defer cleaner.DeleteCreatedEntities(DB)()
service := getServiceAsUser()
wiRepo := workitem.NewWorkItemRepository(DB)
_, err := wiRepo.Create(
context.Background(),
workitem.SystemBug,
map[string]interface{}{
workitem.SystemTitle: "specialwordforsearch2",
workitem.SystemDescription: nil,
workitem.SystemCreator: "baijum",
workitem.SystemState: workitem.SystemStateClosed,
},
"")
require.Nil(t, err)
controller := NewSearchController(service, gormapplication.NewGormDB(DB))
q := "specialwordforsearch2"
_, sr := test.ShowSearchOK(t, nil, nil, controller, nil, nil, q)
// defaults in paging.go is 'pageSizeDefault = 20'
assert.Equal(t, "http:///api/search?page[offset]=0&page[limit]=20&q=specialwordforsearch2", *sr.Links.First)
assert.Equal(t, "http:///api/search?page[offset]=0&page[limit]=20&q=specialwordforsearch2", *sr.Links.Last)
require.NotEmpty(t, sr.Data)
r := sr.Data[0]
assert.Equal(t, "specialwordforsearch2", r.Attributes[workitem.SystemTitle])
}
// 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.")
}
func doWithTrackerRepository(t *testing.T, todo func(repo application.TrackerRepository)) {
doWithTransaction(t, func(db *gorm.DB) {
defer cleaner.DeleteCreatedEntities(db)()
trackerRepo := NewTrackerRepository(db)
todo(trackerRepo)
})
}
// TestListSourceAndTargetLinkTypesNotFound tests that a NotFound error is
// returned when you query a non existing WIT.
func (s *workItemTypeSuite) TestListSourceAndTargetLinkTypesNotFound() {
defer cleaner.DeleteCreatedEntities(s.DB)()
_, jerrors := test.ListSourceLinkTypesWorkitemtypeNotFound(s.T(), nil, nil, s.typeCtrl, "not-existing-WIT")
require.NotNil(s.T(), jerrors)
_, jerrors = test.ListTargetLinkTypesWorkitemtypeNotFound(s.T(), nil, nil, s.typeCtrl, "not-existing-WIT")
require.NotNil(s.T(), jerrors)
}
func TestConvertExistingWorkItem(t *testing.T) {
resource.Require(t, resource.Database)
// Setting up the dependent tracker query and tracker data in the Database
tr := Tracker{URL: "https://api.github.com/", Type: ProviderGithub}
db = db.Create(&tr)
require.Nil(t, db.Error)
tq := TrackerQuery{Query: "some random query", Schedule: "0 0 0 * * *", TrackerID: tr.ID}
db = db.Create(&tq)
require.Nil(t, db.Error)
defer cleaner.DeleteCreatedEntities(db)()
t.Log("Created Tracker Query and Tracker")
models.Transactional(db, func(tx *gorm.DB) error {
t.Log("Adding a work item which wasn't present.")
remoteItemData := TrackerItemContent{
Content: []byte(`{"title":"linking","url":"http://github.com/sbose/api/testonly/1","state":"closed","body":"body of issue","user.login":"******","assignee.login":"******"}`),
ID: "http://github.com/sbose/api/testonly/1",
}
workItem, err := convert(tx, int(tq.ID), remoteItemData, ProviderGithub)
assert.Nil(t, err)
assert.Equal(t, "linking", workItem.Fields[workitem.SystemTitle])
assert.Equal(t, "sbose78", workItem.Fields[workitem.SystemCreator])
assert.Equal(t, "pranav", workItem.Fields[workitem.SystemAssignees].([]interface{})[0])
assert.Equal(t, "closed", workItem.Fields[workitem.SystemState])
return errors.WithStack(err)
})
t.Log("Updating the existing work item when it's reimported.")
models.Transactional(db, func(tx *gorm.DB) error {
remoteItemDataUpdated := TrackerItemContent{
Content: []byte(`{"title":"linking-updated","url":"http://github.com/api/testonly/1","state":"closed","body":"body of issue","user.login":"******","assignee.login":"******"}`),
ID: "http://github.com/sbose/api/testonly/1",
}
workItemUpdated, err := convert(tx, int(tq.ID), remoteItemDataUpdated, ProviderGithub)
assert.Nil(t, err)
assert.Equal(t, "linking-updated", workItemUpdated.Fields[workitem.SystemTitle])
assert.Equal(t, "sbose78", workItemUpdated.Fields[workitem.SystemCreator])
assert.Equal(t, "pranav", workItemUpdated.Fields[workitem.SystemAssignees].([]interface{})[0])
assert.Equal(t, "closed", workItemUpdated.Fields[workitem.SystemState])
wir := workitem.NewWorkItemRepository(tx)
wir.Delete(context.Background(), workItemUpdated.ID)
return errors.WithStack(err)
})
}
// TestCreateWorkItemType tests if we can create two work item types: "animal" and "person"
func (s *workItemTypeSuite) TestCreateWorkItemType() {
defer cleaner.DeleteCreatedEntities(s.DB)()
_, wit := s.createWorkItemTypeAnimal()
require.NotNil(s.T(), wit)
require.Equal(s.T(), "animal", wit.Name)
_, wit = s.createWorkItemTypePerson()
require.NotNil(s.T(), wit)
require.Equal(s.T(), "person", wit.Name)
}
// TestShowWorkItemType tests if we can fetch the work item type "animal".
func (s *workItemTypeSuite) TestShowWorkItemType() {
defer cleaner.DeleteCreatedEntities(s.DB)()
// Create the work item type first and try to read it back in
_, wit := s.createWorkItemTypeAnimal()
require.NotNil(s.T(), wit)
_, wit2 := test.ShowWorkitemtypeOK(s.T(), nil, nil, s.typeCtrl, wit.Name)
require.NotNil(s.T(), wit2)
require.EqualValues(s.T(), wit, wit2)
}
func TestListIdentities(t *testing.T) {
resource.Require(t, resource.Database)
defer cleaner.DeleteCreatedEntities(DB)()
service := goa.New("Test-Identities")
app := gormapplication.NewGormDB(DB)
identityController := NewIdentityController(service, app)
_, ic := test.ListIdentityOK(t, service.Context, service, identityController)
require.NotNil(t, ic)
numberOfCurrentIdent := len(ic.Data)
ctx := context.Background()
identityRepo := app.Identities()
identity := account.Identity{
Username: "******",
Provider: "test-idp",
ID: uuid.NewV4(),
}
err := identityRepo.Create(ctx, &identity)
if err != nil {
t.Fatal(err)
}
_, ic2 := test.ListIdentityOK(t, service.Context, service, identityController)
require.NotNil(t, ic2)
assert.Equal(t, numberOfCurrentIdent+1, len(ic2.Data))
assertIdent(t, identity, findIdent(identity.ID, ic2.Data))
identity2 := account.Identity{
Username: "******",
Provider: "test-idp",
ID: uuid.NewV4(),
}
err = identityRepo.Create(ctx, &identity2)
if err != nil {
t.Fatal(err)
}
_, ic3 := test.ListIdentityOK(t, service.Context, service, identityController)
require.NotNil(t, ic3)
assert.Equal(t, numberOfCurrentIdent+2, len(ic3.Data))
assertIdent(t, identity, findIdent(identity.ID, ic3.Data))
assertIdent(t, identity2, findIdent(identity2.ID, ic3.Data))
}
// TestGetCountsPerIteration makes sure that the query being executed is correctly returning
// the counts of work items
func (s *workItemRepoBlackBoxTest) TestGetCountsPerIteration() {
defer cleaner.DeleteCreatedEntities(s.DB)()
// create seed data
spaceRepo := space.NewRepository(s.DB)
spaceInstance := space.Space{
Name: "Testing space",
}
spaceRepo.Create(context.Background(), &spaceInstance)
fmt.Println("space id = ", spaceInstance.ID)
assert.NotEqual(s.T(), uuid.UUID{}, spaceInstance.ID)
iterationRepo := iteration.NewIterationRepository(s.DB)
iteration1 := iteration.Iteration{
Name: "Sprint 1",
SpaceID: spaceInstance.ID,
}
iterationRepo.Create(context.Background(), &iteration1)
fmt.Println("iteration1 id = ", iteration1.ID)
assert.NotEqual(s.T(), uuid.UUID{}, iteration1.ID)
iteration2 := iteration.Iteration{
Name: "Sprint 2",
SpaceID: spaceInstance.ID,
}
iterationRepo.Create(context.Background(), &iteration2)
fmt.Println("iteration2 id = ", iteration2.ID)
assert.NotEqual(s.T(), uuid.UUID{}, iteration2.ID)
for i := 0; i < 3; i++ {
s.repo.Create(
context.Background(), workitem.SystemBug,
map[string]interface{}{
workitem.SystemTitle: fmt.Sprintf("New issue #%d", i),
workitem.SystemState: workitem.SystemStateNew,
workitem.SystemIteration: iteration1.ID.String(),
}, "xx")
}
for i := 0; i < 2; i++ {
s.repo.Create(
context.Background(), workitem.SystemBug,
map[string]interface{}{
workitem.SystemTitle: fmt.Sprintf("Closed issue #%d", i),
workitem.SystemState: workitem.SystemStateClosed,
workitem.SystemIteration: iteration1.ID.String(),
}, "xx")
}
countsMap, _ := s.repo.GetCountsPerIteration(context.Background(), spaceInstance.ID)
assert.Len(s.T(), countsMap, 1)
require.Contains(s.T(), countsMap, iteration1.ID.String())
assert.Equal(s.T(), 5, countsMap[iteration1.ID.String()].Total)
assert.Equal(s.T(), 2, countsMap[iteration1.ID.String()].Closed)
}
func TestCreateTracker(t *testing.T) {
resource.Require(t, resource.Database)
defer cleaner.DeleteCreatedEntities(DB)()
controller := TrackerController{Controller: nil, db: gormapplication.NewGormDB(DB), scheduler: RwiScheduler}
payload := app.CreateTrackerAlternatePayload{
URL: "http://issues.jboss.com",
Type: "jira",
}
_, created := test.CreateTrackerCreated(t, nil, nil, &controller, &payload)
if created.ID == "" {
t.Error("no id")
}
}
func (s *workItemRepoBlackBoxTest) TestCreateWorkItemWithDescriptionMarkup() {
defer cleaner.DeleteCreatedEntities(s.DB)()
wi, err := s.repo.Create(
context.Background(), workitem.SystemBug,
map[string]interface{}{
workitem.SystemTitle: "Title",
workitem.SystemDescription: rendering.NewMarkupContent("Description", rendering.SystemMarkupMarkdown),
workitem.SystemState: workitem.SystemStateNew,
}, "xx")
require.Nil(s.T(), err, "Could not create workitem")
wi, err = s.repo.Load(context.Background(), wi.ID)
require.Nil(s.T(), err)
// app.WorkItem does not contain the markup associated with the description (yet)
assert.Equal(s.T(), rendering.NewMarkupContent("Description", rendering.SystemMarkupMarkdown), wi.Fields[workitem.SystemDescription])
}
func (s *workItemRepoBlackBoxTest) TestFaiLoadZeroID() {
defer cleaner.DeleteCreatedEntities(s.DB)()
// Create at least 1 item to avoid RowsEffectedCheck
_, err := s.repo.Create(
context.Background(), workitem.SystemBug,
map[string]interface{}{
workitem.SystemTitle: "Title",
workitem.SystemState: workitem.SystemStateNew,
}, "xx")
require.Nil(s.T(), err, "Could not create workitem")
_, err = s.repo.Load(context.Background(), "0")
require.IsType(s.T(), errors.NotFoundError{}, errs.Cause(err))
}
// This test ensures that ID returned by Show is valid.
// refer : https://github.com/almighty/almighty-core/issues/189
func TestCreateTrackerValidId(t *testing.T) {
resource.Require(t, resource.Database)
defer cleaner.DeleteCreatedEntities(DB)()
controller := TrackerController{Controller: nil, db: gormapplication.NewGormDB(DB), scheduler: RwiScheduler}
payload := app.CreateTrackerAlternatePayload{
URL: "http://issues.jboss.com",
Type: "jira",
}
_, tracker := test.CreateTrackerCreated(t, nil, nil, &controller, &payload)
_, created := test.ShowTrackerOK(t, nil, nil, &controller, tracker.ID)
if created != nil && created.ID != tracker.ID {
t.Error("Failed because fetched Tracker not same as requested. Found: ", tracker.ID, " Expected, ", created.ID)
}
}
func (s *trackerRepoBlackBoxTest) TestFaiLoadZeroID() {
defer cleaner.DeleteCreatedEntities(s.DB)()
// Create at least 1 item to avoid RowsEffectedCheck
_, err := s.repo.Create(
context.Background(),
"http://api.github.com",
remoteworkitem.ProviderGithub)
if err != nil {
s.T().Error("Could not create tracker", err)
}
_, err = s.repo.Load(context.Background(), "0")
require.IsType(s.T(), remoteworkitem.NotFoundError{}, err)
}
// TestListSourceAndTargetLinkTypesEmpty tests that no link type is returned for
// WITs that don't have link types associated to them
func (s *workItemTypeSuite) TestListSourceAndTargetLinkTypesEmpty() {
defer cleaner.DeleteCreatedEntities(s.DB)()
_, witPerson := s.createWorkItemTypePerson()
require.NotNil(s.T(), witPerson)
_, wiltCollection := test.ListSourceLinkTypesWorkitemtypeOK(s.T(), nil, nil, s.typeCtrl, "person")
require.NotNil(s.T(), wiltCollection)
require.Nil(s.T(), wiltCollection.Validate())
require.Len(s.T(), wiltCollection.Data, 0)
_, wiltCollection = test.ListTargetLinkTypesWorkitemtypeOK(s.T(), nil, nil, s.typeCtrl, "person")
require.NotNil(s.T(), wiltCollection)
require.Nil(s.T(), wiltCollection.Validate())
require.Len(s.T(), wiltCollection.Data, 0)
}
func (s *workItemRepoBlackBoxTest) TestSaveAssignees() {
defer cleaner.DeleteCreatedEntities(s.DB)()
wi, err := s.repo.Create(
context.Background(), workitem.SystemBug,
map[string]interface{}{
workitem.SystemTitle: "Title",
workitem.SystemState: workitem.SystemStateNew,
workitem.SystemAssignees: []string{"A", "B"},
}, "xx")
require.Nil(s.T(), err, "Could not create workitem")
wi, err = s.repo.Load(context.Background(), wi.ID)
require.Nil(s.T(), err)
assert.Equal(s.T(), "A", wi.Fields[workitem.SystemAssignees].([]interface{})[0])
}
// TestAutoRegisterHostURL checks if client's host is neatly registered as a KnwonURL or not
// Uses helper functions verifySearchByKnownURLs, searchByURL, getWICreatePayload
func TestAutoRegisterHostURL(t *testing.T) {
resource.Require(t, resource.Database)
defer cleaner.DeleteCreatedEntities(DB)()
service := getServiceAsUser()
wiCtrl := NewWorkitemController(service, gormapplication.NewGormDB(DB))
// create a WI, search by `list view URL` of newly created item
newWI := getWICreatePayload()
_, wi := test.CreateWorkitemCreated(t, service.Context, service, wiCtrl, newWI)
require.NotNil(t, wi)
customHost := "own.domain.one"
queryString := fmt.Sprintf("http://%s/work-item/list/detail/%s", customHost, *wi.Data.ID)
verifySearchByKnownURLs(t, wi, customHost, queryString)
// Search by `board view URL` of newly created item
customHost2 := "own.domain.two"
queryString2 := fmt.Sprintf("http://%s/work-item/board/detail/%s", customHost2, *wi.Data.ID)
verifySearchByKnownURLs(t, wi, customHost2, queryString2)
}
func (s *workItemRepoBlackBoxTest) TestSaveForUnchangedCreatedDate() {
defer cleaner.DeleteCreatedEntities(s.DB)()
wi, err := s.repo.Create(
context.Background(), workitem.SystemBug,
map[string]interface{}{
workitem.SystemTitle: "Title",
workitem.SystemState: workitem.SystemStateNew,
}, "xx")
require.Nil(s.T(), err, "Could not create workitem")
wi, err = s.repo.Load(context.Background(), wi.ID)
require.Nil(s.T(), err)
wiNew, err := s.repo.Save(context.Background(), *wi)
require.Nil(s.T(), err)
assert.Equal(s.T(), wi.Fields[workitem.SystemCreatedAt], wiNew.Fields[workitem.SystemCreatedAt])
}
// TestTypeChangeIsNotProhibitedOnDBLayer tests that you can change the type of
// a work item. NOTE: This functionality only works on the DB layer and is not
// exposed to REST.
func (s *workItemRepoBlackBoxTest) TestTypeChangeIsNotProhibitedOnDBLayer() {
defer cleaner.DeleteCreatedEntities(s.DB)()
// Create at least 1 item to avoid RowsAffectedCheck
wi, err := s.repo.Create(
context.Background(), "bug",
map[string]interface{}{
workitem.SystemTitle: "Title",
workitem.SystemState: workitem.SystemStateNew,
}, "xx")
require.Nil(s.T(), err)
wi.Type = "feature"
newWi, err := s.repo.Save(context.Background(), *wi)
require.Nil(s.T(), err)
require.Equal(s.T(), "feature", newWi.Type)
}
// TestListSourceAndTargetLinkTypes tests if we can find the work item link
// types for a given WIT.
func (s *workItemTypeSuite) TestListSourceAndTargetLinkTypes() {
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)
// Create work item link category
linkCatPayload := CreateWorkItemLinkCategory("some-link-category")
_, linkCat := test.CreateWorkItemLinkCategoryCreated(s.T(), nil, nil, s.linkCatCtrl, linkCatPayload)
require.NotNil(s.T(), linkCat)
// Create work item link type
animalLinksToBugStr := "animal-links-to-bug"
linkTypePayload := CreateWorkItemLinkType(animalLinksToBugStr, "animal", workitem.SystemBug, *linkCat.Data.ID)
_, linkType := test.CreateWorkItemLinkTypeCreated(s.T(), nil, nil, s.linkTypeCtrl, linkTypePayload)
require.NotNil(s.T(), linkType)
// Create another work item link type
bugLinksToAnimalStr := "bug-links-to-animal"
linkTypePayload = CreateWorkItemLinkType(bugLinksToAnimalStr, workitem.SystemBug, "animal", *linkCat.Data.ID)
_, linkType = test.CreateWorkItemLinkTypeCreated(s.T(), nil, nil, s.linkTypeCtrl, linkTypePayload)
require.NotNil(s.T(), linkType)
// Fetch source link types
_, wiltCollection := test.ListSourceLinkTypesWorkitemtypeOK(s.T(), nil, nil, s.typeCtrl, "animal")
require.NotNil(s.T(), wiltCollection)
assert.Nil(s.T(), wiltCollection.Validate())
// Check the number of found work item link types
require.Len(s.T(), wiltCollection.Data, 1)
require.Equal(s.T(), animalLinksToBugStr, *wiltCollection.Data[0].Attributes.Name)
// Fetch target link types
_, wiltCollection = test.ListTargetLinkTypesWorkitemtypeOK(s.T(), nil, nil, s.typeCtrl, "animal")
require.NotNil(s.T(), wiltCollection)
require.Nil(s.T(), wiltCollection.Validate())
// Check the number of found work item link types
require.Len(s.T(), wiltCollection.Data, 1)
require.Equal(s.T(), bugLinksToAnimalStr, *wiltCollection.Data[0].Attributes.Name)
}
