api/schema: remove MethodTestCase in favor of AssertSchema()

MethodTestCase had lots of problems, most caused by a good degree of ambiguity
in what we were actually testing.

AssertSchema(), on the other hand, simplifies this problem greatly by correctly
identifying the responsibilities of an *api.RequestSchema. An
*api.RequestSchema is responsible for one thing, and one thing only: to provide
a template for requests to be made against the API, completely regardless of
protocol or implementation.

Most notably, these responsibilities do not include:
 - Preforming an HTTP request, or
 - reading the response of an http request

So MethodTestCase gets simplified to a simple assert.Equal(). We expect to get
some *api.RequestSchema out, and we expect it to have certain parameters. Now,
all of the API's Service tests are rather simple: create a schema, compare,
rinse and repeat.

The only thing left to do is test the schema of the request and response
payload. This is what I had tried to do with the original MethodTestCase
implementation, but the way the system is desinged, trying to accomplish this
involves integrating with too many unrelated parts. To address this, I plan to
introduce a JSON Schema implementation that compares generated request/reponse
payloads with their ideal types.

Author: ttaylorr

api/lock_api_test.go

@@ -3,52 +3,19 @@ package api_test
 import (
 	"net/http"
 	"testing"
-	"time"
 
 	"github.com/github/git-lfs/api"
-	"github.com/stretchr/testify/assert"
 )
 
 var LockService api.LockService
 
 func TestSuccessfullyObtainingALock(t *testing.T) {
-	now := time.Now()
-
-	schema, resp := LockService.Lock(&api.LockRequest{
-		Path:               "/path/to/file",
-		LatestRemoteCommit: "deadbeef",
-		Committer: api.Committer{
-			Name:  "Jane Doe",
-			Email: "[email protected]",
-		},
-	})
-
-	tc := &MethodTestCase{
-		Schema:         schema,
-		ExpectedPath:   "/locks",
-		ExpectedMethod: http.MethodPost,
-		Resp:           resp,
-		Output: &api.LockResponse{
-			Lock: api.Lock{
-				Id:   "some-lock-id",
-				Path: "/path/to/file",
-				Committer: api.Committer{
-					Name:  "Jane Doe",
-					Email: "[email protected]",
-				},
-				CommitSHA: "deadbeef",
-				LockedAt:  now,
-			},
-		},
-	}
-
-	tc.Assert(t)
-
-	assert.Nil(t, resp.Err)
-	assert.Equal(t, "", resp.CommitNeeded)
-	assert.Equal(t, "some-lock-id", resp.Lock.Id)
-	assert.Equal(t, "/path/to/file", resp.Lock.Path)
-	assert.Equal(t, api.Committer{"Jane Doe", "[email protected]"}, resp.Lock.Committer)
-	assert.Equal(t, now, resp.Lock.LockedAt)
-	assert.True(t, resp.Lock.Active())
+	got, body := LockService.Lock(new(api.LockRequest))
+
+	AssertSchema(t, &api.RequestSchema{
+		Method: http.MethodPost,
+		Path:   "/locks",
+		Body:   new(api.LockRequest),
+		Into:   body,
+	}, got)
 }

api/method_test.go

@@ -0,0 +1,25 @@
+package api_test
+
+import (
+	"testing"
+
+	"github.com/github/git-lfs/api"
+	"github.com/github/git-lfs/vendor/_nuts/github.com/stretchr/testify/assert"
+)
+
+// SchemaTestCase encapsulates a single assertion of equality against two
+// generated RequestSchema instances.
+//
+// SchemaTestCases are meant only to test that the request schema generated by
+// an API service matches what we expect it to be. A SchemaTestCase does not
+// make use of the *api.Client, any particular lifecycle, or spin up a test
+// server. All of that behavior is tested at a higher strata in the
+// client/lifecycle tests.
+//
+// For examples, open any `*_api_test.go` file in the `api_test` package.
+//
+//   - Expected is the *api.RequestSchema that we expected to be generated.
+//   - Got is the *api.RequestSchema that was generated by a service.
+func AssertSchema(t *testing.T, expected, got *api.RequestSchema) {
+	assert.Equal(t, expected, got)
+}