Do not create ChangesetSpecs on server with empty diff (#287)

I ran into this yesterday with Chris: we ran a command across multiple
repositories and in one repository it didn't produce a diff.

That's totally to be expected, since you don't know which command will
produce which diff in which repository.

The problem is that src-cli then sends up the changeset spec, even
though the diff is empty and we then try to apply the diff in gitserver,
which is where it fails (bonus: our error message looked really good!)

This commit here fixes it by not adding a spec with an empty diff to the
"list of completed specs".

I've looked at a few places where we could add this check (for example:
right before we make the GraphQL request we could do an early exit, or
before we add it to the cache, ...) and I'm still not 100% whether
that's the best place.

But I think the requirements are these:
- We should not send up empty diffs (because it looks weird in the UI if
  we say "we will create this changeset", even though it has no diff).
- We should still cache the result, even though the diff is empty.
- We should be able to report progress when executing it (we did do _something_, but we
  just didn't produce a diff)
- We shouldn't say "sending up 1 changeset spec" if we don't do that

That's why I added it where it is, which also required to fix the
progress bar for the case where "bar.Max == 0" so we don't run into a
panic.

I think this is the least invasive option of all the ones I considered
(I could also, for example, blast a few `if len(specs) > 0` around the
codebase...).

Let me know what you think, especially you @LawnGnome!

Author: mrnugget

internal/campaigns/executor.go

@@ -200,17 +200,25 @@ func (x *executor) do(ctx context.Context, task *Task) (err error) {
 	status.ChangesetSpec = spec
 	x.updateTaskStatus(task, status)
 
-	// Add the spec to the executor's list of completed specs.
-	x.specsMu.Lock()
-	x.specs = append(x.specs, spec)
-	x.specsMu.Unlock()
+	// Add it to the status
+	status.ChangesetSpec = spec
 
 	// Add to the cache. We don't use runCtx here because we want to write to
 	// the cache even if we've now reached the timeout.
 	if err = x.cache.Set(ctx, cacheKey, spec); err != nil {
 		err = errors.Wrapf(err, "caching result for %q", task.Repository.Name)
 	}
 
+	// If the steps didn't result in any diff, we don't need to add it to the
+	// list of specs that are displayed to the user and send to the server.
+	if len(diff) == 0 {
+		return
+	}
+
+	// Add the spec to the executor's list of completed specs.
+	x.specsMu.Lock()
+	x.specs = append(x.specs, spec)
+	x.specsMu.Unlock()
 	return
 }