aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--pkg/instance/endpoint_test.go588
-rw-r--r--pkg/instance/instance.go69
-rw-r--r--pkg/instance/instance_test.go155
-rw-r--r--pkg/instance/metric.go10
-rw-r--r--pkg/instance/request.go77
-rw-r--r--pkg/instance/request_test.go318
6 files changed, 345 insertions, 872 deletions
diff --git a/pkg/instance/endpoint_test.go b/pkg/instance/endpoint_test.go
index 8511b8d..efcd4c0 100644
--- a/pkg/instance/endpoint_test.go
+++ b/pkg/instance/endpoint_test.go
@@ -2,479 +2,431 @@ package stfe
import (
"bytes"
- "context"
+ "encoding/hex"
"fmt"
+ "io"
"net/http"
"net/http/httptest"
- "reflect"
"testing"
"github.com/golang/mock/gomock"
- cttestdata "github.com/google/certificate-transparency-go/trillian/testdata"
- "github.com/google/trillian"
- "github.com/system-transparency/stfe/pkg/testdata"
+ "github.com/system-transparency/stfe/pkg/mocks"
"github.com/system-transparency/stfe/pkg/types"
)
-func TestEndpointAddEntry(t *testing.T) {
- for _, table := range []struct {
- description string
- breq *bytes.Buffer
- trsp *trillian.QueueLeafResponse
- terr error
- wantCode int
- }{
- {
- description: "invalid: bad request: empty",
- breq: bytes.NewBuffer(nil),
- wantCode: http.StatusBadRequest,
+var (
+ testWitVK = [types.VerificationKeySize]byte{}
+ testConfig = Config{
+ LogID: hex.EncodeToString(types.Hash([]byte("logid"))[:]),
+ TreeID: 0,
+ Prefix: "testonly",
+ MaxRange: 3,
+ Deadline: 10,
+ Interval: 10,
+ Witnesses: map[[types.HashSize]byte][types.VerificationKeySize]byte{
+ *types.Hash(testWitVK[:]): testWitVK,
},
- {
- description: "invalid: bad Trillian response: error",
- breq: testdata.AddSignedChecksumBuffer(t, testdata.Ed25519SkSubmitter, testdata.Ed25519VkSubmitter),
- terr: fmt.Errorf("backend failure"),
- wantCode: http.StatusInternalServerError,
+ }
+ testSTH = &types.SignedTreeHead{
+ TreeHead: types.TreeHead{
+ Timestamp: 0,
+ TreeSize: 0,
+ RootHash: types.Hash(nil),
},
- {
- description: "valid",
- breq: testdata.AddSignedChecksumBuffer(t, testdata.Ed25519SkSubmitter, testdata.Ed25519VkSubmitter),
- trsp: testdata.DefaultTQlr(t, false),
- wantCode: http.StatusOK,
+ SigIdent: []*types.SigIdent{
+ &types.SigIdent{
+ Signature: &[types.SignatureSize]byte{},
+ KeyHash: &[types.HashSize]byte{},
+ },
},
- } {
- func() { // run deferred functions at the end of each iteration
- ti := newTestInstance(t, nil)
- defer ti.ctrl.Finish()
-
- url := EndpointAddEntry.Path("http://example.com", ti.instance.LogParameters.Prefix)
- req, err := http.NewRequest("POST", url, table.breq)
- if err != nil {
- t.Fatalf("must create http request: %v", err)
- }
- req.Header.Set("Content-Type", "application/octet-stream")
- if table.trsp != nil || table.terr != nil {
- ti.client.EXPECT().QueueLeaf(newDeadlineMatcher(), gomock.Any()).Return(table.trsp, table.terr)
- }
+ }
+)
- w := httptest.NewRecorder()
- ti.postHandler(t, EndpointAddEntry).ServeHTTP(w, req)
- if got, want := w.Code, table.wantCode; got != want {
- t.Errorf("got error code %d but wanted %d in test %q", got, want, table.description)
- }
- }()
+func mustHandle(t *testing.T, i Instance, e types.Endpoint) Handler {
+ for _, handler := range i.Handlers() {
+ if handler.Endpoint == e {
+ return handler
+ }
}
+ t.Fatalf("must handle endpoint: %v", e)
+ return Handler{}
}
-func TestEndpointAddCosignature(t *testing.T) {
+func TestAddLeaf(t *testing.T) {
+ buf := func() io.Reader {
+ // A valid leaf request that was created manually
+ return bytes.NewBufferString(fmt.Sprintf(
+ "%s%s%s%s"+"%s%s%s%s"+"%s%s%s%s"+"%s%s%s%s"+"%s%s%s%s",
+ types.ShardHint, types.Delim, "0", types.EOL,
+ types.Checksum, types.Delim, "0000000000000000000000000000000000000000000000000000000000000000", types.EOL,
+ types.SignatureOverMessage, types.Delim, "4cb410a4d48f52f761a7c01abcc28fd71811b84ded5403caed5e21b374f6aac9637cecd36828f17529fd503413d30ab66d7bb37a31dbf09a90d23b9241c45009", types.EOL,
+ types.VerificationKey, types.Delim, "f2b7a00b625469d32502e06e8b7fad1ef258d4ad0c6cd87b846142ab681957d5", types.EOL,
+ types.DomainHint, types.Delim, "example.com", types.EOL,
+ ))
+ }
for _, table := range []struct {
description string
- breq *bytes.Buffer
- wantCode int
+ ascii io.Reader // buffer used to populate HTTP request
+ expect bool // set if a mock answer is expected
+ err error // error from Trillian client
+ wantCode int // HTTP status ok
}{
{
- description: "invalid: bad request: empty",
- breq: bytes.NewBuffer(nil),
+ description: "invalid: bad request (parser error)",
+ ascii: bytes.NewBufferString("key=value\n"),
wantCode: http.StatusBadRequest,
},
{
- description: "invalid: signed wrong sth", // newLogParameters() use testdata.Ed25519VkLog as default
- breq: testdata.AddCosignatureBuffer(t, testdata.DefaultSth(t, testdata.Ed25519VkLog2), &testdata.Ed25519SkWitness, &testdata.Ed25519VkWitness),
- wantCode: http.StatusBadRequest,
+ description: "invalid: bad request (signature error)",
+ ascii: bytes.NewBufferString(fmt.Sprintf(
+ "%s%s%s%s"+"%s%s%s%s"+"%s%s%s%s"+"%s%s%s%s"+"%s%s%s%s",
+ types.ShardHint, types.Delim, "1", types.EOL,
+ types.Checksum, types.Delim, "1111111111111111111111111111111111111111111111111111111111111111", types.EOL,
+ types.SignatureOverMessage, types.Delim, "4cb410a4d48f52f761a7c01abcc28fd71811b84ded5403caed5e21b374f6aac9637cecd36828f17529fd503413d30ab66d7bb37a31dbf09a90d23b9241c45009", types.EOL,
+ types.VerificationKey, types.Delim, "f2b7a00b625469d32502e06e8b7fad1ef258d4ad0c6cd87b846142ab681957d5", types.EOL,
+ types.DomainHint, types.Delim, "example.com", types.EOL,
+ )),
+ wantCode: http.StatusBadRequest,
+ },
+ {
+ description: "invalid: backend failure",
+ ascii: buf(),
+ expect: true,
+ err: fmt.Errorf("something went wrong"),
+ wantCode: http.StatusInternalServerError,
},
{
description: "valid",
- breq: testdata.AddCosignatureBuffer(t, testdata.DefaultSth(t, testdata.Ed25519VkLog), &testdata.Ed25519SkWitness, &testdata.Ed25519VkWitness),
+ ascii: buf(),
+ expect: true,
wantCode: http.StatusOK,
},
} {
- func() { // run deferred functions at the end of each iteration
- ti := newTestInstance(t, nil)
- defer ti.ctrl.Finish()
-
- url := EndpointAddCosignature.Path("http://example.com", ti.instance.LogParameters.Prefix)
- req, err := http.NewRequest("POST", url, table.breq)
+ // Run deferred functions at the end of each iteration
+ func() {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+ client := mocks.NewMockClient(ctrl)
+ if table.expect {
+ client.EXPECT().AddLeaf(gomock.Any(), gomock.Any()).Return(table.err)
+ }
+ i := Instance{
+ Config: testConfig,
+ Client: client,
+ }
+
+ // Create HTTP request
+ url := types.EndpointAddLeaf.Path("http://example.com", i.Prefix)
+ req, err := http.NewRequest("POST", url, table.ascii)
if err != nil {
t.Fatalf("must create http request: %v", err)
}
- req.Header.Set("Content-Type", "application/octet-stream")
+ // Run HTTP request
w := httptest.NewRecorder()
- ti.postHandler(t, EndpointAddCosignature).ServeHTTP(w, req)
+ mustHandle(t, i, types.EndpointAddLeaf).ServeHTTP(w, req)
if got, want := w.Code, table.wantCode; got != want {
- t.Errorf("got error code %d but wanted %d in test %q", got, want, table.description)
+ t.Errorf("got HTTP status code %v but wanted %v in test %q", got, want, table.description)
}
}()
}
}
-func TestEndpointGetLatestSth(t *testing.T) {
+func TestAddCosignature(t *testing.T) {
+ buf := func() io.Reader {
+ return bytes.NewBufferString(fmt.Sprintf(
+ "%s%s%x%s"+"%s%s%x%s",
+ types.Signature, types.Delim, make([]byte, types.SignatureSize), types.EOL,
+ types.KeyHash, types.Delim, *types.Hash(testWitVK[:]), types.EOL,
+ ))
+ }
for _, table := range []struct {
description string
- trsp *trillian.GetLatestSignedLogRootResponse
- terr error
- wantCode int
- wantItem *types.StItem
+ ascii io.Reader // buffer used to populate HTTP request
+ expect bool // set if a mock answer is expected
+ err error // error from Trillian client
+ wantCode int // HTTP status ok
}{
{
- description: "backend failure",
- terr: fmt.Errorf("backend failure"),
- wantCode: http.StatusInternalServerError,
+ description: "invalid: bad request (parser error)",
+ ascii: bytes.NewBufferString("key=value\n"),
+ wantCode: http.StatusBadRequest,
},
{
- description: "valid",
- trsp: testdata.DefaultTSlr(t),
- wantCode: http.StatusOK,
- wantItem: testdata.DefaultSth(t, testdata.Ed25519VkLog),
+ description: "invalid: bad request (unknown witness)",
+ ascii: bytes.NewBufferString(fmt.Sprintf(
+ "%s%s%x%s"+"%s%s%x%s",
+ types.Signature, types.Delim, make([]byte, types.SignatureSize), types.EOL,
+ types.KeyHash, types.Delim, *types.Hash(testWitVK[1:]), types.EOL,
+ )),
+ wantCode: http.StatusBadRequest,
},
- } {
- func() { // run deferred functions at the end of each iteration
- ti := newTestInstance(t, cttestdata.NewSignerWithFixedSig(nil, testdata.Signature))
- ti.ctrl.Finish()
-
- // Setup and run client query
- url := EndpointGetLatestSth.Path("http://example.com", ti.instance.LogParameters.Prefix)
- req, err := http.NewRequest("GET", url, nil)
- if err != nil {
- t.Fatalf("must create http request: %v", err)
- }
- if table.trsp != nil || table.terr != nil {
- ti.client.EXPECT().GetLatestSignedLogRoot(newDeadlineMatcher(), gomock.Any()).Return(table.trsp, table.terr)
- }
-
- w := httptest.NewRecorder()
- ti.getHandler(t, EndpointGetLatestSth).ServeHTTP(w, req)
- if got, want := w.Code, table.wantCode; got != want {
- t.Errorf("got error code %d but wanted %d in test %q", got, want, table.description)
- }
- if w.Code != http.StatusOK {
- return
- }
-
- var item types.StItem
- if err := types.Unmarshal([]byte(w.Body.String()), &item); err != nil {
- t.Errorf("valid response cannot be unmarshalled in test %q: %v", table.description, err)
- }
- if got, want := item, *table.wantItem; !reflect.DeepEqual(got, want) {
- t.Errorf("got item\n%v\n\tbut wanted\n%v\n\tin test %q", got, want, table.description)
- }
- }()
- }
-}
-
-func TestEndpointGetStableSth(t *testing.T) {
- for _, table := range []struct {
- description string
- useBadSource bool
- wantCode int
- wantItem *types.StItem
- }{
{
- description: "invalid: sth source failure",
- useBadSource: true,
- wantCode: http.StatusInternalServerError,
+ description: "invalid: backend failure",
+ ascii: buf(),
+ expect: true,
+ err: fmt.Errorf("something went wrong"),
+ wantCode: http.StatusBadRequest,
},
{
description: "valid",
+ ascii: buf(),
+ expect: true,
wantCode: http.StatusOK,
- wantItem: testdata.DefaultSth(t, testdata.Ed25519VkLog),
},
} {
- func() { // run deferred functions at the end of each iteration
- ti := newTestInstance(t, nil)
- ti.ctrl.Finish()
- if table.useBadSource {
- ti.instance.SthSource = &ActiveSthSource{}
- }
-
- // Setup and run client query
- url := EndpointGetStableSth.Path("http://example.com", ti.instance.LogParameters.Prefix)
- req, err := http.NewRequest("GET", url, nil)
+ // Run deferred functions at the end of each iteration
+ func() {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+ stateman := mocks.NewMockStateManager(ctrl)
+ if table.expect {
+ stateman.EXPECT().AddCosignature(gomock.Any(), gomock.Any(), gomock.Any()).Return(table.err)
+ }
+ i := Instance{
+ Config: testConfig,
+ Stateman: stateman,
+ }
+
+ // Create HTTP request
+ url := types.EndpointAddCosignature.Path("http://example.com", i.Prefix)
+ req, err := http.NewRequest("POST", url, table.ascii)
if err != nil {
t.Fatalf("must create http request: %v", err)
}
+ // Run HTTP request
w := httptest.NewRecorder()
- ti.getHandler(t, EndpointGetStableSth).ServeHTTP(w, req)
+ mustHandle(t, i, types.EndpointAddCosignature).ServeHTTP(w, req)
if got, want := w.Code, table.wantCode; got != want {
- t.Errorf("got error code %d but wanted %d in test %q", got, want, table.description)
- }
- if w.Code != http.StatusOK {
- return
- }
-
- var item types.StItem
- if err := types.Unmarshal([]byte(w.Body.String()), &item); err != nil {
- t.Errorf("valid response cannot be unmarshalled in test %q: %v", table.description, err)
- }
- if got, want := item, *table.wantItem; !reflect.DeepEqual(got, want) {
- t.Errorf("got item\n%v\n\tbut wanted\n%v\n\tin test %q", got, want, table.description)
+ t.Errorf("got HTTP status code %v but wanted %v in test %q", got, want, table.description)
}
}()
}
}
-func TestEndpointGetCosignedSth(t *testing.T) {
+func TestGetTreeHeadLatest(t *testing.T) {
for _, table := range []struct {
- description string
- useBadSource bool
- wantCode int
- wantItem *types.StItem
+ description string
+ expect bool // set if a mock answer is expected
+ rsp *types.SignedTreeHead // signed tree head from Trillian client
+ err error // error from Trillian client
+ wantCode int // HTTP status ok
}{
{
- description: "invalid: sth source failure",
- useBadSource: true,
- wantCode: http.StatusInternalServerError,
+ description: "invalid: backend failure",
+ expect: true,
+ err: fmt.Errorf("something went wrong"),
+ wantCode: http.StatusInternalServerError,
},
{
description: "valid",
+ expect: true,
+ rsp: testSTH,
wantCode: http.StatusOK,
- wantItem: testdata.DefaultCosth(t, testdata.Ed25519VkLog, [][32]byte{testdata.Ed25519VkWitness}),
},
} {
- func() { // run deferred functions at the end of each iteration
- ti := newTestInstance(t, nil)
- ti.ctrl.Finish()
- if table.useBadSource {
- ti.instance.SthSource = &ActiveSthSource{}
+ // Run deferred functions at the end of each iteration
+ func() {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+ stateman := mocks.NewMockStateManager(ctrl)
+ if table.expect {
+ stateman.EXPECT().Latest(gomock.Any()).Return(table.rsp, table.err)
+ }
+ i := Instance{
+ Config: testConfig,
+ Stateman: stateman,
}
- // Setup and run client query
- url := EndpointGetCosignedSth.Path("http://example.com", ti.instance.LogParameters.Prefix)
+ // Create HTTP request
+ url := types.EndpointGetTreeHeadLatest.Path("http://example.com", i.Prefix)
req, err := http.NewRequest("GET", url, nil)
if err != nil {
t.Fatalf("must create http request: %v", err)
}
+ // Run HTTP request
w := httptest.NewRecorder()
- ti.getHandler(t, EndpointGetCosignedSth).ServeHTTP(w, req)
+ mustHandle(t, i, types.EndpointGetTreeHeadLatest).ServeHTTP(w, req)
if got, want := w.Code, table.wantCode; got != want {
- t.Errorf("got error code %d but wanted %d in test %q", got, want, table.description)
- }
- if w.Code != http.StatusOK {
- return
- }
-
- var item types.StItem
- if err := types.Unmarshal([]byte(w.Body.String()), &item); err != nil {
- t.Errorf("valid response cannot be unmarshalled in test %q: %v", table.description, err)
- }
- if got, want := item, *table.wantItem; !reflect.DeepEqual(got, want) {
- t.Errorf("got item\n%v\n\tbut wanted\n%v\n\tin test %q", got, want, table.description)
+ t.Errorf("got HTTP status code %v but wanted %v in test %q", got, want, table.description)
}
}()
}
}
-func TestEndpointGetProofByHash(t *testing.T) {
+func TestGetTreeToSign(t *testing.T) {
for _, table := range []struct {
description string
- breq *bytes.Buffer
- trsp *trillian.GetInclusionProofByHashResponse
- terr error
- wantCode int
- wantItem *types.StItem
+ expect bool // set if a mock answer is expected
+ rsp *types.SignedTreeHead // signed tree head from Trillian client
+ err error // error from Trillian client
+ wantCode int // HTTP status ok
}{
{
- description: "invalid: bad request: empty",
- breq: bytes.NewBuffer(nil),
- wantCode: http.StatusBadRequest,
- },
- {
- description: "invalid: bad Trillian response: error",
- breq: bytes.NewBuffer(marshal(t, types.GetProofByHashV1{TreeSize: 1, Hash: testdata.LeafHash})),
- terr: fmt.Errorf("backend failure"),
+ description: "invalid: backend failure",
+ expect: true,
+ err: fmt.Errorf("something went wrong"),
wantCode: http.StatusInternalServerError,
},
{
description: "valid",
- breq: bytes.NewBuffer(marshal(t, types.GetProofByHashV1{TreeSize: 1, Hash: testdata.LeafHash})),
- trsp: testdata.DefaultTGipbhr(t),
+ expect: true,
+ rsp: testSTH,
wantCode: http.StatusOK,
- wantItem: testdata.DefaultInclusionProof(t, 1),
},
} {
- func() { // run deferred functions at the end of each iteration
- ti := newTestInstance(t, nil)
- defer ti.ctrl.Finish()
+ // Run deferred functions at the end of each iteration
+ func() {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+ stateman := mocks.NewMockStateManager(ctrl)
+ if table.expect {
+ stateman.EXPECT().ToSign(gomock.Any()).Return(table.rsp, table.err)
+ }
+ i := Instance{
+ Config: testConfig,
+ Stateman: stateman,
+ }
- url := EndpointGetProofByHash.Path("http://example.com", ti.instance.LogParameters.Prefix)
- req, err := http.NewRequest("POST", url, table.breq)
+ // Create HTTP request
+ url := types.EndpointGetTreeHeadToSign.Path("http://example.com", i.Prefix)
+ req, err := http.NewRequest("GET", url, nil)
if err != nil {
t.Fatalf("must create http request: %v", err)
}
- req.Header.Set("Content-Type", "application/octet-stream")
- if table.trsp != nil || table.terr != nil {
- ti.client.EXPECT().GetInclusionProofByHash(newDeadlineMatcher(), gomock.Any()).Return(table.trsp, table.terr)
- }
+ // Run HTTP request
w := httptest.NewRecorder()
- ti.postHandler(t, EndpointGetProofByHash).ServeHTTP(w, req)
+ mustHandle(t, i, types.EndpointGetTreeHeadToSign).ServeHTTP(w, req)
if got, want := w.Code, table.wantCode; got != want {
- t.Errorf("got error code %d but wanted %d in test %q", got, want, table.description)
- }
- if w.Code != http.StatusOK {
- return
- }
-
- var item types.StItem
- if err := types.Unmarshal([]byte(w.Body.String()), &item); err != nil {
- t.Errorf("valid response cannot be unmarshalled in test %q: %v", table.description, err)
- }
- if got, want := item, *table.wantItem; !reflect.DeepEqual(got, want) {
- t.Errorf("got item\n%v\n\tbut wanted\n%v\n\tin test %q", got, want, table.description)
+ t.Errorf("got HTTP status code %v but wanted %v in test %q", got, want, table.description)
}
}()
}
}
-func TestEndpointGetConsistencyProof(t *testing.T) {
+func TestGetTreeCosigned(t *testing.T) {
for _, table := range []struct {
description string
- breq *bytes.Buffer
- trsp *trillian.GetConsistencyProofResponse
- terr error
- wantCode int
- wantItem *types.StItem
+ expect bool // set if a mock answer is expected
+ rsp *types.SignedTreeHead // signed tree head from Trillian client
+ err error // error from Trillian client
+ wantCode int // HTTP status ok
}{
{
- description: "invalid: bad request: empty",
- breq: bytes.NewBuffer(nil),
- wantCode: http.StatusBadRequest,
- },
- {
- description: "invalid: bad Trillian response: error",
- breq: bytes.NewBuffer(marshal(t, types.GetConsistencyProofV1{First: 1, Second: 2})),
- terr: fmt.Errorf("backend failure"),
+ description: "invalid: backend failure",
+ expect: true,
+ err: fmt.Errorf("something went wrong"),
wantCode: http.StatusInternalServerError,
},
{
description: "valid",
- breq: bytes.NewBuffer(marshal(t, types.GetConsistencyProofV1{First: 1, Second: 2})),
- trsp: testdata.DefaultTGcpr(t),
+ expect: true,
+ rsp: testSTH,
wantCode: http.StatusOK,
- wantItem: testdata.DefaultConsistencyProof(t, 1, 2),
},
} {
- func() { // run deferred functions at the end of each iteration
- ti := newTestInstance(t, nil)
- defer ti.ctrl.Finish()
+ // Run deferred functions at the end of each iteration
+ func() {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+ stateman := mocks.NewMockStateManager(ctrl)
+ if table.expect {
+ stateman.EXPECT().Cosigned(gomock.Any()).Return(table.rsp, table.err)
+ }
+ i := Instance{
+ Config: testConfig,
+ Stateman: stateman,
+ }
- url := EndpointGetConsistencyProof.Path("http://example.com", ti.instance.LogParameters.Prefix)
- req, err := http.NewRequest("POST", url, table.breq)
+ // Create HTTP request
+ url := types.EndpointGetTreeHeadCosigned.Path("http://example.com", i.Prefix)
+ req, err := http.NewRequest("GET", url, nil)
if err != nil {
t.Fatalf("must create http request: %v", err)
}
- req.Header.Set("Content-Type", "application/octet-stream")
- if table.trsp != nil || table.terr != nil {
- ti.client.EXPECT().GetConsistencyProof(newDeadlineMatcher(), gomock.Any()).Return(table.trsp, table.terr)
- }
+ // Run HTTP request
w := httptest.NewRecorder()
- ti.postHandler(t, EndpointGetConsistencyProof).ServeHTTP(w, req)
+ mustHandle(t, i, types.EndpointGetTreeHeadCosigned).ServeHTTP(w, req)
if got, want := w.Code, table.wantCode; got != want {
- t.Errorf("got error code %d but wanted %d in test %q", got, want, table.description)
- }
- if w.Code != http.StatusOK {
- return
- }
-
- var item types.StItem
- if err := types.Unmarshal([]byte(w.Body.String()), &item); err != nil {
- t.Errorf("valid response cannot be unmarshalled in test %q: %v", table.description, err)
- }
- if got, want := item, *table.wantItem; !reflect.DeepEqual(got, want) {
- t.Errorf("got item\n%v\n\tbut wanted\n%v\n\tin test %q", got, want, table.description)
+ t.Errorf("got HTTP status code %v but wanted %v in test %q", got, want, table.description)
}
}()
}
}
-func TestEndpointGetEntriesV1(t *testing.T) {
+func TestGetConsistencyProof(t *testing.T) {
+ buf := func(oldSize, newSize int) io.Reader {
+ return bytes.NewBufferString(fmt.Sprintf(
+ "%s%s%d%s"+"%s%s%d%s",
+ types.OldSize, types.Delim, oldSize, types.EOL,
+ types.NewSize, types.Delim, newSize, types.EOL,
+ ))
+ }
+ // values in testProof are not relevant for the test, just need a path
+ testProof := &types.ConsistencyProof{
+ OldSize: 1,
+ NewSize: 2,
+ Path: []*[types.HashSize]byte{
+ types.Hash(nil),
+ },
+ }
for _, table := range []struct {
description string
- breq *bytes.Buffer
- trsp *trillian.GetLeavesByRangeResponse
- terr error
- wantCode int
- wantItem *types.StItemList
+ ascii io.Reader // buffer used to populate HTTP request
+ expect bool // set if a mock answer is expected
+ rsp *types.ConsistencyProof // consistency proof from Trillian client
+ err error // error from Trillian client
+ wantCode int // HTTP status ok
}{
{
- description: "invalid: bad request: empty",
- breq: bytes.NewBuffer(nil),
+ description: "invalid: bad request (parser error)",
+ ascii: bytes.NewBufferString("key=value\n"),
wantCode: http.StatusBadRequest,
},
{
- description: "invalid: bad Trillian response: error",
- breq: bytes.NewBuffer(marshal(t, types.GetEntriesV1{Start: 0, End: 0})),
- terr: fmt.Errorf("backend failure"),
- wantCode: http.StatusInternalServerError,
- },
- {
- description: "valid", // remember that newLogParameters() have testdata.MaxRange configured
- breq: bytes.NewBuffer(marshal(t, types.GetEntriesV1{Start: 0, End: uint64(testdata.MaxRange - 1)})),
- trsp: testdata.DefaultTGlbrr(t, 0, testdata.MaxRange-1),
+ description: "valid",
+ ascii: buf(1, 2),
+ expect: true,
+ rsp: testProof,
wantCode: http.StatusOK,
- wantItem: testdata.DefaultStItemList(t, 0, uint64(testdata.MaxRange)-1),
},
} {
- func() { // run deferred functions at the end of each iteration
- ti := newTestInstance(t, nil)
- defer ti.ctrl.Finish()
-
- url := EndpointGetEntries.Path("http://example.com", ti.instance.LogParameters.Prefix)
- req, err := http.NewRequest("POST", url, table.breq)
+ // Run deferred functions at the end of each iteration
+ func() {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+ client := mocks.NewMockClient(ctrl)
+ if table.expect {
+ client.EXPECT().GetConsistencyProof(gomock.Any(), gomock.Any()).Return(table.rsp, table.err)
+ }
+ i := Instance{
+ Config: testConfig,
+ Client: client,
+ }
+
+ // Create HTTP request
+ url := types.EndpointGetConsistencyProof.Path("http://example.com", i.Prefix)
+ req, err := http.NewRequest("POST", url, table.ascii)
if err != nil {
t.Fatalf("must create http request: %v", err)
}
- req.Header.Set("Content-Type", "application/octet-stream")
- if table.trsp != nil || table.terr != nil {
- ti.client.EXPECT().GetLeavesByRange(newDeadlineMatcher(), gomock.Any()).Return(table.trsp, table.terr)
- }
+ // Run HTTP request
w := httptest.NewRecorder()
- ti.postHandler(t, EndpointGetEntries).ServeHTTP(w, req)
+ mustHandle(t, i, types.EndpointGetConsistencyProof).ServeHTTP(w, req)
if got, want := w.Code, table.wantCode; got != want {
- t.Errorf("got error code %d but wanted %d in test %q", got, want, table.description)
- }
- if w.Code != http.StatusOK {
- return
- }
-
- var item types.StItemList
- if err := types.Unmarshal([]byte(w.Body.String()), &item); err != nil {
- t.Errorf("valid response cannot be unmarshalled in test %q: %v", table.description, err)
- }
- if got, want := item, *table.wantItem; !reflect.DeepEqual(got, want) {
- t.Errorf("got item\n%v\n\tbut wanted\n%v\n\tin test %q", got, want, table.description)
+ t.Errorf("got HTTP status code %v but wanted %v in test %q", got, want, table.description)
}
}()
}
}
-// TODO: TestWriteOctetResponse
-func TestWriteOctetResponse(t *testing.T) {
-}
-
-// deadlineMatcher implements gomock.Matcher, such that an error is raised if
-// there is no context.Context deadline set
-type deadlineMatcher struct{}
-
-// newDeadlineMatcher returns a new DeadlineMatcher
-func newDeadlineMatcher() gomock.Matcher {
- return &deadlineMatcher{}
-}
-
-// Matches returns true if the passed interface is a context with a deadline
-func (dm *deadlineMatcher) Matches(i interface{}) bool {
- ctx, ok := i.(context.Context)
- if !ok {
- return false
- }
- _, ok = ctx.Deadline()
- return ok
+func TestGetInclusionProof(t *testing.T) {
}
-// String is needed to implement gomock.Matcher
-func (dm *deadlineMatcher) String() string {
- return fmt.Sprintf("deadlineMatcher{}")
+func TestGetLeaves(t *testing.T) {
}
diff --git a/pkg/instance/instance.go b/pkg/instance/instance.go
index 3441a0a..c2fe8fa 100644
--- a/pkg/instance/instance.go
+++ b/pkg/instance/instance.go
@@ -3,6 +3,7 @@ package stfe
import (
"context"
"crypto"
+ "crypto/ed25519"
"fmt"
"net/http"
"time"
@@ -88,3 +89,71 @@ func (a Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
http.Error(w, fmt.Sprintf("%s%s%s%s", "Error", types.Delim, err.Error(), types.EOL), statusCode)
}
}
+
+func (i *Instance) leafRequestFromHTTP(r *http.Request) (*types.LeafRequest, error) {
+ var req types.LeafRequest
+ if err := req.UnmarshalASCII(r.Body); err != nil {
+ return nil, fmt.Errorf("UnmarshalASCII: %v", err)
+ }
+
+ vk := ed25519.PublicKey(req.VerificationKey[:])
+ msg := req.Message.Marshal()
+ sig := req.Signature[:]
+ if !ed25519.Verify(vk, msg, sig) {
+ return nil, fmt.Errorf("invalid signature")
+ }
+ // TODO: check shard hint
+ // TODO: check domain hint
+ return &req, nil
+}
+
+func (i *Instance) cosignatureRequestFromHTTP(r *http.Request) (*types.CosignatureRequest, error) {
+ var req types.CosignatureRequest
+ if err := req.UnmarshalASCII(r.Body); err != nil {
+ return nil, fmt.Errorf("unpackOctetPost: %v", err)
+ }
+ if _, ok := i.Witnesses[*req.KeyHash]; !ok {
+ return nil, fmt.Errorf("Unknown witness: %x", req.KeyHash)
+ }
+ return &req, nil
+}
+
+func (i *Instance) consistencyProofRequestFromHTTP(r *http.Request) (*types.ConsistencyProofRequest, error) {
+ var req types.ConsistencyProofRequest
+ if err := req.UnmarshalASCII(r.Body); err != nil {
+ return nil, fmt.Errorf("UnmarshalASCII: %v", err)
+ }
+ if req.OldSize < 1 {
+ return nil, fmt.Errorf("OldSize(%d) must be larger than zero", req.OldSize)
+ }
+ if req.NewSize <= req.OldSize {
+ return nil, fmt.Errorf("NewSize(%d) must be larger than OldSize(%d)", req.NewSize, req.OldSize)
+ }
+ return &req, nil
+}
+
+func (i *Instance) inclusionProofRequestFromHTTP(r *http.Request) (*types.InclusionProofRequest, error) {
+ var req types.InclusionProofRequest
+ if err := req.UnmarshalASCII(r.Body); err != nil {
+ return nil, fmt.Errorf("UnmarshalASCII: %v", err)
+ }
+ if req.TreeSize < 1 {
+ return nil, fmt.Errorf("TreeSize(%d) must be larger than zero", req.TreeSize)
+ }
+ return &req, nil
+}
+
+func (i *Instance) leavesRequestFromHTTP(r *http.Request) (*types.LeavesRequest, error) {
+ var req types.LeavesRequest
+ if err := req.UnmarshalASCII(r.Body); err != nil {
+ return nil, fmt.Errorf("UnmarshalASCII: %v", err)
+ }
+
+ if req.StartSize > req.EndSize {
+ return nil, fmt.Errorf("StartSize(%d) must be less than or equal to EndSize(%d)", req.StartSize, req.EndSize)
+ }
+ if req.EndSize-req.StartSize+1 > uint64(i.MaxRange) {
+ req.EndSize = req.StartSize + uint64(i.MaxRange) - 1
+ }
+ return &req, nil
+}
diff --git a/pkg/instance/instance_test.go b/pkg/instance/instance_test.go
index a7a3d8a..45a2837 100644
--- a/pkg/instance/instance_test.go
+++ b/pkg/instance/instance_test.go
@@ -1,158 +1,9 @@
package stfe
import (
- "crypto"
- "net/http"
- "net/http/httptest"
"testing"
-
- "github.com/golang/mock/gomock"
- "github.com/google/certificate-transparency-go/trillian/mockclient"
- "github.com/system-transparency/stfe/pkg/testdata"
- "github.com/system-transparency/stfe/pkg/types"
)
-type testInstance struct {
- ctrl *gomock.Controller
- client *mockclient.MockTrillianLogClient
- instance *Instance
-}
-
-// newTestInstances sets up a test instance that uses default log parameters
-// with an optional signer, see newLogParameters() for further details. The
-// SthSource is instantiated with an ActiveSthSource that has (i) the default
-// STH as the currently cosigned STH based on testdata.Ed25519VkWitness, and
-// (ii) the default STH without any cosignatures as the currently stable STH.
-func newTestInstance(t *testing.T, signer crypto.Signer) *testInstance {
- t.Helper()
- ctrl := gomock.NewController(t)
- client := mockclient.NewMockTrillianLogClient(ctrl)
- return &testInstance{
- ctrl: ctrl,
- client: client,
- instance: &Instance{
- Client: client,
- LogParameters: newLogParameters(t, signer),
- SthSource: &ActiveSthSource{
- client: client,
- logParameters: newLogParameters(t, signer),
- currCosth: testdata.DefaultCosth(t, testdata.Ed25519VkLog, [][32]byte{testdata.Ed25519VkWitness}),
- nextCosth: testdata.DefaultCosth(t, testdata.Ed25519VkLog, nil),
- cosignatureFrom: make(map[[types.NamespaceFingerprintSize]byte]bool),
- },
- },
- }
-}
-
-// getHandlers returns all endpoints that use HTTP GET as a map to handlers
-func (ti *testInstance) getHandlers(t *testing.T) map[Endpoint]Handler {
- t.Helper()
- return map[Endpoint]Handler{
- EndpointGetLatestSth: Handler{Instance: ti.instance, Handler: getLatestSth, Endpoint: EndpointGetLatestSth, Method: http.MethodGet},
- EndpointGetStableSth: Handler{Instance: ti.instance, Handler: getStableSth, Endpoint: EndpointGetStableSth, Method: http.MethodGet},
- EndpointGetCosignedSth: Handler{Instance: ti.instance, Handler: getCosignedSth, Endpoint: EndpointGetCosignedSth, Method: http.MethodGet},
- }
-}
-
-// postHandlers returns all endpoints that use HTTP POST as a map to handlers
-func (ti *testInstance) postHandlers(t *testing.T) map[Endpoint]Handler {
- t.Helper()
- return map[Endpoint]Handler{
- EndpointAddEntry: Handler{Instance: ti.instance, Handler: addEntry, Endpoint: EndpointAddEntry, Method: http.MethodPost},
- EndpointAddCosignature: Handler{Instance: ti.instance, Handler: addCosignature, Endpoint: EndpointAddCosignature, Method: http.MethodPost},
- EndpointGetConsistencyProof: Handler{Instance: ti.instance, Handler: getConsistencyProof, Endpoint: EndpointGetConsistencyProof, Method: http.MethodPost},
- EndpointGetProofByHash: Handler{Instance: ti.instance, Handler: getProofByHash, Endpoint: EndpointGetProofByHash, Method: http.MethodPost},
- EndpointGetEntries: Handler{Instance: ti.instance, Handler: getEntries, Endpoint: EndpointGetEntries, Method: http.MethodPost},
- }
-}
-
-// getHandler must return a particular HTTP GET handler
-func (ti *testInstance) getHandler(t *testing.T, endpoint Endpoint) Handler {
- t.Helper()
- handler, ok := ti.getHandlers(t)[endpoint]
- if !ok {
- t.Fatalf("must return HTTP GET handler for endpoint: %s", endpoint)
- }
- return handler
-}
-
-// postHandler must return a particular HTTP POST handler
-func (ti *testInstance) postHandler(t *testing.T, endpoint Endpoint) Handler {
- t.Helper()
- handler, ok := ti.postHandlers(t)[endpoint]
- if !ok {
- t.Fatalf("must return HTTP POST handler for endpoint: %s", endpoint)
- }
- return handler
-}
-
-// TestHandlers checks that we configured all endpoints and that there are no
-// unexpected ones.
-func TestHandlers(t *testing.T) {
- endpoints := map[Endpoint]bool{
- EndpointAddEntry: false,
- EndpointAddCosignature: false,
- EndpointGetLatestSth: false,
- EndpointGetStableSth: false,
- EndpointGetCosignedSth: false,
- EndpointGetConsistencyProof: false,
- EndpointGetProofByHash: false,
- EndpointGetEntries: false,
- }
- i := &Instance{nil, newLogParameters(t, nil), nil}
- for _, handler := range i.Handlers() {
- if _, ok := endpoints[handler.Endpoint]; !ok {
- t.Errorf("got unexpected endpoint: %s", handler.Endpoint)
- }
- endpoints[handler.Endpoint] = true
- }
- for endpoint, ok := range endpoints {
- if !ok {
- t.Errorf("endpoint %s is not configured", endpoint)
- }
- }
-}
-
-// TestGetHandlersRejectPost checks that all get handlers reject post requests
-func TestGetHandlersRejectPost(t *testing.T) {
- ti := newTestInstance(t, nil)
- defer ti.ctrl.Finish()
-
- for endpoint, handler := range ti.getHandlers(t) {
- t.Run(string(endpoint), func(t *testing.T) {
- s := httptest.NewServer(handler)
- defer s.Close()
-
- url := endpoint.Path(s.URL, ti.instance.LogParameters.Prefix)
- if rsp, err := http.Post(url, "application/json", nil); err != nil {
- t.Fatalf("http.Post(%s)=(_,%q), want (_,nil)", url, err)
- } else if rsp.StatusCode != http.StatusMethodNotAllowed {
- t.Errorf("http.Post(%s)=(%d,nil), want (%d, nil)", url, rsp.StatusCode, http.StatusMethodNotAllowed)
- }
- })
- }
-}
-
-// TestPostHandlersRejectGet checks that all post handlers reject get requests
-func TestPostHandlersRejectGet(t *testing.T) {
- ti := newTestInstance(t, nil)
- defer ti.ctrl.Finish()
-
- for endpoint, handler := range ti.postHandlers(t) {
- t.Run(string(endpoint), func(t *testing.T) {
- s := httptest.NewServer(handler)
- defer s.Close()
-
- url := endpoint.Path(s.URL, ti.instance.LogParameters.Prefix)
- if rsp, err := http.Get(url); err != nil {
- t.Fatalf("http.Get(%s)=(_,%q), want (_,nil)", url, err)
- } else if rsp.StatusCode != http.StatusMethodNotAllowed {
- t.Errorf("http.Get(%s)=(%d,nil), want (%d, nil)", url, rsp.StatusCode, http.StatusMethodNotAllowed)
- }
- })
- }
-}
-
-// TODO: TestHandlerPath
-func TestHandlerPath(t *testing.T) {
-}
+func TestHandlers(t *testing.T) {}
+func TestPath(t *testing.T) {}
+func TestServeHTTP(t *testing.T) {}
diff --git a/pkg/instance/metric.go b/pkg/instance/metric.go
index 7e3e8b2..db11bd2 100644
--- a/pkg/instance/metric.go
+++ b/pkg/instance/metric.go
@@ -6,11 +6,9 @@ import (
)
var (
- reqcnt monitoring.Counter // number of incoming http requests
- rspcnt monitoring.Counter // number of valid http responses
- latency monitoring.Histogram // request-response latency
- lastSthTimestamp monitoring.Gauge // unix timestamp from the most recent sth
- lastSthSize monitoring.Gauge // tree size of most recent sth
+ reqcnt monitoring.Counter // number of incoming http requests
+ rspcnt monitoring.Counter // number of valid http responses
+ latency monitoring.Histogram // request-response latency
)
func init() {
@@ -18,6 +16,4 @@ func init() {
reqcnt = mf.NewCounter("http_req", "number of http requests", "logid", "endpoint")
rspcnt = mf.NewCounter("http_rsp", "number of http requests", "logid", "endpoint", "status")
latency = mf.NewHistogram("http_latency", "http request-response latency", "logid", "endpoint", "status")
- lastSthTimestamp = mf.NewGauge("last_sth_timestamp", "unix timestamp while handling the most recent sth", "logid")
- lastSthSize = mf.NewGauge("last_sth_size", "most recent sth tree size", "logid")
}
diff --git a/pkg/instance/request.go b/pkg/instance/request.go
deleted file mode 100644
index 7475b26..0000000
--- a/pkg/instance/request.go
+++ /dev/null
@@ -1,77 +0,0 @@
-package stfe
-
-import (
- "crypto/ed25519"
- "fmt"
- "net/http"
-
- "github.com/system-transparency/stfe/pkg/types"
-)
-
-func (i *Instance) leafRequestFromHTTP(r *http.Request) (*types.LeafRequest, error) {
- var req types.LeafRequest
- if err := req.UnmarshalASCII(r.Body); err != nil {
- return nil, fmt.Errorf("UnmarshalASCII: %v", err)
- }
-
- vk := ed25519.PublicKey(req.VerificationKey[:])
- msg := req.Message.Marshal()
- sig := req.Signature[:]
- if !ed25519.Verify(vk, msg, sig) {
- return nil, fmt.Errorf("invalid signature")
- }
- // TODO: check shard hint
- // TODO: check domain hint
- return &req, nil
-}
-
-func (i *Instance) cosignatureRequestFromHTTP(r *http.Request) (*types.CosignatureRequest, error) {
- var req types.CosignatureRequest
- if err := req.UnmarshalASCII(r.Body); err != nil {
- return nil, fmt.Errorf("unpackOctetPost: %v", err)
- }
- if _, ok := i.Witnesses[*req.KeyHash]; !ok {
- return nil, fmt.Errorf("Unknown witness: %x", req.KeyHash)
- }
- return &req, nil
-}
-
-func (i *Instance) consistencyProofRequestFromHTTP(r *http.Request) (*types.ConsistencyProofRequest, error) {
- var req types.ConsistencyProofRequest
- if err := req.UnmarshalASCII(r.Body); err != nil {
- return nil, fmt.Errorf("UnmarshalASCII: %v", err)
- }
- if req.OldSize < 1 {
- return nil, fmt.Errorf("OldSize(%d) must be larger than zero", req.OldSize)
- }
- if req.NewSize <= req.OldSize {
- return nil, fmt.Errorf("NewSize(%d) must be larger than OldSize(%d)", req.NewSize, req.OldSize)
- }
- return &req, nil
-}
-
-func (i *Instance) inclusionProofRequestFromHTTP(r *http.Request) (*types.InclusionProofRequest, error) {
- var req types.InclusionProofRequest
- if err := req.UnmarshalASCII(r.Body); err != nil {
- return nil, fmt.Errorf("UnmarshalASCII: %v", err)
- }
- if req.TreeSize < 1 {
- return nil, fmt.Errorf("TreeSize(%d) must be larger than zero", req.TreeSize)
- }
- return &req, nil
-}
-
-func (i *Instance) leavesRequestFromHTTP(r *http.Request) (*types.LeavesRequest, error) {
- var req types.LeavesRequest
- if err := req.UnmarshalASCII(r.Body); err != nil {
- return nil, fmt.Errorf("UnmarshalASCII: %v", err)
- }
-
- if req.StartSize > req.EndSize {
- return nil, fmt.Errorf("StartSize(%d) must be less than or equal to EndSize(%d)", req.StartSize, req.EndSize)
- }
- if req.EndSize-req.StartSize+1 > uint64(i.MaxRange) {
- req.EndSize = req.StartSize + uint64(i.MaxRange) - 1
- }
- return &req, nil
-}
diff --git a/pkg/instance/request_test.go b/pkg/instance/request_test.go
deleted file mode 100644
index 0a5a908..0000000
--- a/pkg/instance/request_test.go
+++ /dev/null
@@ -1,318 +0,0 @@
-package stfe
-
-import (
- "bytes"
- //"fmt"
- "reflect"
- "testing"
- //"testing/iotest"
-
- "net/http"
-
- "github.com/system-transparency/stfe/pkg/testdata"
- "github.com/system-transparency/stfe/pkg/types"
-)
-
-func TestParseAddEntryV1Request(t *testing.T) {
- lp := newLogParameters(t, nil)
- for _, table := range []struct {
- description string
- breq *bytes.Buffer
- wantErr bool
- }{
- {
- description: "invalid: nothing to unpack",
- breq: bytes.NewBuffer(nil),
- wantErr: true,
- },
- {
- description: "invalid: not a signed checksum entry",
- breq: testdata.AddCosignatureBuffer(t, testdata.DefaultSth(t, testdata.Ed25519VkLog), &testdata.Ed25519SkWitness, &testdata.Ed25519VkWitness),
- wantErr: true,
- },
- {
- description: "invalid: untrusted submitter", // only testdata.Ed25519VkSubmitter is registered by default in newLogParameters()
-
- breq: testdata.AddSignedChecksumBuffer(t, testdata.Ed25519SkSubmitter2, testdata.Ed25519VkSubmitter2),
- wantErr: true,
- },
- {
- description: "invalid: signature does not cover message",
-
- breq: testdata.AddSignedChecksumBuffer(t, testdata.Ed25519SkSubmitter2, testdata.Ed25519VkSubmitter),
- wantErr: true,
- },
- {
- description: "valid",
- breq: testdata.AddSignedChecksumBuffer(t, testdata.Ed25519SkSubmitter, testdata.Ed25519VkSubmitter),
- }, // TODO: add test case that disables submitter policy (i.e., unregistered namespaces are accepted)
- } {
- url := EndpointAddEntry.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/octet-stream")
-
- _, err = lp.parseAddEntryV1Request(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)
- }
- }
-}
-
-func TestParseAddCosignatureV1Request(t *testing.T) {
- lp := newLogParameters(t, nil)
- for _, table := range []struct {
- description string
- breq *bytes.Buffer
- wantErr bool
- }{
- {
- description: "invalid: nothing to unpack",
- breq: bytes.NewBuffer(nil),
- wantErr: true,
- },
- {
- description: "invalid: not a cosigned sth",
- breq: testdata.AddSignedChecksumBuffer(t, testdata.Ed25519SkSubmitter, testdata.Ed25519VkSubmitter),
- wantErr: true,
- },
- {
- description: "invalid: no cosignature",
- breq: testdata.AddCosignatureBuffer(t, testdata.DefaultSth(t, testdata.Ed25519VkLog), &testdata.Ed25519SkWitness, nil),
- wantErr: true,
- },
- {
- description: "invalid: untrusted witness", // only testdata.Ed25519VkWitness is registered by default in newLogParameters()
- breq: testdata.AddCosignatureBuffer(t, testdata.DefaultSth(t, testdata.Ed25519VkLog), &testdata.Ed25519SkWitness2, &testdata.Ed25519VkWitness2),
- wantErr: true,
- },
- {
- description: "invalid: signature does not cover message",
- breq: testdata.AddCosignatureBuffer(t, testdata.DefaultSth(t, testdata.Ed25519VkLog), &testdata.Ed25519SkWitness2, &testdata.Ed25519VkWitness),
- wantErr: true,
- },
- {
- description: "valid",
- breq: testdata.AddCosignatureBuffer(t, testdata.DefaultSth(t, testdata.Ed25519VkLog), &testdata.Ed25519SkWitness, &testdata.Ed25519VkWitness),
- }, // TODO: add test case that disables witness policy (i.e., unregistered namespaces are accepted)
- } {
- 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/octet-stream")
-
- _, err = lp.parseAddCosignatureV1Request(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)
- }
- }
-}
-
-func TestNewGetConsistencyProofRequest(t *testing.T) {
- lp := newLogParameters(t, nil)
- for _, table := range []struct {
- description string
- req *types.GetConsistencyProofV1
- wantErr bool
- }{
- {
- description: "invalid: nothing to unpack",
- req: nil,
- wantErr: true,
- },
- {
- description: "invalid: first must be larger than zero",
- req: &types.GetConsistencyProofV1{First: 0, Second: 0},
- wantErr: true,
- },
- {
- description: "invalid: second must be larger than first",
- req: &types.GetConsistencyProofV1{First: 2, Second: 1},
- wantErr: true,
- },
- {
- description: "valid",
- req: &types.GetConsistencyProofV1{First: 1, Second: 2},
- },
- } {
- var buf *bytes.Buffer
- if table.req == nil {
- buf = bytes.NewBuffer(nil)
- } else {
- buf = bytes.NewBuffer(marshal(t, *table.req))
- }
-
- url := EndpointGetConsistencyProof.Path("http://example.com", lp.Prefix)
- req, err := http.NewRequest("POST", url, buf)
- if err != nil {
- t.Fatalf("failed creating http request: %v", err)
- }
- req.Header.Set("Content-Type", "application/octet-stream")
-
- _, err = lp.parseGetConsistencyProofV1Request(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)
- }
- }
-}
-
-func TestNewGetProofByHashRequest(t *testing.T) {
- lp := newLogParameters(t, nil)
- for _, table := range []struct {
- description string
- req *types.GetProofByHashV1
- wantErr bool
- }{
- {
- description: "invalid: nothing to unpack",
- req: nil,
- wantErr: true,
- },
- {
- description: "invalid: no entry in an empty tree",
- req: &types.GetProofByHashV1{TreeSize: 0, Hash: testdata.LeafHash},
- wantErr: true,
- },
- {
- description: "valid",
- req: &types.GetProofByHashV1{TreeSize: 1, Hash: testdata.LeafHash},
- },
- } {
- var buf *bytes.Buffer
- if table.req == nil {
- buf = bytes.NewBuffer(nil)
- } else {
- buf = bytes.NewBuffer(marshal(t, *table.req))
- }
-
- url := EndpointGetProofByHash.Path("http://example.com", lp.Prefix)
- req, err := http.NewRequest("POST", url, buf)
- if err != nil {
- t.Fatalf("failed creating http request: %v", err)
- }
- req.Header.Set("Content-Type", "application/octet-stream")
-
- _, err = lp.parseGetProofByHashV1Request(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)
- }
- }
-}
-
-func TestParseGetEntriesV1Request(t *testing.T) {
- lp := newLogParameters(t, nil)
- for _, table := range []struct {
- description string
- req *types.GetEntriesV1
- wantErr bool
- wantReq *types.GetEntriesV1
- }{
- {
- description: "invalid: nothing to unpack",
- req: nil,
- wantErr: true,
- },
- {
- description: "invalid: start must be larger than end",
- req: &types.GetEntriesV1{Start: 1, End: 0},
- wantErr: true,
- },
- {
- description: "valid: want truncated range",
- req: &types.GetEntriesV1{Start: 0, End: uint64(testdata.MaxRange)},
- wantReq: &types.GetEntriesV1{Start: 0, End: uint64(testdata.MaxRange) - 1},
- },
- {
- description: "valid",
- req: &types.GetEntriesV1{Start: 0, End: 0},
- wantReq: &types.GetEntriesV1{Start: 0, End: 0},
- },
- } {
- var buf *bytes.Buffer
- if table.req == nil {
- buf = bytes.NewBuffer(nil)
- } else {
- buf = bytes.NewBuffer(marshal(t, *table.req))
- }
-
- url := EndpointGetEntries.Path("http://example.com", lp.Prefix)
- req, err := http.NewRequest("POST", url, buf)
- if err != nil {
- t.Fatalf("failed creating http request: %v", err)
- }
- req.Header.Set("Content-Type", "application/octet-stream")
-
- output, err := lp.parseGetEntriesV1Request(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)
- }
- if err != nil {
- continue
- }
- if got, want := output, table.wantReq; !reflect.DeepEqual(got, want) {
- t.Errorf("got request\n%v\n\tbut wanted\n%v\n\t in test %q", got, want, table.description)
- }
- }
-}
-
-func TestUnpackOctetPost(t *testing.T) {
- for _, table := range []struct {
- description string
- req *http.Request
- out interface{}
- wantErr bool
- }{
- //{
- // description: "invalid: cannot read request body",
- // req: func() *http.Request {
- // req, err := http.NewRequest(http.MethodPost, "", iotest.ErrReader(fmt.Errorf("bad reader")))
- // if err != nil {
- // t.Fatalf("must make new http request: %v", err)
- // }
- // return req
- // }(),
- // out: &types.StItem{},
- // wantErr: true,
- //}, // testcase requires Go 1.16
- {
- description: "invalid: cannot unmarshal",
- req: func() *http.Request {
- req, err := http.NewRequest(http.MethodPost, "", bytes.NewBuffer(nil))
- if err != nil {
- t.Fatalf("must make new http request: %v", err)
- }
- return req
- }(),
- out: &types.StItem{},
- wantErr: true,
- },
- {
- description: "valid",
- req: func() *http.Request {
- req, err := http.NewRequest(http.MethodPost, "", bytes.NewBuffer([]byte{0}))
- if err != nil {
- t.Fatalf("must make new http request: %v", err)
- }
- return req
- }(),
- out: &struct{ SomeUint8 uint8 }{},
- },
- } {
- err := unpackOctetPost(table.req, table.out)
- if got, want := err != nil, table.wantErr; got != want {
- t.Errorf("got error %v but wanted %v in test %q", got, want, table.description)
- }
- }
-}
-
-func marshal(t *testing.T, out interface{}) []byte {
- b, err := types.Marshal(out)
- if err != nil {
- t.Fatalf("must marshal: %v", err)
- }
- return b
-}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-22 16:43:20 +0000