github: fix 3 edge-case failures

13 files changed, 114 insertions, 95 deletions

diff --git a/bridge/github/import.go b/bridge/github/import.go
index 38278911..4627145e 100644
--- a/bridge/github/import.go
+++ b/bridge/github/import.go
@@ -108,13 +108,13 @@ func (gi *githubImporter) Import(repo *cache.RepoCache, id string) error {
 func (gi *githubImporter) ensureIssue(repo *cache.RepoCache, issue issueTimeline, rootVariables map[string]interface{}) (*cache.BugCache, error) {
 	fmt.Printf("import issue: %s\n", issue.Title)
 
-	b, err := repo.ResolveBugCreateMetadata(keyGithubId, parseId(issue.Id))
-	if err != nil && err != bug.ErrBugNotExist {
+	author, err := gi.ensurePerson(repo, issue.Author)
+	if err != nil {
 		return nil, err
 	}
 
-	author, err := gi.makePerson(repo, issue.Author)
-	if err != nil {
+	b, err := repo.ResolveBugCreateMetadata(keyGithubId, parseId(issue.Id))
+	if err != nil && err != bug.ErrBugNotExist {
 		return nil, err
 	}
 
@@ -187,7 +187,7 @@ func (gi *githubImporter) ensureIssue(repo *cache.RepoCache, issue issueTimeline
 			continue
 		}
 
-		target, err := b.ResolveTargetWithMetadata(keyGithubId, parseId(issue.Id))
+		target, err := b.ResolveOperationWithMetadata(keyGithubId, parseId(issue.Id))
 		if err != nil {
 			return nil, err
 		}
@@ -269,7 +269,7 @@ func (gi *githubImporter) ensureIssue(repo *cache.RepoCache, issue issueTimeline
 				continue
 			}
 
-			target, err := b.ResolveTargetWithMetadata(keyGithubId, parseId(issue.Id))
+			target, err := b.ResolveOperationWithMetadata(keyGithubId, parseId(issue.Id))
 			if err != nil {
 				return nil, err
 			}
@@ -318,15 +318,15 @@ func (gi *githubImporter) ensureTimelineItem(repo *cache.RepoCache, b *cache.Bug
 
 	case "LabeledEvent":
 		id := parseId(item.LabeledEvent.Id)
-		_, err := b.ResolveTargetWithMetadata(keyGithubId, id)
+		_, err := b.ResolveOperationWithMetadata(keyGithubId, id)
 		if err != cache.ErrNoMatchingOp {
 			return err
 		}
-		author, err := gi.makePerson(repo, item.LabeledEvent.Actor)
+		author, err := gi.ensurePerson(repo, item.LabeledEvent.Actor)
 		if err != nil {
 			return err
 		}
-		_, err = b.ChangeLabelsRaw(
+		_, _, err = b.ChangeLabelsRaw(
 			author,
 			item.LabeledEvent.CreatedAt.Unix(),
 			[]string{
@@ -339,15 +339,15 @@ func (gi *githubImporter) ensureTimelineItem(repo *cache.RepoCache, b *cache.Bug
 
 	case "UnlabeledEvent":
 		id := parseId(item.UnlabeledEvent.Id)
-		_, err := b.ResolveTargetWithMetadata(keyGithubId, id)
+		_, err := b.ResolveOperationWithMetadata(keyGithubId, id)
 		if err != cache.ErrNoMatchingOp {
 			return err
 		}
-		author, err := gi.makePerson(repo, item.UnlabeledEvent.Actor)
+		author, err := gi.ensurePerson(repo, item.UnlabeledEvent.Actor)
 		if err != nil {
 			return err
 		}
-		_, err = b.ChangeLabelsRaw(
+		_, _, err = b.ChangeLabelsRaw(
 			author,
 			item.UnlabeledEvent.CreatedAt.Unix(),
 			nil,
@@ -360,52 +360,55 @@ func (gi *githubImporter) ensureTimelineItem(repo *cache.RepoCache, b *cache.Bug
 
 	case "ClosedEvent":
 		id := parseId(item.ClosedEvent.Id)
-		_, err := b.ResolveTargetWithMetadata(keyGithubId, id)
+		_, err := b.ResolveOperationWithMetadata(keyGithubId, id)
 		if err != cache.ErrNoMatchingOp {
 			return err
 		}
-		author, err := gi.makePerson(repo, item.ClosedEvent.Actor)
+		author, err := gi.ensurePerson(repo, item.ClosedEvent.Actor)
 		if err != nil {
 			return err
 		}
-		return b.CloseRaw(
+		_, err = b.CloseRaw(
 			author,
 			item.ClosedEvent.CreatedAt.Unix(),
 			map[string]string{keyGithubId: id},
 		)
+		return err
 
 	case "ReopenedEvent":
 		id := parseId(item.ReopenedEvent.Id)
-		_, err := b.ResolveTargetWithMetadata(keyGithubId, id)
+		_, err := b.ResolveOperationWithMetadata(keyGithubId, id)
 		if err != cache.ErrNoMatchingOp {
 			return err
 		}
-		author, err := gi.makePerson(repo, item.ReopenedEvent.Actor)
+		author, err := gi.ensurePerson(repo, item.ReopenedEvent.Actor)
 		if err != nil {
 			return err
 		}
-		return b.OpenRaw(
+		_, err = b.OpenRaw(
 			author,
 			item.ReopenedEvent.CreatedAt.Unix(),
 			map[string]string{keyGithubId: id},
 		)
+		return err
 
 	case "RenamedTitleEvent":
 		id := parseId(item.RenamedTitleEvent.Id)
-		_, err := b.ResolveTargetWithMetadata(keyGithubId, id)
+		_, err := b.ResolveOperationWithMetadata(keyGithubId, id)
 		if err != cache.ErrNoMatchingOp {
 			return err
 		}
-		author, err := gi.makePerson(repo, item.RenamedTitleEvent.Actor)
+		author, err := gi.ensurePerson(repo, item.RenamedTitleEvent.Actor)
 		if err != nil {
 			return err
 		}
-		return b.SetTitleRaw(
+		_, err = b.SetTitleRaw(
 			author,
 			item.RenamedTitleEvent.CreatedAt.Unix(),
 			string(item.RenamedTitleEvent.CurrentTitle),
 			map[string]string{keyGithubId: id},
 		)
+		return err
 
 	default:
 		fmt.Println("ignore event ", item.Typename)
@@ -415,14 +418,14 @@ func (gi *githubImporter) ensureTimelineItem(repo *cache.RepoCache, b *cache.Bug
 }
 
 func (gi *githubImporter) ensureComment(repo *cache.RepoCache, b *cache.BugCache, cursor githubv4.String, comment issueComment, rootVariables map[string]interface{}) error {
-	target, err := b.ResolveTargetWithMetadata(keyGithubId, parseId(comment.Id))
-	if err != nil && err != cache.ErrNoMatchingOp {
-		// real error
+	author, err := gi.ensurePerson(repo, comment.Author)
+	if err != nil {
 		return err
 	}
 
-	author, err := gi.makePerson(repo, comment.Author)
-	if err != nil {
+	target, err := b.ResolveOperationWithMetadata(keyGithubId, parseId(comment.Id))
+	if err != nil && err != cache.ErrNoMatchingOp {
+		// real error
 		return err
 	}
 
@@ -439,7 +442,7 @@ func (gi *githubImporter) ensureComment(repo *cache.RepoCache, b *cache.BugCache
 
 	if len(comment.UserContentEdits.Nodes) == 0 {
 		if err == cache.ErrNoMatchingOp {
-			err = b.AddCommentRaw(
+			op, err := b.AddCommentRaw(
 				author,
 				comment.CreatedAt.Unix(),
 				cleanupText(string(comment.Body)),
@@ -448,7 +451,11 @@ func (gi *githubImporter) ensureComment(repo *cache.RepoCache, b *cache.BugCache
 					keyGithubId: parseId(comment.Id),
 				},
 			)
+			if err != nil {
+				return err
+			}
 
+			target, err = op.Hash()
 			if err != nil {
 				return err
 			}
@@ -472,7 +479,7 @@ func (gi *githubImporter) ensureComment(repo *cache.RepoCache, b *cache.BugCache
 				continue
 			}
 
-			err = b.AddCommentRaw(
+			op, err := b.AddCommentRaw(
 				author,
 				comment.CreatedAt.Unix(),
 				cleanupText(string(*edit.Diff)),
@@ -485,6 +492,11 @@ func (gi *githubImporter) ensureComment(repo *cache.RepoCache, b *cache.BugCache
 			if err != nil {
 				return err
 			}
+
+			target, err = op.Hash()
+			if err != nil {
+				return err
+			}
 		}
 
 		err := gi.ensureCommentEdit(repo, b, target, edit)
@@ -554,11 +566,7 @@ func (gi *githubImporter) ensureCommentEdit(repo *cache.RepoCache, b *cache.BugC
 		return nil
 	}
 
-	if edit.Editor == nil {
-		return fmt.Errorf("no editor")
-	}
-
-	_, err := b.ResolveTargetWithMetadata(keyGithubId, parseId(edit.Id))
+	_, err := b.ResolveOperationWithMetadata(keyGithubId, parseId(edit.Id))
 	if err == nil {
 		// already imported
 		return nil
@@ -570,9 +578,18 @@ func (gi *githubImporter) ensureCommentEdit(repo *cache.RepoCache, b *cache.BugC
 
 	fmt.Println("import edition")
 
-	editor, err := gi.makePerson(repo, edit.Editor)
-	if err != nil {
-		return err
+	var editor *cache.IdentityCache
+	if edit.Editor == nil {
+		// user account has been deleted, replacing it with the ghost
+		editor, err = gi.getGhost(repo)
+		if err != nil {
+			return err
+		}
+	} else {
+		editor, err = gi.ensurePerson(repo, edit.Editor)
+		if err != nil {
+			return err
+		}
 	}
 
 	switch {
@@ -581,7 +598,7 @@ func (gi *githubImporter) ensureCommentEdit(repo *cache.RepoCache, b *cache.BugC
 
 	case edit.DeletedAt == nil:
 		// comment edition
-		err := b.EditCommentRaw(
+		_, err := b.EditCommentRaw(
 			editor,
 			edit.CreatedAt.Unix(),
 			target,
@@ -598,8 +615,8 @@ func (gi *githubImporter) ensureCommentEdit(repo *cache.RepoCache, b *cache.BugC
 	return nil
 }
 
-// makePerson create a bug.Person from the Github data
-func (gi *githubImporter) makePerson(repo *cache.RepoCache, actor *actor) (*cache.IdentityCache, error) {
+// ensurePerson create a bug.Person from the Github data
+func (gi *githubImporter) ensurePerson(repo *cache.RepoCache, actor *actor) (*cache.IdentityCache, error) {
 	// When a user has been deleted, Github return a null actor, while displaying a profile named "ghost"
 	// in it's UI. So we need a special case to get it.
 	if actor == nil {
diff --git a/bridge/launchpad/import.go b/bridge/launchpad/import.go
index b70d34f0..30ec5c3f 100644
--- a/bridge/launchpad/import.go
+++ b/bridge/launchpad/import.go
@@ -23,7 +23,7 @@ func (li *launchpadImporter) Init(conf core.Configuration) error {
 const keyLaunchpadID = "launchpad-id"
 const keyLaunchpadLogin = "launchpad-login"
 
-func (li *launchpadImporter) makePerson(repo *cache.RepoCache, owner LPPerson) (*cache.IdentityCache, error) {
+func (li *launchpadImporter) ensurePerson(repo *cache.RepoCache, owner LPPerson) (*cache.IdentityCache, error) {
 	// Look first in the cache
 	i, err := repo.ResolveIdentityImmutableMetadata(keyLaunchpadLogin, owner.Login)
 	if err == nil {
@@ -67,7 +67,7 @@ func (li *launchpadImporter) ImportAll(repo *cache.RepoCache) error {
 			return err
 		}
 
-		owner, err := li.makePerson(repo, lpBug.Owner)
+		owner, err := li.ensurePerson(repo, lpBug.Owner)
 		if err != nil {
 			return err
 		}
@@ -100,7 +100,7 @@ func (li *launchpadImporter) ImportAll(repo *cache.RepoCache) error {
 		// The Launchpad API returns the bug description as the first
 		// comment, so skip it.
 		for _, lpMessage := range lpBug.Messages[1:] {
-			_, err := b.ResolveTargetWithMetadata(keyLaunchpadID, lpMessage.ID)
+			_, err := b.ResolveOperationWithMetadata(keyLaunchpadID, lpMessage.ID)
 			if err != nil && err != cache.ErrNoMatchingOp {
 				return errors.Wrapf(err, "failed to fetch comments for bug #%s", lpBugID)
 			}
@@ -113,14 +113,14 @@ func (li *launchpadImporter) ImportAll(repo *cache.RepoCache) error {
 				continue
 			}
 
-			owner, err := li.makePerson(repo, lpMessage.Owner)
+			owner, err := li.ensurePerson(repo, lpMessage.Owner)
 			if err != nil {
 				return err
 			}
 
 			// This is a new comment, we can add it.
 			createdAt, _ := time.Parse(time.RFC3339, lpMessage.CreatedAt)
-			err = b.AddCommentRaw(
+			_, err = b.AddCommentRaw(
 				owner,
 				createdAt.Unix(),
 				lpMessage.Content,
diff --git a/cache/bug_cache.go b/cache/bug_cache.go
index 53a96275..5fc76658 100644
--- a/cache/bug_cache.go
+++ b/cache/bug_cache.go
@@ -57,8 +57,8 @@ func (e ErrMultipleMatchOp) Error() string {
 	return fmt.Sprintf("Multiple matching operation found:\n%s", strings.Join(casted, "\n"))
 }
 
-// ResolveTargetWithMetadata will find an operation that has the matching metadata
-func (c *BugCache) ResolveTargetWithMetadata(key string, value string) (git.Hash, error) {
+// ResolveOperationWithMetadata will find an operation that has the matching metadata
+func (c *BugCache) ResolveOperationWithMetadata(key string, value string) (git.Hash, error) {
 	// preallocate but empty
 	matching := make([]git.Hash, 0, 5)
 
@@ -86,45 +86,45 @@ func (c *BugCache) ResolveTargetWithMetadata(key string, value string) (git.Hash
 	return matching[0], nil
 }
 
-func (c *BugCache) AddComment(message string) error {
+func (c *BugCache) AddComment(message string) (*bug.AddCommentOperation, error) {
 	return c.AddCommentWithFiles(message, nil)
 }
 
-func (c *BugCache) AddCommentWithFiles(message string, files []git.Hash) error {
+func (c *BugCache) AddCommentWithFiles(message string, files []git.Hash) (*bug.AddCommentOperation, error) {
 	author, err := c.repoCache.GetUserIdentity()
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	return c.AddCommentRaw(author, time.Now().Unix(), message, files, nil)
 }
 
-func (c *BugCache) AddCommentRaw(author *IdentityCache, unixTime int64, message string, files []git.Hash, metadata map[string]string) error {
+func (c *BugCache) AddCommentRaw(author *IdentityCache, unixTime int64, message string, files []git.Hash, metadata map[string]string) (*bug.AddCommentOperation, error) {
 	op, err := bug.AddCommentWithFiles(c.bug, author.Identity, unixTime, message, files)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	for key, value := range metadata {
 		op.SetMetadata(key, value)
 	}
 
-	return c.notifyUpdated()
+	return op, c.notifyUpdated()
 }
 
-func (c *BugCache) ChangeLabels(added []string, removed []string) ([]bug.LabelChangeResult, error) {
+func (c *BugCache) ChangeLabels(added []string, removed []string) ([]bug.LabelChangeResult, *bug.LabelChangeOperation, error) {
 	author, err := c.repoCache.GetUserIdentity()
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	return c.ChangeLabelsRaw(author, time.Now().Unix(), added, removed, nil)
 }
 
-func (c *BugCache) ChangeLabelsRaw(author *IdentityCache, unixTime int64, added []string, removed []string, metadata map[string]string) ([]bug.LabelChangeResult, error) {
+func (c *BugCache) ChangeLabelsRaw(author *IdentityCache, unixTime int64, added []string, removed []string, metadata map[string]string) ([]bug.LabelChangeResult, *bug.LabelChangeOperation, error) {
 	changes, op, err := bug.ChangeLabels(c.bug, author.Identity, unixTime, added, removed)
 	if err != nil {
-		return changes, err
+		return changes, nil, err
 	}
 
 	for key, value := range metadata {
@@ -133,98 +133,98 @@ func (c *BugCache) ChangeLabelsRaw(author *IdentityCache, unixTime int64, added
 
 	err = c.notifyUpdated()
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
-	return changes, nil
+	return changes, op, nil
 }
 
-func (c *BugCache) Open() error {
+func (c *BugCache) Open() (*bug.SetStatusOperation, error) {
 	author, err := c.repoCache.GetUserIdentity()
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	return c.OpenRaw(author, time.Now().Unix(), nil)
 }
 
-func (c *BugCache) OpenRaw(author *IdentityCache, unixTime int64, metadata map[string]string) error {
+func (c *BugCache) OpenRaw(author *IdentityCache, unixTime int64, metadata map[string]string) (*bug.SetStatusOperation, error) {
 	op, err := bug.Open(c.bug, author.Identity, unixTime)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	for key, value := range metadata {
 		op.SetMetadata(key, value)
 	}
 
-	return c.notifyUpdated()
+	return op, c.notifyUpdated()
 }
 
-func (c *BugCache) Close() error {
+func (c *BugCache) Close() (*bug.SetStatusOperation, error) {
 	author, err := c.repoCache.GetUserIdentity()
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	return c.CloseRaw(author, time.Now().Unix(), nil)
 }
 
-func (c *BugCache) CloseRaw(author *IdentityCache, unixTime int64, metadata map[string]string) error {
+func (c *BugCache) CloseRaw(author *IdentityCache, unixTime int64, metadata map[string]string) (*bug.SetStatusOperation, error) {
 	op, err := bug.Close(c.bug, author.Identity, unixTime)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	for key, value := range metadata {
 		op.SetMetadata(key, value)
 	}
 
-	return c.notifyUpdated()
+	return op, c.notifyUpdated()
 }
 
-func (c *BugCache) SetTitle(title string) error {
+func (c *BugCache) SetTitle(title string) (*bug.SetTitleOperation, error) {
 	author, err := c.repoCache.GetUserIdentity()
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	return c.SetTitleRaw(author, time.Now().Unix(), title, nil)
 }
 
-func (c *BugCache) SetTitleRaw(author *IdentityCache, unixTime int64, title string, metadata map[string]string) error {
+func (c *BugCache) SetTitleRaw(author *IdentityCache, unixTime int64, title string, metadata map[string]string) (*bug.SetTitleOperation, error) {
 	op, err := bug.SetTitle(c.bug, author.Identity, unixTime, title)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	for key, value := range metadata {
 		op.SetMetadata(key, value)
 	}
 
-	return c.notifyUpdated()
+	return op, c.notifyUpdated()
 }
 
-func (c *BugCache) EditComment(target git.Hash, message string) error {
+func (c *BugCache) EditComment(target git.Hash, message string) (*bug.EditCommentOperation, error) {
 	author, err := c.repoCache.GetUserIdentity()
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	return c.EditCommentRaw(author, time.Now().Unix(), target, message, nil)
 }
 
-func (c *BugCache) EditCommentRaw(author *IdentityCache, unixTime int64, target git.Hash, message string, metadata map[string]string) error {
+func (c *BugCache) EditCommentRaw(author *IdentityCache, unixTime int64, target git.Hash, message string, metadata map[string]string) (*bug.EditCommentOperation, error) {
 	op, err := bug.EditComment(c.bug, author.Identity, unixTime, target, message)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	for key, value := range metadata {
 		op.SetMetadata(key, value)
 	}
 
-	return c.notifyUpdated()
+	return op, c.notifyUpdated()
 }
 
 func (c *BugCache) Commit() error {
diff --git a/commands/comment_add.go b/commands/comment_add.go
index 58408bc5..80955da5 100644
--- a/commands/comment_add.go
+++ b/commands/comment_add.go
@@ -46,7 +46,7 @@ func runCommentAdd(cmd *cobra.Command, args []string) error {
 		}
 	}
 
-	err = b.AddComment(commentAddMessage)
+	_, err = b.AddComment(commentAddMessage)
 	if err != nil {
 		return err
 	}
diff --git a/commands/label_add.go b/commands/label_add.go
index f04ed7d6..2b808311 100644
--- a/commands/label_add.go
+++ b/commands/label_add.go
@@ -22,7 +22,7 @@ func runLabelAdd(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	changes, err := b.ChangeLabels(args, nil)
+	changes, _, err := b.ChangeLabels(args, nil)
 
 	for _, change := range changes {
 		fmt.Println(change)
diff --git a/commands/label_rm.go b/commands/label_rm.go
index 36051ba1..6b48fe72 100644
--- a/commands/label_rm.go
+++ b/commands/label_rm.go
@@ -22,7 +22,7 @@ func runLabelRm(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	changes, err := b.ChangeLabels(nil, args)
+	changes, _, err := b.ChangeLabels(nil, args)
 
 	for _, change := range changes {
 		fmt.Println(change)
diff --git a/commands/status_close.go b/commands/status_close.go
index 2b4f9602..03618cc6 100644
--- a/commands/status_close.go
+++ b/commands/status_close.go
@@ -20,7 +20,7 @@ func runStatusClose(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	err = b.Close()
+	_, err = b.Close()
 	if err != nil {
 		return err
 	}
diff --git a/commands/status_open.go b/commands/status_open.go
index 5e3029e2..f19847db 100644
--- a/commands/status_open.go
+++ b/commands/status_open.go
@@ -20,7 +20,7 @@ func runStatusOpen(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	err = b.Open()
+	_, err = b.Open()
 	if err != nil {
 		return err
 	}
diff --git a/commands/title_edit.go b/commands/title_edit.go
index 6bbd1b0a..8848e7a8 100644
--- a/commands/title_edit.go
+++ b/commands/title_edit.go
@@ -44,7 +44,7 @@ func runTitleEdit(cmd *cobra.Command, args []string) error {
 		fmt.Println("No change, aborting.")
 	}
 
-	err = b.SetTitle(titleEditTitle)
+	_, err = b.SetTitle(titleEditTitle)
 	if err != nil {
 		return err
 	}
diff --git a/graphql/resolvers/mutation.go b/graphql/resolvers/mutation.go
index ee79ce6b..be6956af 100644
--- a/graphql/resolvers/mutation.go
+++ b/graphql/resolvers/mutation.go
@@ -68,7 +68,7 @@ func (r mutationResolver) AddComment(ctx context.Context, repoRef *string, prefi
 		return bug.Snapshot{}, err
 	}
 
-	err = b.AddCommentWithFiles(message, files)
+	_, err = b.AddCommentWithFiles(message, files)
 	if err != nil {
 		return bug.Snapshot{}, err
 	}
@@ -89,7 +89,7 @@ func (r mutationResolver) ChangeLabels(ctx context.Context, repoRef *string, pre
 		return bug.Snapshot{}, err
 	}
 
-	_, err = b.ChangeLabels(added, removed)
+	_, _, err = b.ChangeLabels(added, removed)
 	if err != nil {
 		return bug.Snapshot{}, err
 	}
@@ -110,7 +110,7 @@ func (r mutationResolver) Open(ctx context.Context, repoRef *string, prefix stri
 		return bug.Snapshot{}, err
 	}
 
-	err = b.Open()
+	_, err = b.Open()
 	if err != nil {
 		return bug.Snapshot{}, err
 	}
@@ -131,7 +131,7 @@ func (r mutationResolver) Close(ctx context.Context, repoRef *string, prefix str
 		return bug.Snapshot{}, err
 	}
 
-	err = b.Close()
+	_, err = b.Close()
 	if err != nil {
 		return bug.Snapshot{}, err
 	}
@@ -152,7 +152,7 @@ func (r mutationResolver) SetTitle(ctx context.Context, repoRef *string, prefix
 		return bug.Snapshot{}, err
 	}
 
-	err = b.SetTitle(title)
+	_, err = b.SetTitle(title)
 	if err != nil {
 		return bug.Snapshot{}, err
 	}
diff --git a/termui/label_select.go b/termui/label_select.go
index 026eba04..131703f9 100644
--- a/termui/label_select.go
+++ b/termui/label_select.go
@@ -296,7 +296,7 @@ func (ls *labelSelect) saveAndReturn(g *gocui.Gui, v *gocui.View) error {
 		}
 	}
 
-	if _, err := ls.bug.ChangeLabels(newLabels, rmLabels); err != nil {
+	if _, _, err := ls.bug.ChangeLabels(newLabels, rmLabels); err != nil {
 		ui.msgPopup.Activate(msgPopupErrorTitle, err.Error())
 	}
 
diff --git a/termui/show_bug.go b/termui/show_bug.go
index 55d86018..733c801e 100644
--- a/termui/show_bug.go
+++ b/termui/show_bug.go
@@ -622,9 +622,11 @@ func (sb *showBug) setTitle(g *gocui.Gui, v *gocui.View) error {
 func (sb *showBug) toggleOpenClose(g *gocui.Gui, v *gocui.View) error {
 	switch sb.bug.Snapshot().Status {
 	case bug.OpenStatus:
-		return sb.bug.Close()
+		_, err := sb.bug.Close()
+		return err
 	case bug.ClosedStatus:
-		return sb.bug.Open()
+		_, err := sb.bug.Open()
+		return err
 	default:
 		return nil
 	}
diff --git a/termui/termui.go b/termui/termui.go
index 78900de8..54d9df69 100644
--- a/termui/termui.go
+++ b/termui/termui.go
@@ -226,7 +226,7 @@ func addCommentWithEditor(bug *cache.BugCache) error {
 	if err == input.ErrEmptyMessage {
 		ui.msgPopup.Activate(msgPopupErrorTitle, "Empty message, aborting.")
 	} else {
-		err := bug.AddComment(message)
+		_, err := bug.AddComment(message)
 		if err != nil {
 			return err
 		}
@@ -261,7 +261,7 @@ func editCommentWithEditor(bug *cache.BugCache, target git.Hash, preMessage stri
 	} else if message == preMessage {
 		ui.msgPopup.Activate(msgPopupErrorTitle, "No changes found, aborting.")
 	} else {
-		err := bug.EditComment(target, message)
+		_, err := bug.EditComment(target, message)
 		if err != nil {
 			return err
 		}
@@ -298,7 +298,7 @@ func setTitleWithEditor(bug *cache.BugCache) error {
 	} else if title == snap.Title {
 		ui.msgPopup.Activate(msgPopupErrorTitle, "No change, aborting.")
 	} else {
-		err := bug.SetTitle(title)
+		_, err := bug.SetTitle(title)
 		if err != nil {
 			return err
 		}