major refactor based on README.md and TODOs

Updated types, improved units tests, isolated most test data to have
it in one place, renamed and created new files to improve readability,
and fixed a bunch of minor TODOs.

1 files changed, 0 insertions, 365 deletions

diff --git a/reqres_test.go b/reqres_test.go
deleted file mode 100644
index 7c3b455..0000000
--- a/reqres_test.go
+++ /dev/null
@@ -1,365 +0,0 @@
-package stfe
-
-import (
-	"bytes"
-	"fmt"
-	"strconv"
-	"testing"
-
-	"net/http"
-
-	"github.com/system-transparency/stfe/namespace/testdata"
-)
-
-func TestNewAddCosignatureRequest(t *testing.T) {
-	lp := makeTestLogParameters(t, nil)
-	validSth := NewSignedTreeHeadV1(NewTreeHeadV1(makeTrillianLogRoot(t, testTimestamp, testTreeSize, testNodeHash)), testLogId, testSignature)
-	for _, table := range []struct {
-		description string
-		breq        *bytes.Buffer
-		wantErr     bool
-	}{
-		// TODO: test cases for all errors + add wantBytes for valid cases
-		{
-			description: "invalid: unknown witness",
-			breq:        mustMakeAddCosiBuffer(t, testdata.Ed25519Sk2, testdata.Ed25519Vk2, validSth),
-			wantErr:     true,
-		},
-		{
-			description: "invalid: bad signature",
-			breq:        mustMakeAddCosiBuffer(t, testdata.Ed25519Sk, testdata.Ed25519Vk2, validSth),
-			wantErr:     true,
-		},
-		{
-			description: "valid",
-			breq:        mustMakeAddCosiBuffer(t, testdata.Ed25519Sk, testdata.Ed25519Vk, validSth),
-		},
-	} {
-		url := EndpointAddCosignature.Path("http://example.com", lp.Prefix)
-		req, err := http.NewRequest("POST", url, table.breq)
-		if err != nil {
-			t.Fatalf("failed creating http request: %v", err)
-		}
-		req.Header.Set("Content-Type", "application/json")
-
-		_, err = lp.newAddCosignatureRequest(req)
-		if got, want := err != nil, table.wantErr; got != want {
-			t.Errorf("got errror %v but wanted %v in test %q: %v", got, want, table.description, err)
-		}
-	}
-}
-
-// TODO: TestNewAddEntryRequest
-func TestNewAddEntryRequest(t *testing.T) {
-}
-
-func TestNewGetEntriesRequest(t *testing.T) {
-	lp := makeTestLogParameters(t, nil)
-	for _, table := range []struct {
-		description string
-		start       string
-		end         string
-		wantErr     bool
-	}{
-		{
-			description: "bad request: start must be an integer",
-			start:       "start",
-			end:         "10",
-			wantErr:     true,
-		},
-		{
-			description: "bad request: end must be an integer",
-			start:       "10",
-			end:         "end",
-			wantErr:     true,
-		},
-		{
-			description: "bad request: start must not be negative",
-			start:       "-1",
-			end:         "10",
-			wantErr:     true,
-		},
-		{
-			description: "bad request: start must be larger than end",
-			start:       "1",
-			end:         "0",
-			wantErr:     true,
-		},
-		{
-			description: "ok request but bad response: expected truncated",
-			start:       "0",
-			end:         fmt.Sprintf("%d", testMaxRange),
-		},
-		{
-			description: "ok request and response",
-			start:       "0",
-			end:         "0",
-		},
-		{
-			description: "ok request and response",
-			start:       "0",
-			end:         fmt.Sprintf("%d", testMaxRange-1),
-		},
-	} {
-		url := EndpointGetEntries.Path("http://example.com/", lp.Prefix)
-		r, err := http.NewRequest("GET", url, nil)
-		if err != nil {
-			t.Fatalf("must make http request in test %q: %v", table.description, err)
-		}
-		q := r.URL.Query()
-		q.Add("start", table.start)
-		q.Add("end", table.end)
-		r.URL.RawQuery = q.Encode()
-
-		req, err := lp.newGetEntriesRequest(r)
-		if got, want := err != nil, table.wantErr; got != want {
-			t.Errorf("got error is %v but wanted %v in test %q: %v", got, want, table.description, err)
-		}
-		if err != nil {
-			continue
-		}
-
-		if got, want := req.Start, mustParseInt64(t, table.start); got != want {
-			t.Errorf("got start %d but wanted %d in test %q", got, want, table.description)
-		}
-		if got, want := req.End, min(mustParseInt64(t, table.end), req.Start+testMaxRange-1); got != want {
-			t.Errorf("got end %d but wanted %d in test %q", got, want, table.description)
-		}
-	}
-}
-
-func TestNewGetProofByHashRequest(t *testing.T) {
-	lp := makeTestLogParameters(t, nil)
-	for _, table := range []struct {
-		description string
-		treeSize    string
-		hash        string
-		wantErr     bool
-	}{
-		{
-			description: "bad request: tree size must be an integer",
-			treeSize:    "treeSize",
-			hash:        b64(testNodeHash),
-			wantErr:     true,
-		},
-		{
-			description: "bad request: tree size must be larger than zero",
-			treeSize:    "0",
-			hash:        b64(testNodeHash),
-			wantErr:     true,
-		},
-		{
-			description: "bad request: hash is not base64",
-			treeSize:    "1",
-			hash:        "<(^_^)>",
-			wantErr:     true,
-		},
-		{
-			description: "bad request: invalid node hash (too small)",
-			treeSize:    "1",
-			hash:        b64(testNodeHash[1:]),
-			wantErr:     true,
-		},
-		{
-			description: "bad request: invalid node hash (too large)",
-			treeSize:    "1",
-			hash:        b64(append(testNodeHash, byte(0))),
-			wantErr:     true,
-		},
-		{
-			description: "ok request",
-			treeSize:    "1",
-			hash:        b64(testNodeHash),
-		},
-	} {
-		url := EndpointGetProofByHash.Path("http://example.com/", lp.Prefix)
-		r, err := http.NewRequest("GET", url, nil)
-		if err != nil {
-			t.Fatalf("must make http request in test %q: %v", table.description, err)
-		}
-		q := r.URL.Query()
-		q.Add("tree_size", table.treeSize)
-		q.Add("hash", table.hash)
-		r.URL.RawQuery = q.Encode()
-
-		req, err := lp.newGetProofByHashRequest(r)
-		if got, want := err != nil, table.wantErr; got != want {
-			t.Errorf("got error is %v but wanted %v in test %q: %v", got, want, table.description, err)
-		}
-		if err != nil {
-			continue
-		}
-
-		if got, want := req.TreeSize, mustParseInt64(t, table.treeSize); got != want {
-			t.Errorf("got treeSize %d but wanted %d in test %q", got, want, table.description)
-		}
-		if got, want := req.Hash, mustDeb64(t, table.hash); !bytes.Equal(got, want) {
-			t.Errorf("got hash %X but wanted %X in test %q", got, want, table.description)
-		}
-	}
-}
-
-func TestNewGetConsistencyProofRequest(t *testing.T) {
-	lp := makeTestLogParameters(t, nil)
-	for _, table := range []struct {
-		description string
-		first       string
-		second      string
-		wantErr     bool
-	}{
-		{
-			description: "bad reuqest: first must be an integer",
-			first:       "first",
-			second:      "1",
-			wantErr:     true,
-		},
-		{
-			description: "bad request: second must be an integer",
-			first:       "1",
-			second:      "second",
-			wantErr:     true,
-		},
-		{
-			description: "bad request: first must be larger than zero",
-			first:       "0",
-			second:      "2",
-			wantErr:     true,
-		},
-		{
-			description: "bad request: second must be larger than firsst",
-			first:       "2",
-			second:      "1",
-			wantErr:     true,
-		},
-		{
-			description: "ok request",
-			first:       "1",
-			second:      "2",
-		},
-	} {
-		url := EndpointGetConsistencyProof.Path("http://example.com/", lp.Prefix)
-		r, err := http.NewRequest("GET", url, nil)
-		if err != nil {
-			t.Fatalf("must make http request in test %q: %v", table.description, err)
-		}
-		q := r.URL.Query()
-		q.Add("first", table.first)
-		q.Add("second", table.second)
-		r.URL.RawQuery = q.Encode()
-
-		req, err := lp.newGetConsistencyProofRequest(r)
-		if got, want := err != nil, table.wantErr; got != want {
-			t.Errorf("got error is %v but wanted %v in test %q: %v", got, want, table.description, err)
-		}
-		if err != nil {
-			continue
-		}
-
-		if got, want := req.First, mustParseInt64(t, table.first); got != want {
-			t.Errorf("got first %d but wanted %d in test %q", got, want, table.description)
-		}
-		if got, want := req.Second, mustParseInt64(t, table.second); got != want {
-			t.Errorf("got second %d but wanted %d in test %q", got, want, table.description)
-		}
-	}
-}
-
-// TODO: refactor TestNewGetEntryResponse
-func TestNewGetEntryResponse(t *testing.T) {
-	//lp := makeTestLogParameters(t, nil)
-
-	//var appendix Appendix
-	//leaf, app := makeTestLeaf(t, testPackage, testdata.RootChain, testdata.EndEntityPrivateKey)
-	//if err := appendix.Unmarshal(app); err != nil {
-	//	t.Fatalf("must unmarshal appendix: %v", err)
-	//}
-	//if _, err := lp.newGetEntryResponse(leaf, app[1:]); err == nil {
-	//	t.Errorf("got no error invalid appendix")
-	//}
-
-	//// Valid response
-	//rsp, err := lp.newGetEntryResponse(leaf, app)
-	//if err != nil {
-	//	t.Errorf("got error %v but wanted none", err)
-	//	return
-	//}
-	//if got, want := rsp.Item, leaf; !bytes.Equal(got, want) {
-	//	t.Errorf("got leaf %X but wanted %X", got, want)
-	//}
-	//if got, want := rsp.Signature, appendix.Signature; !bytes.Equal(got, want) {
-	//	t.Errorf("got signature %X but wanted %X", got, want)
-	//}
-	//if got, want := rsp.SignatureScheme, appendix.SignatureScheme; got != want {
-	//	t.Errorf("got signature scheme %d but wanted %d", got, want)
-	//}
-	//if got, want := len(rsp.Chain), len(appendix.Chain); got != want {
-	//	t.Errorf("got chain length %d but wanted %d", got, want)
-	//}
-	//for i, n := 0, len(rsp.Chain); i < n; i++ {
-	//	if got, want := rsp.Chain[i], appendix.Chain[i].Data; !bytes.Equal(got, want) {
-	//		t.Errorf("got chain[%d]=%X but wanted %X", i, got, want)
-	//	}
-	//}
-}
-
-// TODO: refactor TestNewGetEntriesResponse
-func TestNewGetEntriesResponse(t *testing.T) {
-	//lp := makeTestLogParameters(t, nil)
-
-	//// Invalid
-	//leaf := makeTrillianQueueLeafResponse(t, testPackage, testdata.RootChain, testdata.EndEntityPrivateKey, false).QueuedLeaf.Leaf
-	//leaf.ExtraData = leaf.ExtraData[1:]
-	//if _, err := lp.newGetEntriesResponse([]*trillian.LogLeaf{leaf}); err == nil {
-	//	t.Errorf("got no error for invalid appendix")
-	//}
-
-	//// Valid, including empty
-	//for n, numEntries := 0, 5; n < numEntries; n++ {
-	//	leaves := make([]*trillian.LogLeaf, 0, n)
-	//	for i := 0; i < n; i++ {
-	//		leaves = append(leaves, makeTrillianQueueLeafResponse(t, []byte(fmt.Sprintf("%s-%d", testPackage, i)), testdata.RootChain, testdata.EndEntityPrivateKey, false).QueuedLeaf.Leaf)
-	//	}
-	//	if rsp, err := lp.newGetEntriesResponse(leaves); err != nil {
-	//		t.Errorf("got error for %d valid leaves: %v", n, err)
-	//	} else if got, want := len(rsp), n; got != want {
-	//		t.Errorf("got %d leaves but wanted %d", got, want)
-	//	}
-	//	// note that we tested actual leaf contents in TestNewGetEntryResponse
-	//}
-}
-
-// TODO: refactor TestNewGetAnchorsResponse
-func TestNewGetAnchorsResponse(t *testing.T) {
-	//rawAnchors := makeTestLogParameters(t, nil).newGetAnchorsResponse()
-	//if got, want := len(rawAnchors), testdata.NumTrustAnchors; got != want {
-	//	t.Errorf("got %d anchors but wanted %d", got, want)
-	//}
-	//for _, rawAnchor := range rawAnchors {
-	//	if _, err := x509.ParseCertificate(rawAnchor); err != nil {
-	//		t.Errorf("invalid trust anchor %X: %v", rawAnchor, err)
-	//	}
-	//}
-}
-
-func mustParseInt64(t *testing.T, num string) int64 {
-	n, err := strconv.ParseInt(num, 10, 64)
-	if err != nil {
-		t.Fatalf("must parse int: %v", err)
-	}
-	return n
-}
-
-func mustDeb64(t *testing.T, str string) []byte {
-	b, err := deb64(str)
-	if err != nil {
-		t.Fatalf("must base64 decode: %v", err)
-	}
-	return b
-}
-
-func min(a, b int64) int64 {
-	if a < b {
-		return a
-	}
-	return b
-}