blob: 69f54f9fc6914e8608e1411b70b57a7f079caa52 [file] [log] [blame]
// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package cve5
import (
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"net/url"
"reflect"
"strconv"
"strings"
"testing"
"time"
)
const (
testApiKey = "test_api_key"
testApiOrg = "test_api_org"
testApiUser = "test_api_user"
defaultTestCVEID = "CVE-2022-0000"
)
var (
defaultTestCVE = newTestCVE(defaultTestCVEID, StateReserved, "2022")
defaultTestCVEs = AssignedCVEList{
defaultTestCVE,
newTestCVE("CVE-2022-0001", StateReserved, "2022")}
defaultTestQuota = &Quota{
Quota: 10,
Reserved: 3,
Available: 7,
}
defaultTestOrg = &Org{
Name: "An Org",
ShortName: testApiOrg,
UUID: "000-000-000",
}
)
func readTestData(t *testing.T, filename string) *CVERecord {
record, err := Read(fmt.Sprintf("../cve5/testdata/%s", filename))
if err != nil {
t.Fatalf("could not read test data from file %s: %v", filename, err)
}
return record
}
var defaultTestCVERecord = func(t *testing.T) *CVERecord {
return readTestData(t, "basic-example.json")
}
var (
testTime2022 = time.Date(2022, 1, 1, 0, 0, 0, 0, time.UTC)
testTime2000 = time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
testTime1999 = time.Date(1999, 1, 1, 0, 0, 0, 0, time.UTC)
testTime1992 = time.Date(1992, 1, 1, 0, 0, 0, 0, time.UTC)
)
func newTestCVE(id string, state State, year string) AssignedCVE {
return AssignedCVE{
ID: id,
Year: year,
State: state,
CNA: testApiOrg,
Reserved: testTime2022,
RequestedBy: RequestedBy{
CNA: testApiOrg,
User: testApiUser,
},
}
}
func newTestClientAndServer(handler http.HandlerFunc) (*Client, *httptest.Server) {
s := httptest.NewServer(handler)
c := NewClient(Config{
Endpoint: s.URL,
Key: testApiKey,
Org: testApiOrg,
User: testApiUser})
c.c = s.Client()
return c, s
}
func checkHeaders(t *testing.T, r *http.Request) {
if got, want := r.Header.Get(headerApiUser), testApiUser; got != want {
t.Errorf("HTTP Header %q = %s, want %s", headerApiUser, got, want)
}
if got, want := r.Header.Get(headerApiOrg), testApiOrg; got != want {
t.Errorf("HTTP Header %q = %s, want %s", headerApiOrg, got, want)
}
if got, want := r.Header.Get(headerApiKey), testApiKey; got != want {
t.Errorf("HTTP Header %q = %s, want %s", headerApiKey, got, want)
}
}
func newTestHandler(t *testing.T, mockStatus int, mockResponse any, validateRequest func(t *testing.T, r *http.Request)) http.HandlerFunc {
mr, err := json.Marshal(mockResponse)
if err != nil {
t.Fatalf("could not marshal mock response: %v", err)
}
return func(w http.ResponseWriter, r *http.Request) {
if validateRequest != nil {
validateRequest(t, r)
}
checkHeaders(t, r)
w.WriteHeader(mockStatus)
_, err := w.Write(mr)
if err != nil {
t.Errorf("could not write mock response body: %v", err)
}
}
}
func newTestHandlerMultiPage(t *testing.T, mockResponses []any, validateRequest func(t *testing.T, r *http.Request)) http.HandlerFunc {
var mrs [][]byte
for _, r := range mockResponses {
mr, err := json.Marshal(r)
if err != nil {
t.Fatalf("could not marshal mock response: %v", err)
}
mrs = append(mrs, mr)
}
return func(w http.ResponseWriter, r *http.Request) {
if validateRequest != nil {
validateRequest(t, r)
}
parsed, err := url.ParseQuery(r.URL.RawQuery)
if err != nil {
t.Errorf("could not parse URL query: %v", err)
}
var page int
if pages := parsed["page"]; len(pages) >= 1 {
page, err = strconv.Atoi(parsed["page"][0])
if err != nil {
t.Errorf("could not parse page as int: %v", err)
}
}
checkHeaders(t, r)
w.WriteHeader(http.StatusOK)
_, err = w.Write(mrs[page])
if err != nil {
t.Errorf("could not write mock response body: %v", err)
}
}
}
func TestCreateReserveIDsRequest(t *testing.T) {
tests := []struct {
opts ReserveOptions
wantParams string
}{
{
opts: ReserveOptions{
NumIDs: 1,
Year: 2000,
Mode: SequentialRequest,
},
wantParams: "amount=1&cve_year=2000&short_name=test_api_org",
},
{
opts: ReserveOptions{
NumIDs: 2,
Year: 2022,
Mode: SequentialRequest,
},
wantParams: "amount=2&batch_type=sequential&cve_year=2022&short_name=test_api_org",
},
{
opts: ReserveOptions{
NumIDs: 3,
Year: 2010,
Mode: NonsequentialRequest,
},
wantParams: "amount=3&batch_type=nonsequential&cve_year=2010&short_name=test_api_org",
},
}
for _, test := range tests {
t.Run(fmt.Sprintf("NumIDs=%d/Year=%d/Mode=%s", test.opts.NumIDs, test.opts.Year, test.opts.Mode), func(t *testing.T) {
c, s := newTestClientAndServer(nil)
defer s.Close()
req, err := c.createReserveIDsRequest(test.opts)
if err != nil {
t.Fatalf("unexpected error getting reserve ID request: %v", err)
}
if got, want := req.URL.RawQuery, test.wantParams; got != want {
t.Errorf("incorrect request params: got %v, want %v", got, want)
}
})
}
}
type queryFunc func(t *testing.T, c *Client) (any, error)
var (
reserveIDsQuery = func(t *testing.T, c *Client) (any, error) {
return c.ReserveIDs(ReserveOptions{
NumIDs: 2,
Year: 2002,
Mode: SequentialRequest,
})
}
retrieveQuotaQuery = func(t *testing.T, c *Client) (any, error) {
return c.RetrieveQuota()
}
retrieveIDQuery = func(t *testing.T, c *Client) (any, error) {
return c.RetrieveID(defaultTestCVERecord(t).Metadata.ID)
}
retrieveRecordQuery = func(t *testing.T, c *Client) (any, error) {
return c.RetrieveRecord(defaultTestCVERecord(t).Metadata.ID)
}
createRecordQuery = func(t *testing.T, c *Client) (any, error) {
return c.CreateRecord(defaultTestCVE.ID, &defaultTestCVERecord(t).Containers)
}
updateRecordQuery = func(t *testing.T, c *Client) (any, error) {
return c.UpdateRecord(defaultTestCVE.ID, &defaultTestCVERecord(t).Containers)
}
retrieveOrgQuery = func(t *testing.T, c *Client) (any, error) {
return c.RetrieveOrg()
}
listOrgCVEsQuery = func(t *testing.T, c *Client) (any, error) {
return c.ListOrgCVEs(&ListOptions{})
}
)
func TestAllSuccess(t *testing.T) {
defaultTestCVERecord := defaultTestCVERecord(t)
tests := []struct {
name string
mockStatus int
mockResponse any
query queryFunc
wantHTTPMethod string
wantPath string
want any
}{
{
name: "ReserveIDs",
query: reserveIDsQuery,
mockStatus: http.StatusOK,
mockResponse: reserveIDsResponse{
CVEs: defaultTestCVEs},
wantHTTPMethod: http.MethodPost,
wantPath: "/api/cve-id",
want: defaultTestCVEs,
},
{
name: "ReserveIDs/partial content ok",
query: reserveIDsQuery,
mockStatus: http.StatusPartialContent,
mockResponse: reserveIDsResponse{
CVEs: AssignedCVEList{defaultTestCVE}},
wantHTTPMethod: http.MethodPost,
wantPath: "/api/cve-id",
want: AssignedCVEList{defaultTestCVE},
},
{
name: "RetrieveQuota",
query: retrieveQuotaQuery,
mockStatus: http.StatusOK,
mockResponse: defaultTestQuota,
wantHTTPMethod: http.MethodGet,
wantPath: "/api/org/test_api_org/id_quota",
want: defaultTestQuota,
},
{
name: "RetrieveID",
query: retrieveIDQuery,
mockStatus: http.StatusOK,
mockResponse: defaultTestCVE,
wantHTTPMethod: http.MethodGet,
wantPath: "/api/cve-id/CVE-2022-0000",
want: &defaultTestCVE,
},
{
name: "RetrieveRecord",
query: retrieveRecordQuery,
mockStatus: http.StatusOK,
mockResponse: defaultTestCVERecord,
wantHTTPMethod: http.MethodGet,
wantPath: "/api/cve/CVE-2022-0000",
want: defaultTestCVERecord,
},
{
name: "CreateRecord",
query: createRecordQuery,
mockStatus: http.StatusOK,
mockResponse: createResponse{*defaultTestCVERecord},
wantHTTPMethod: http.MethodPost,
wantPath: "/api/cve/CVE-2022-0000/cna",
want: defaultTestCVERecord,
},
{
name: "UpdateRecord",
query: updateRecordQuery,
mockStatus: http.StatusOK,
mockResponse: updateResponse{*defaultTestCVERecord},
wantHTTPMethod: http.MethodPut,
wantPath: "/api/cve/CVE-2022-0000/cna",
want: defaultTestCVERecord,
},
{
name: "RetrieveOrg",
query: retrieveOrgQuery,
mockStatus: http.StatusOK,
mockResponse: defaultTestOrg,
wantHTTPMethod: http.MethodGet,
wantPath: "/api/org/test_api_org",
want: defaultTestOrg,
},
{
name: "ListOrgCVEs/single page",
query: listOrgCVEsQuery,
mockStatus: http.StatusOK,
mockResponse: listOrgCVEsResponse{
CurrentPage: 0,
NextPage: -1,
CVEs: defaultTestCVEs,
},
wantHTTPMethod: http.MethodGet,
wantPath: "/api/cve-id",
want: defaultTestCVEs,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
validateRequest := func(t *testing.T, r *http.Request) {
if got, want := r.Method, test.wantHTTPMethod; got != want {
t.Errorf("incorrect HTTP method: got %v, want %v", got, want)
}
if got, want := r.URL.Path, test.wantPath; got != want {
t.Errorf("incorrect request URL path: got %v, want %v", got, want)
}
}
c, s := newTestClientAndServer(
newTestHandler(t, test.mockStatus, test.mockResponse, validateRequest))
defer s.Close()
got, err := test.query(t, c)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if want := test.want; !reflect.DeepEqual(got, want) {
t.Errorf("got %v, want %v", got, want)
}
})
}
}
func TestAllFail(t *testing.T) {
tests := []struct {
name string
query queryFunc
}{
{
name: "ReserveIDs",
query: reserveIDsQuery,
},
{
name: "RetrieveQuota",
query: retrieveQuotaQuery,
},
{
name: "RetrieveID",
query: retrieveIDQuery,
},
{
name: "RetrieveRecord",
query: retrieveRecordQuery,
},
{
name: "CreateRecord",
query: createRecordQuery,
},
{
name: "UpdateRecord",
query: updateRecordQuery,
},
{
name: "RetrieveOrg",
query: retrieveOrgQuery,
},
{
name: "ListOrgCVEs",
query: listOrgCVEsQuery,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
mockStatus := http.StatusUnauthorized
mockResponse := apiError{
Error: "more info",
Message: "even more info",
}
c, s := newTestClientAndServer(newTestHandler(t, mockStatus, mockResponse, nil))
defer s.Close()
want := "401 Unauthorized: more info: even more info"
_, err := test.query(t, c)
if err == nil {
t.Fatalf("unexpected success: want err %v", want)
}
if got := err.Error(); !strings.Contains(got, want) {
t.Errorf("unexpected error string: got %v, want %v", got, want)
}
})
}
}
func TestCreateListOrgCVEsRequest(t *testing.T) {
tests := []struct {
opts ListOptions
page int
wantParams string
}{
{
opts: ListOptions{
State: StateReserved,
Year: 2000,
ReservedBefore: &testTime2022,
ReservedAfter: &testTime1999,
ModifiedBefore: &testTime2000,
ModifiedAfter: &testTime1992,
},
page: 0,
wantParams: "cve_id_year=2000&state=RESERVED&time_modified.gt=1992-01-01T00%3A00%3A00Z&time_modified.lt=2000-01-01T00%3A00%3A00Z&time_reserved.gt=1999-01-01T00%3A00%3A00Z&time_reserved.lt=2022-01-01T00%3A00%3A00Z",
},
{
opts: ListOptions{
State: StateRejected,
Year: 1999,
ReservedBefore: &testTime1999,
ReservedAfter: &testTime2000,
ModifiedBefore: &testTime1992,
ModifiedAfter: &testTime2022,
},
page: 1,
wantParams: "cve_id_year=1999&page=1&state=REJECTED&time_modified.gt=2022-01-01T00%3A00%3A00Z&time_modified.lt=1992-01-01T00%3A00%3A00Z&time_reserved.gt=2000-01-01T00%3A00%3A00Z&time_reserved.lt=1999-01-01T00%3A00%3A00Z",
},
{
opts: ListOptions{
State: StatePublished,
Year: 2000,
},
page: 2,
wantParams: "cve_id_year=2000&page=2&state=PUBLISHED",
},
}
for _, test := range tests {
t.Run(fmt.Sprintf("State=%s/Year=%d/ReservedBefore=%s/ReservedAfter=%s/ModifiedBefore=%s/ModifiedAfter=%s", test.opts.State, test.opts.Year, test.opts.ReservedBefore, test.opts.ReservedAfter, test.opts.ModifiedBefore, test.opts.ModifiedAfter), func(t *testing.T) {
c, s := newTestClientAndServer(nil)
defer s.Close()
req, err := c.createListOrgCVEsRequest(&test.opts, test.page)
if err != nil {
t.Fatalf("unexpected error creating ListOrgCVEs request: %v", err)
}
if got, want := req.URL.RawQuery, test.wantParams; got != want {
t.Errorf("incorrect request params: got %v, want %v", got, want)
}
})
}
}
func TestListOrgCVEsMultiPage(t *testing.T) {
extraCVE := newTestCVE("CVE-2000-1234", StateReserved, "2000")
mockResponses := []any{
listOrgCVEsResponse{
CurrentPage: 0,
NextPage: 1,
CVEs: defaultTestCVEs,
},
listOrgCVEsResponse{
CurrentPage: 1,
NextPage: -1,
CVEs: AssignedCVEList{extraCVE},
},
}
c, s := newTestClientAndServer(
newTestHandlerMultiPage(t, mockResponses, nil))
defer s.Close()
got, err := c.ListOrgCVEs(nil)
if err != nil {
t.Fatalf("unexpected error listing org cves: %v", err)
}
want := append(defaultTestCVEs, extraCVE)
if !reflect.DeepEqual(got, want) {
t.Errorf("got %v, want %v", got, want)
}
}