Syncing between source head and git
diff --git a/api/api.go b/api/api.go
index d419c40..61e0129 100644
--- a/api/api.go
+++ b/api/api.go
@@ -1,5 +1,5 @@
/*
-Copyright 2017 Google Inc.
+Copyright 2019 Google Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -19,6 +19,7 @@
import (
"bytes"
+ "context"
"crypto/tls"
"crypto/x509"
"encoding/base64"
@@ -33,33 +34,27 @@
"strings"
"time"
+ epb "github.com/golang/protobuf/ptypes/empty"
"github.com/golang/protobuf/jsonpb"
"github.com/golang/protobuf/proto"
- "github.com/golang/protobuf/ptypes/empty"
"github.com/google/go-cmp/cmp"
+
"github.com/maps-booking-v3/utils"
fpb "github.com/maps-booking-v3/feeds"
mpb "github.com/maps-booking-v3/v3"
- wpb "github.com/maps-booking-v3/waitlist"
+ wpb "github.com/maps-booking-v3/v3waitlist"
)
const (
- userID = "0"
- firstName = "Jane"
- lastName = "Doe"
- telephone = "+1 800-789-7890"
- email = "test@example.com"
+ userID = "0"
+ firstName = "Jane"
+ lastName = "Doe"
+ telephone = "+1 800-789-7890"
+ email = "test@example.com"
+ reqTimeout = 10 * time.Second
)
-// HTTPConnection is a convenience struct for holding connection-related objects.
-type HTTPConnection struct {
- client *http.Client
- credentials string
- marshaler *jsonpb.Marshaler
- baseURL string
-}
-
func setupCertConfig(caFile string, fullServerName string) (*tls.Config, error) {
if caFile == "" {
return nil, nil
@@ -78,9 +73,9 @@
}, nil
}
-// InitHTTPConnection creates and returns a new HTTPConnection object
+// InitHTTPConnection creates and returns a new utils.HTTPConnection object
// with a given server address and username/password.
-func InitHTTPConnection(serverAddr string, credentialsFile string, caFile string, fullServerName string) (*HTTPConnection, error) {
+func InitHTTPConnection(serverAddr string, credentialsFile string, caFile string, fullServerName string) (*utils.HTTPConnection, error) {
// Set up username/password.
var credentials string
if credentialsFile != "" {
@@ -98,24 +93,16 @@
if config != nil {
protocol = "https"
}
- return &HTTPConnection{
- client: &http.Client{
- Timeout: 10 * time.Second,
+ return &utils.HTTPConnection{
+ Client: &http.Client{
Transport: &http.Transport{TLSClientConfig: config},
},
- credentials: credentials,
- marshaler: &jsonpb.Marshaler{OrigName: true},
- baseURL: protocol + "://" + serverAddr,
+ Credentials: credentials,
+ Marshaler: &jsonpb.Marshaler{OrigName: true},
+ BaseURL: protocol + "://" + serverAddr,
}, nil
}
-func (h HTTPConnection) getURL(rpcName string) string {
- if rpcName != "" {
- return h.baseURL + "/v3/" + rpcName
- }
- return h.baseURL
-}
-
// Bookings is a convenience type for a booking array.
type Bookings []*mpb.Booking
@@ -132,32 +119,58 @@
}
// HealthCheck performs a health check.
-func HealthCheck(conn *HTTPConnection) error {
- utils.LogFlow("Health Check", "Start")
- defer utils.LogFlow("Health Check", "End")
+func HealthCheck(ctx context.Context, logger *log.Logger, conn *utils.HTTPConnection) error {
+ utils.LogFlow(logger, "Health Check", "Start")
+ defer utils.LogFlow(logger, "Health Check", "End")
- httpReq, err := http.NewRequest("GET", conn.getURL("HealthCheck"), nil)
- httpReq.Header.Set("Authorization", conn.credentials)
+ fmt.Println(conn.GetURL("HealthCheck"))
+ httpReq, err := http.NewRequest("GET", conn.GetURL("HealthCheck"), nil)
+ reqCtx, cancel := context.WithTimeout(ctx, reqTimeout)
+ defer cancel()
+ httpReq = httpReq.WithContext(reqCtx)
+ httpReq.Header.Set("Authorization", conn.Credentials)
// See if we get a response.
- resp, err := conn.client.Do(httpReq)
+ resp, err := conn.Client.Do(httpReq)
+ if err := ctx.Err(); err != nil {
+ panic(fmt.Sprintf("Encountered context error: %s", err.Error()))
+ }
if err != nil {
return fmt.Errorf("Health check failed to connect to server: %v", err)
} else if resp.StatusCode != 200 {
return fmt.Errorf("Health check returned unhealthy status: %s", resp.Status)
}
- log.Printf("health check success! Got status: %s", resp.Status)
+ logger.Printf("health check success! Got status: %s", resp.Status)
return nil
}
-// sendRequest sets up and sends the relevant HTTP request to the server and returns the HTTP response.
-func sendRequest(rpcName string, req string, conn *HTTPConnection) (string, error) {
- httpReq, err := http.NewRequest("POST", conn.getURL(rpcName), bytes.NewBuffer([]byte(req)))
- httpReq.Header.Set("Content-Type", "application/json")
- httpReq.Header.Set("Authorization", conn.credentials)
- log.Printf("%v Request. Sent(unix): %s, Url: %v, Method: %v, Header: %v, Body: %v\n", rpcName, time.Now().UTC().Format(time.RFC850), httpReq.URL, httpReq.Method, httpReq.Header, httpReq.Body)
+func getLogSafeHeader(header http.Header) http.Header {
+ logHeader := make(http.Header)
+ for k, v := range header {
+ if k == "Authorization" {
+ logHeader.Set("Authorization", "VALUE REDACTED.")
+ continue
+ }
+ logHeader[k] = v
+ }
+ return logHeader
+}
- httpResp, err := conn.client.Do(httpReq)
+// sendRequest sets up and sends the relevant HTTP request to the server and returns the HTTP response.
+func sendRequest(ctx context.Context, logger *log.Logger, rpcName string, req string, conn *utils.HTTPConnection) (string, error) {
+ httpReq, err := http.NewRequest("POST", conn.GetURL(rpcName), bytes.NewBuffer([]byte(req)))
+ reqCtx, cancel := context.WithTimeout(ctx, reqTimeout)
+ defer cancel()
+ httpReq = httpReq.WithContext(reqCtx)
+ httpReq.Header.Set("Content-Type", "application/json")
+ httpReq.Header.Set("Authorization", conn.Credentials)
+ logHeader := getLogSafeHeader(httpReq.Header)
+ logger.Printf("%v Request. Sent(unix): %s, Url: %v, Method: %v, Header: %v, Body: %v\n", rpcName, time.Now().UTC().Format(time.RFC850), httpReq.URL, httpReq.Method, logHeader, httpReq.Body)
+
+ httpResp, err := conn.Client.Do(httpReq)
+ if err := ctx.Err(); err != nil {
+ panic(fmt.Sprintf("Encountered context error: %s", err.Error()))
+ }
if err != nil {
return "", fmt.Errorf("invalid response. %s yielded error: %v", rpcName, err)
}
@@ -167,13 +180,13 @@
return "", fmt.Errorf("Could not read http response body")
}
bodyString := string(bodyBytes)
- log.Printf("%v Response. Received(unix): %s, Response %v\n", rpcName, time.Now().UTC().Format(time.RFC850), bodyString)
+ logger.Printf("%v Response. Received(unix): %s, Response %v\n", rpcName, time.Now().UTC().Format(time.RFC850), bodyString)
return bodyString, nil
}
// CheckAvailability performs a maps booking availability check on all supplied availability slots. This function
// returns any errors when trying to call the CheckAvailability RPC.
-func CheckAvailability(a *fpb.Availability, conn *HTTPConnection) error {
+func CheckAvailability(ctx context.Context, logger *log.Logger, a *fpb.Availability, conn *utils.HTTPConnection) error {
slot, err := utils.BuildSlotFrom(a)
if err != nil {
return fmt.Errorf("unable to build request for check availability flow. err: %v, availability record: %v", err, a.String())
@@ -181,11 +194,11 @@
reqPB := &mpb.CheckAvailabilityRequest{
Slot: slot,
}
- req, err := conn.marshaler.MarshalToString(reqPB)
+ req, err := conn.Marshaler.MarshalToString(reqPB)
if err != nil {
return fmt.Errorf("Could not convert pb3 to json: %v", reqPB)
}
- httpResp, err := sendRequest("CheckAvailability", req, conn)
+ httpResp, err := sendRequest(ctx, logger, "CheckAvailability", req, conn)
if err != nil {
return fmt.Errorf("invalid response. CheckAvailability yielded error: %v", err)
}
@@ -207,16 +220,16 @@
// BatchAvailabilityLookup performs a maps booking batch availability lookup on all supplied availability slots. This function
// returns any errors when trying to call the BatchAvailabilityLookup RPC.
-func BatchAvailabilityLookup(av []*fpb.Availability, conn *HTTPConnection) error {
+func BatchAvailabilityLookup(ctx context.Context, logger *log.Logger, av []*fpb.Availability, conn *utils.HTTPConnection) error {
reqPB, err := utils.BuildBatchAvailabilityLookupRequestFrom(av)
if err != nil {
return fmt.Errorf("unable to build request for batch availability lookup flow. err: %v, availability records: %v", err, av)
}
- req, err := conn.marshaler.MarshalToString(reqPB)
+ req, err := conn.Marshaler.MarshalToString(reqPB)
if err != nil {
return fmt.Errorf("Could not convert pb3 to json: %v", reqPB)
}
- httpResp, err := sendRequest("BatchAvailabilityLookup", req, conn)
+ httpResp, err := sendRequest(ctx, logger, "BatchAvailabilityLookup", req, conn)
if err != nil {
return fmt.Errorf("invalid response. BatchAvailabilityLookup yielded error: %v", err)
}
@@ -232,7 +245,7 @@
slotTimeReq := reqPB.GetSlotTime()[i]
slotTimeResp := resp.GetSlotTimeAvailability()[i].GetSlotTime()
if diff := cmp.Diff(slotTimeReq, slotTimeResp, cmp.Comparer(proto.Equal)); diff != "" {
- log.Printf("Slot %v differs: req=%v, resp=%v", i, slotTimeReq, slotTimeResp)
+ logger.Printf("Slot %v differs: req=%v, resp=%v", i, slotTimeReq, slotTimeResp)
diffCount++
}
}
@@ -243,7 +256,7 @@
}
// CreateBooking attempts to create bookings from availability slots.
-func CreateBooking(a *fpb.Availability, conn *HTTPConnection) (*mpb.Booking, error) {
+func CreateBooking(ctx context.Context, logger *log.Logger, a *fpb.Availability, conn *utils.HTTPConnection) (*mpb.Booking, error) {
slot, err := utils.BuildSlotFrom(a)
if err != nil {
return nil, fmt.Errorf("unable to build request for check availability flow. err: %v, availability record: %v", err, a.String())
@@ -265,12 +278,12 @@
},
IdempotencyToken: strconv.Itoa(gen.Intn(1000000)),
}
- req, err := conn.marshaler.MarshalToString(reqPB)
+ req, err := conn.Marshaler.MarshalToString(reqPB)
if err != nil {
return nil, fmt.Errorf("Could not convert pb3 to json: %v", reqPB)
}
- httpResp, err := sendRequest("CreateBooking", req, conn)
+ httpResp, err := sendRequest(ctx, logger, "CreateBooking", req, conn)
if err != nil {
return nil, fmt.Errorf("invalid response. CreateBooking yielded error: %v", err)
}
@@ -293,8 +306,8 @@
}
// Perform idempotency test.
- log.Printf("Idempotency check -- CreateBooking Request. Sent(unix): %s, Request %s", time.Now().UTC().Format(time.RFC850), reqPB.String())
- idemHTTPResp, err := sendRequest("CreateBooking", req, conn)
+ logger.Printf("Idempotency check -- CreateBooking Request. Sent(unix): %s, Request %s", time.Now().UTC().Format(time.RFC850), reqPB.String())
+ idemHTTPResp, err := sendRequest(ctx, logger, "CreateBooking", req, conn)
if err != nil {
return nil, fmt.Errorf("invalid response. Idempotency check yielded error: %v", err)
}
@@ -311,15 +324,15 @@
}
// ListBookings calls the maps booking ListBookings rpc and compares the return with all input bookings.
-func ListBookings(tB Bookings, conn *HTTPConnection) (Bookings, error) {
+func ListBookings(ctx context.Context, logger *log.Logger, tB Bookings, conn *utils.HTTPConnection) (Bookings, error) {
reqPB := &mpb.ListBookingsRequest{
UserId: userID,
}
- req, err := conn.marshaler.MarshalToString(reqPB)
+ req, err := conn.Marshaler.MarshalToString(reqPB)
if err != nil {
return nil, fmt.Errorf("Could not convert pb3 to json: %v", reqPB)
}
- httpResp, err := sendRequest("ListBookings", req, conn)
+ httpResp, err := sendRequest(ctx, logger, "ListBookings", req, conn)
if err != nil {
return nil, fmt.Errorf("invalid response. ListBookings yielded error: %v. Abandoning all booking from this flow", err)
}
@@ -330,37 +343,37 @@
gB := Bookings(resp.GetBookings())
if len(tB) == 0 {
- log.Printf("ListBookings returning %d found bookings", len(gB))
+ logger.Printf("ListBookings returning %d found bookings", len(gB))
return gB, nil
}
if len(gB) != len(tB) {
- log.Printf("ListBookings number of bookings differed unexpectedly. Got: %d, Want: %d.", len(gB), len(tB))
+ logger.Printf("ListBookings number of bookings differed unexpectedly. Got: %d, Want: %d.", len(gB), len(tB))
}
sort.Sort(gB)
sort.Sort(tB)
var out Bookings
for i := 0; i < len(tB); i++ {
if iE := utils.ValidateBooking(gB[i], tB[i]); iE != nil {
- log.Printf("ListBookings invalid, %s, abandoning slot %d/%d", iE.Error(), i, len(tB))
+ logger.Printf("ListBookings invalid, %s, abandoning slot %d/%d", iE.Error(), i, len(tB))
continue
}
out = append(out, tB[i])
}
- log.Printf("ListBookings returning %d bookings", len(out))
+ logger.Printf("ListBookings returning %d bookings", len(out))
return out, nil
}
// GetBookingStatus checks that all input bookings are in an acceptable state.
-func GetBookingStatus(b *mpb.Booking, conn *HTTPConnection) error {
+func GetBookingStatus(ctx context.Context, logger *log.Logger, b *mpb.Booking, conn *utils.HTTPConnection) error {
reqPB := &mpb.GetBookingStatusRequest{
BookingId: b.GetBookingId(),
}
- req, err := conn.marshaler.MarshalToString(reqPB)
+ req, err := conn.Marshaler.MarshalToString(reqPB)
if err != nil {
return fmt.Errorf("Could not convert pb3 to json: %v", reqPB)
}
- httpResp, err := sendRequest("GetBookingStatus", req, conn)
+ httpResp, err := sendRequest(ctx, logger, "GetBookingStatus", req, conn)
if err != nil {
return fmt.Errorf("invalid response. GetBookingStatus yielded error: %v", err)
}
@@ -377,18 +390,18 @@
}
// CancelBooking is a clean up method that cancels all supplied bookings.
-func CancelBooking(bookingID string, conn *HTTPConnection) error {
+func CancelBooking(ctx context.Context, logger *log.Logger, bookingID string, conn *utils.HTTPConnection) error {
reqPB := &mpb.UpdateBookingRequest{
Booking: &mpb.Booking{
BookingId: bookingID,
Status: mpb.BookingStatus_CANCELED,
},
}
- req, err := conn.marshaler.MarshalToString(reqPB)
+ req, err := conn.Marshaler.MarshalToString(reqPB)
if err != nil {
return fmt.Errorf("Could not convert pb3 to json: %v", reqPB)
}
- httpResp, err := sendRequest("UpdateBooking", req, conn)
+ httpResp, err := sendRequest(ctx, logger, "UpdateBooking", req, conn)
if err != nil {
return fmt.Errorf("invalid response. UpdateBooking yielded error: %v", err)
}
@@ -397,14 +410,20 @@
return fmt.Errorf("CancelBooking: Could not parse HTTP response to pb3: %v", err)
}
- if iE := utils.ValidateBooking(resp.GetBooking(), reqPB.GetBooking()); iE != nil {
+ // We only care that the correct booking was cancelled. The rest of the response content
+ // is not relevant.
+ compareBooking := &mpb.Booking{
+ BookingId: resp.GetBooking().GetBookingId(),
+ Status: resp.GetBooking().GetStatus(),
+ }
+ if iE := utils.ValidateBooking(compareBooking, reqPB.GetBooking()); iE != nil {
return fmt.Errorf("invalid response. UpdateBooking: %s", iE.Error())
}
return nil
}
// Rescheduling will attempt to create a booking, update the booking, then cancel.
-func Rescheduling(av []*fpb.Availability, conn *HTTPConnection) error {
+func Rescheduling(ctx context.Context, logger *log.Logger, av []*fpb.Availability, conn *utils.HTTPConnection) error {
var slots []*fpb.Availability
for _, v := range utils.BuildMerchantServiceMap(av) {
// Need at least two slots for reschedule.
@@ -419,7 +438,7 @@
return errors.New("no suitable availability for rescheduling flow. exiting")
}
// Book first slot.
- newBooking, err := CreateBooking(slots[0], conn)
+ newBooking, err := CreateBooking(ctx, logger, slots[0], conn)
if err != nil {
return fmt.Errorf("could not complete booking, abandoning rescheduling flow: %v", err)
}
@@ -436,11 +455,11 @@
},
},
}
- req, err := conn.marshaler.MarshalToString(reqPB)
+ req, err := conn.Marshaler.MarshalToString(reqPB)
if err != nil {
return fmt.Errorf("Rescheduling UpdateBooking: Could not convert pb3 to json: %v", reqPB)
}
- updateHTTPResp, err := sendRequest("UpdateBooking", req, conn)
+ updateHTTPResp, err := sendRequest(ctx, logger, "UpdateBooking", req, conn)
var resp mpb.CreateBookingResponse
if err := jsonpb.UnmarshalString(updateHTTPResp, &resp); err != nil {
return fmt.Errorf("Rescheduling UpdateBooking: Could not parse HTTP response to pb3: %v", err)
@@ -453,21 +472,21 @@
if iE := utils.ValidateBooking(resp.GetBooking(), newBooking); iE != nil {
return fmt.Errorf("invalid response. UpdateBooking: %s, abandoning slot 1/1", iE.Error())
}
- return CancelBooking(resp.GetBooking().GetBookingId(), conn)
+ return CancelBooking(ctx, logger, resp.GetBooking().GetBookingId(), conn)
}
// CheckOrderFulfillability attempts to send a CheckOrderFulfillabilityRequest
// to the connection endpoint and diff the results with what are expected.
-func CheckOrderFulfillability(merchantID string, lineItems []*mpb.LineItem, conn *HTTPConnection) error {
+func CheckOrderFulfillability(ctx context.Context, logger *log.Logger, merchantID string, lineItems []*mpb.LineItem, conn *utils.HTTPConnection) error {
reqPB := &mpb.CheckOrderFulfillabilityRequest{
MerchantId: merchantID,
Item: lineItems,
}
- req, err := conn.marshaler.MarshalToString(reqPB)
+ req, err := conn.Marshaler.MarshalToString(reqPB)
if err != nil {
return fmt.Errorf("Could not convert pb3 to json: %v", reqPB)
}
- httpResp, err := sendRequest("CheckOrderFulfillability", req, conn)
+ httpResp, err := sendRequest(ctx, logger, "CheckOrderFulfillability", req, conn)
if err != nil {
return fmt.Errorf("invalid response. CheckOrderFulfillability yielded error: %v", err)
}
@@ -477,7 +496,6 @@
}
orderFulfillability := resp.GetFulfillability()
- // TODO(ccawdrey): Add validation cases for other OrderFulFillability enums.
if diff := cmp.Diff(orderFulfillability.GetResult(), mpb.OrderFulfillability_CAN_FULFILL); diff != "" {
return fmt.Errorf("invalid response. CheckOrderFulfillability.Fulfillability.OrderFulfillabilityResult differ (-got +want)\n%s", diff)
}
@@ -505,7 +523,7 @@
}
// CreateOrder will attempt to build an order from a merchant id and array of line orders.
-func CreateOrder(merchantID string, lineItems []*mpb.LineItem, conn *HTTPConnection) (*mpb.Order, error) {
+func CreateOrder(ctx context.Context, logger *log.Logger, merchantID string, lineItems []*mpb.LineItem, conn *utils.HTTPConnection) (*mpb.Order, error) {
gen := rand.New(rand.NewSource(time.Now().UnixNano()))
reqOrder := &mpb.Order{
@@ -527,11 +545,11 @@
IdempotencyToken: strconv.Itoa(gen.Intn(1000000)),
}
- req, err := conn.marshaler.MarshalToString(reqPB)
+ req, err := conn.Marshaler.MarshalToString(reqPB)
if err != nil {
return nil, fmt.Errorf("Could not convert pb3 to json: %v", reqPB)
}
- httpResp, err := sendRequest("CreateOrder", req, conn)
+ httpResp, err := sendRequest(ctx, logger, "CreateOrder", req, conn)
if err != nil {
return nil, fmt.Errorf("invalid response. CreateOrder yielded error: %v", err)
}
@@ -549,8 +567,8 @@
}
// Perform idempotency test.
- log.Printf("Idempotency check")
- idemHTTPResp, err := sendRequest("CreateOrder", req, conn)
+ logger.Printf("Idempotency check")
+ idemHTTPResp, err := sendRequest(ctx, logger, "CreateOrder", req, conn)
if err != nil {
return nil, fmt.Errorf("invalid response. Idempotency check yielded error: %v", err)
}
@@ -569,12 +587,12 @@
return resp.GetOrder(), nil
}
-func sendListOrdersRequest(reqPB *mpb.ListOrdersRequest, conn *HTTPConnection) (mpb.ListOrdersResponse, error) {
- req, err := conn.marshaler.MarshalToString(reqPB)
+func sendListOrdersRequest(ctx context.Context, logger *log.Logger, reqPB *mpb.ListOrdersRequest, conn *utils.HTTPConnection) (mpb.ListOrdersResponse, error) {
+ req, err := conn.Marshaler.MarshalToString(reqPB)
if err != nil {
return mpb.ListOrdersResponse{}, fmt.Errorf("Could not convert pb3 to json: %v", reqPB)
}
- httpResp, err := sendRequest("ListOrders", req, conn)
+ httpResp, err := sendRequest(ctx, logger, "ListOrders", req, conn)
if err != nil {
return mpb.ListOrdersResponse{}, fmt.Errorf("invalid response. ListOrders yielded error: %v", err)
}
@@ -588,7 +606,7 @@
// ListOrders first checks that the number and contents of the server's order state
// are consistent with what the test client assumes is present.
-func ListOrders(orders []*mpb.Order, conn *HTTPConnection) error {
+func ListOrders(ctx context.Context, logger *log.Logger, orders []*mpb.Order, conn *utils.HTTPConnection) error {
if len(orders) == 0 {
return errors.New("at least one order must be present for ListOrders to succeed")
}
@@ -597,7 +615,7 @@
reqPB := &mpb.ListOrdersRequest{
Ids: &mpb.ListOrdersRequest_UserId{userID},
}
- respUser, err := sendListOrdersRequest(reqPB, conn)
+ respUser, err := sendListOrdersRequest(ctx, logger, reqPB, conn)
if err != nil {
return err
}
@@ -613,7 +631,7 @@
}
reqPB.Ids = &mpb.ListOrdersRequest_OrderIds_{&orderIDs}
- respOrder, err := sendListOrdersRequest(reqPB, conn)
+ respOrder, err := sendListOrdersRequest(ctx, logger, reqPB, conn)
if err != nil {
return err
}
@@ -625,7 +643,7 @@
}
// BatchGetWaitEstimates calls the partners API and verifies the returned WaitEstimates.
-func BatchGetWaitEstimates(s *fpb.Service, conn *HTTPConnection) error {
+func BatchGetWaitEstimates(ctx context.Context, logger *log.Logger, s *fpb.Service, conn *utils.HTTPConnection) error {
rules := s.GetWaitlistRules()
ps := make([]int32, rules.GetMaxPartySize()-rules.GetMinPartySize())
@@ -637,11 +655,11 @@
ServiceId: s.GetServiceId(),
PartySize: ps,
}
- req, err := conn.marshaler.MarshalToString(reqPB)
+ req, err := conn.Marshaler.MarshalToString(reqPB)
if err != nil {
return fmt.Errorf("Could not convert pb3 to json: %v", reqPB)
}
- httpResp, err := sendRequest("BatchGetWaitEstimates", req, conn)
+ httpResp, err := sendRequest(ctx, logger, "BatchGetWaitEstimates", req, conn)
if err != nil {
return fmt.Errorf("invalid response. BatchGetWaitEstimates yielded error: %v", err)
}
@@ -677,7 +695,7 @@
// CreateWaitlistEntry attempts to create waitlist entries from a service.
// The max party size listed for the service's waitlist rules is used for
// the waitlist entry's party size.
-func CreateWaitlistEntry(s *fpb.Service, conn *HTTPConnection) (string, error) {
+func CreateWaitlistEntry(ctx context.Context, logger *log.Logger, s *fpb.Service, conn *utils.HTTPConnection) (string, error) {
gen := rand.New(rand.NewSource(time.Now().UnixNano()))
reqPB := &wpb.CreateWaitlistEntryRequest{
@@ -696,12 +714,12 @@
if s.GetWaitlistRules().GetSupportsAdditionalRequest() {
reqPB.AdditionalRequest = "test additional request"
}
- req, err := conn.marshaler.MarshalToString(reqPB)
+ req, err := conn.Marshaler.MarshalToString(reqPB)
if err != nil {
return "", fmt.Errorf("Could not convert pb3 to json: %v", reqPB)
}
- httpResp, err := sendRequest("CreateWaitlistEntry", req, conn)
+ httpResp, err := sendRequest(ctx, logger, "CreateWaitlistEntry", req, conn)
if err != nil {
return "", fmt.Errorf("invalid response. CreateWaitlistEntry yielded error: %v", err)
}
@@ -721,8 +739,8 @@
}
// Perform idempotency test.
- log.Printf("Idempotency check -- CreateWaitlistEntry Request. Sent(unix): %s, Request %s", time.Now().UTC().Format(time.RFC850), reqPB.String())
- idemHTTPResp, err := sendRequest("CreateWaitlistEntry", req, conn)
+ logger.Printf("Idempotency check -- CreateWaitlistEntry Request. Sent(unix): %s, Request %s", time.Now().UTC().Format(time.RFC850), reqPB.String())
+ idemHTTPResp, err := sendRequest(ctx, logger, "CreateWaitlistEntry", req, conn)
if err != nil {
return "", fmt.Errorf("invalid response. Idempotency check yielded error: %v", err)
}
@@ -740,16 +758,16 @@
// GetWaitlistEntry retrieves and validates the booking for the specified
// waitlist entry id.
-func GetWaitlistEntry(id string, conn *HTTPConnection) (*wpb.WaitlistEntry, error) {
+func GetWaitlistEntry(ctx context.Context, logger *log.Logger, id string, conn *utils.HTTPConnection) (*wpb.WaitlistEntry, error) {
reqPB := &wpb.GetWaitlistEntryRequest{
WaitlistEntryId: id,
}
- req, err := conn.marshaler.MarshalToString(reqPB)
+ req, err := conn.Marshaler.MarshalToString(reqPB)
if err != nil {
return nil, fmt.Errorf("Could not convert pb3 to json: %v", reqPB)
}
- httpResp, err := sendRequest("GetWaitlistEntry", req, conn)
+ httpResp, err := sendRequest(ctx, logger, "GetWaitlistEntry", req, conn)
if err != nil {
return nil, fmt.Errorf("invalid response. GetWaitlistEntry yielded error: %v", err)
}
@@ -766,22 +784,22 @@
}
// DeleteWaitlistEntry makes a request to delete the waitlist entry.
-func DeleteWaitlistEntry(id string, conn *HTTPConnection) error {
+func DeleteWaitlistEntry(ctx context.Context, logger *log.Logger, id string, conn *utils.HTTPConnection) error {
reqPB := &wpb.DeleteWaitlistEntryRequest{
WaitlistEntryId: id,
}
- req, err := conn.marshaler.MarshalToString(reqPB)
+ req, err := conn.Marshaler.MarshalToString(reqPB)
if err != nil {
return fmt.Errorf("Could not convert pb3 to json: %v", reqPB)
}
- httpResp, err := sendRequest("DeleteWaitlistEntry", req, conn)
+ httpResp, err := sendRequest(ctx, logger, "DeleteWaitlistEntry", req, conn)
if err != nil {
return fmt.Errorf("invalid response. DeleteWaitlistEntry yielded error: %v", err)
}
- var resp empty.Empty
+ var resp epb.Empty
if err := jsonpb.UnmarshalString(httpResp, &resp); err != nil {
return fmt.Errorf("DeleteWaitlistEntry: Could not parse HTTP response to pb3: %v. Body should be: {}", err)
}
diff --git a/booking/bookingTests.go b/booking/bookingTests.go
new file mode 100644
index 0000000..b44ec05
--- /dev/null
+++ b/booking/bookingTests.go
@@ -0,0 +1,270 @@
+/*
+Copyright 2019 Google Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package booking contains test logic for booking related endpoints.
+package booking
+
+import (
+ "context"
+ "log"
+
+ "github.com/maps-booking-v3/api"
+ "github.com/maps-booking-v3/utils"
+
+ fpb "github.com/maps-booking-v3/feeds"
+ mpb "github.com/maps-booking-v3/v3"
+)
+
+// GenerateBookings creates bookings from an availability feed.
+func GenerateBookings(ctx context.Context, logger *log.Logger, av []*fpb.Availability, stats *utils.TestSummary, conn *utils.HTTPConnection, config *utils.Config) api.Bookings {
+ logger.Println("no previous bookings to use, acquiring new inventory")
+ utils.LogFlow(logger, "Generate Fresh Inventory", "Start")
+ defer utils.LogFlow(logger, "Generate Fresh Inventory", "End")
+
+ var out api.Bookings
+ totalSlots := len(av)
+ for i, a := range av {
+ if config.BookingUseBal {
+ if err := api.BatchAvailabilityLookup(ctx, logger, []*fpb.Availability{a}, conn); err != nil {
+ logger.Printf("BAL error: %s. skipping slot %d/%d", err.Error(), i, totalSlots)
+ stats.BookingBatchAvailabilityLookupErrors++
+ continue
+ }
+ stats.BookingBatchAvailabilityLookupSuccess++
+ } else {
+ if err := api.CheckAvailability(ctx, logger, a, conn); err != nil {
+ logger.Printf("%s. skipping slot %d/%d", err.Error(), i, totalSlots)
+ stats.BookingCheckAvailabilityErrors++
+ continue
+ }
+ stats.BookingCheckAvailabilitySuccess++
+ }
+
+ booking, err := api.CreateBooking(ctx, logger, a, conn)
+ if err != nil {
+ logger.Printf("%s. skipping slot %d/%d", err.Error(), i, totalSlots)
+ stats.BookingCreateBookingErrors++
+ continue
+ }
+ out = append(out, booking)
+ stats.BookingCreateBookingSuccess++
+ }
+ return out
+}
+
+func logStats(stats *utils.TestSummary, logger *log.Logger, config *utils.Config) {
+ logger.Println("\n************* Begin Stats *************\n")
+ var totalErrors int
+ if config.BookingHealthFlow || config.BookingAllFlows {
+ if stats.BookingHealthCheckSuccess {
+ logger.Println("HealthCheck Succeeded")
+ } else {
+ totalErrors++
+ logger.Println("HealthCheck Failed")
+ }
+ }
+ if config.BookingCheckFlow || config.BookingAllFlows {
+ if config.BookingUseBal {
+ totalErrors += stats.BookingBatchAvailabilityLookupErrors
+ logger.Printf("BatchAvailabilityLookup Errors: %d/%d", stats.BookingBatchAvailabilityLookupErrors, stats.BookingBatchAvailabilityLookupErrors+stats.BookingBatchAvailabilityLookupSuccess)
+ } else {
+ totalErrors += stats.BookingCheckAvailabilityErrors
+ logger.Printf("CheckAvailability Errors: %d/%d", stats.BookingCheckAvailabilityErrors, stats.BookingCheckAvailabilityErrors+stats.BookingCheckAvailabilitySuccess)
+ }
+ }
+ if config.BookingBookFlow || config.BookingAllFlows {
+ totalErrors += stats.BookingCreateBookingErrors
+ logger.Printf("CreateBooking Errors: %d/%d", stats.BookingCreateBookingErrors, stats.BookingCreateBookingErrors+stats.BookingCreateBookingSuccess)
+ }
+ if config.BookingListFlow || config.BookingAllFlows || config.BookingCancelAllBookings {
+ if stats.BookingListBookingsSuccess {
+ logger.Println("ListBookings Succeeded")
+ } else {
+ totalErrors++
+ logger.Println("ListBookings Failed")
+ }
+ }
+ if config.BookingStatusFlow || config.BookingAllFlows {
+ totalErrors += stats.BookingGetBookingStatusErrors
+ logger.Printf("GetBookingStatus Errors: %d/%d", stats.BookingGetBookingStatusErrors, stats.BookingGetBookingStatusErrors+stats.BookingGetBookingStatusSuccess)
+ }
+ if config.BookingRescheduleFlow || config.BookingAllFlows {
+ if stats.BookingReschedulingSuccess {
+ logger.Println("Rescheduling Succeeded")
+ } else {
+ totalErrors++
+ logger.Println("Rescheduling Failed")
+ }
+ }
+
+ logger.Println("\n\n\n")
+ if totalErrors == 0 {
+ logger.Println("All Tests Pass!")
+ } else {
+ logger.Printf("Found %d Errors", totalErrors)
+ }
+
+ logger.Println("\n************* End Stats *************\n")
+}
+
+// RunTests runs booking tests.
+func RunTests(ctx context.Context, logger *log.Logger, config *utils.Config, av []*fpb.Availability, avForRescheduling []*fpb.Availability, stats *utils.TestSummary) {
+ conn := config.Conn
+ // HealthCheck Flow
+ if config.BookingHealthFlow || config.BookingAllFlows {
+ stats.BookingHealthCheckSuccess = true
+ if err := api.HealthCheck(ctx, logger, conn); err != nil {
+ stats.BookingHealthCheckSuccess = false
+ logger.Println(err.Error())
+ }
+ stats.BookingHealthCheckCompleted = true
+ if !config.BookingAllFlows && !config.BookingCheckFlow && !config.BookingBookFlow &&
+ !config.BookingListFlow && !config.BookingStatusFlow && !config.BookingRescheduleFlow {
+ logStats(stats, logger, config)
+ return
+ }
+ }
+ if config.BookingCheckFlow || config.BookingAllFlows {
+ if config.BookingUseBal {
+ utils.LogFlow(logger, "Batch Availability Lookup", "Start")
+ for _, a := range utils.SplitAvailabilityByMerchant(av) {
+ if err := api.BatchAvailabilityLookup(ctx, logger, a, conn); err != nil {
+ logger.Printf("BatchAvailabilityLookup returned error: %v", err)
+ stats.BookingBatchAvailabilityLookupErrors++
+ } else {
+ stats.BookingBatchAvailabilityLookupSuccess++
+ }
+ }
+ utils.LogFlow(logger, "Batch Availability Lookup", "End")
+ stats.BookingBatchAvailabilityLookupCompleted = true
+ } else {
+ // AvailabilityCheck Flow
+ utils.LogFlow(logger, "Availability Check", "Start")
+ totalSlots := len(av)
+
+ for i, a := range av {
+ if err := api.CheckAvailability(ctx, logger, a, conn); err != nil {
+ logger.Printf("%s. skipping slot %d/%d", err.Error(), i, totalSlots)
+ stats.BookingCheckAvailabilityErrors++
+ continue
+ }
+ stats.BookingCheckAvailabilitySuccess++
+ }
+ utils.LogFlow(logger, "Availability Check", "End")
+ stats.BookingCheckAvailabilityCompleted = true
+ }
+ }
+
+ // CreateBooking Flow.
+ var b []*mpb.Booking
+ if config.BookingBookFlow || config.BookingAllFlows {
+ utils.LogFlow(logger, "Booking", "Start")
+ totalSlots := len(av)
+ logger.Printf("total slots %d", totalSlots)
+ for i, a := range av {
+ logger.Printf("creating booking")
+ booking, err := api.CreateBooking(ctx, logger, a, conn)
+ if err != nil {
+ logger.Printf("%s. skipping slot %d/%d", err.Error(), i, totalSlots)
+ stats.BookingCreateBookingErrors++
+ continue
+ }
+ b = append(b, booking)
+ stats.BookingCreateBookingSuccess++
+ }
+ utils.LogFlow(logger, "Booking", "End")
+ stats.BookingCreateBookingCompleted = true
+ }
+ // ListBookings Flow
+ if config.BookingListFlow || config.BookingAllFlows || config.BookingCancelAllBookings {
+ if len(b) == 0 && !config.BookingCancelAllBookings {
+ b = GenerateBookings(ctx, logger, av, stats, conn, config)
+ }
+ utils.LogFlow(logger, "List Bookings", "Start")
+ if len(b) > 0 || config.BookingCancelAllBookings {
+ var err error
+ b, err = api.ListBookings(ctx, logger, b, conn)
+ stats.BookingListBookingsSuccess = true
+ if err != nil {
+ stats.BookingListBookingsSuccess = false
+ logger.Println(err.Error())
+ }
+ } else {
+ logger.Println("Could not create bookings to test ListBookings flow with.")
+ stats.BookingListBookingsSuccess = false
+ }
+ utils.LogFlow(logger, "List Bookings", "End")
+ stats.BookingListBookingsCompleted = true
+ }
+
+ // GetBookingStatus Flow
+ if config.BookingStatusFlow || config.BookingAllFlows {
+ if len(b) == 0 {
+ b = GenerateBookings(ctx, logger, av, stats, conn, config)
+ }
+
+ utils.LogFlow(logger, "BookingStatus", "Start")
+ totalBookings := len(b)
+
+ if totalBookings > 0 {
+ j := 0
+ for i, booking := range b {
+ if err := api.GetBookingStatus(ctx, logger, booking, conn); err != nil {
+ logger.Printf("%s. abandoning booking %d/%d", err.Error(), i, totalBookings)
+ stats.BookingGetBookingStatusErrors++
+ continue
+ }
+ stats.BookingGetBookingStatusSuccess++
+ b[j] = booking
+ j++
+ }
+ b = b[:j]
+ } else {
+ logger.Println("Could not create bookings to test GetBookingStatus flow with.")
+ }
+ utils.LogFlow(logger, "BookingStatus", "End")
+ stats.BookingGetBookingStatusCompleted = true
+ }
+ // CancelBooking Flow
+ if len(b) > 0 {
+ utils.LogFlow(logger, "Cancel Booking", "Start")
+ for i, booking := range b {
+ if err := api.CancelBooking(ctx, logger, booking.GetBookingId(), conn); err != nil {
+ logger.Printf("%s. abandoning booking %d/%d", err.Error(), i, len(b))
+ stats.BookingCancelBookingsErrors++
+ continue
+ }
+ stats.BookingCancelBookingsSuccess++
+ }
+ utils.LogFlow(logger, "Cancel Booking", "End")
+ stats.BookingCancelBookingsCompleted = true
+ }
+
+ // Rescheduling is nuanced and can be isolated
+ // from the rest of the tests.
+ if config.BookingRescheduleFlow || config.BookingAllFlows {
+ utils.LogFlow(logger, "Rescheduling", "Start")
+ stats.BookingReschedulingSuccess = true
+ if err := api.Rescheduling(ctx, logger, avForRescheduling, conn); err != nil {
+ logger.Println(err.Error())
+ stats.BookingReschedulingSuccess = false
+ }
+ utils.LogFlow(logger, "Rescheduling", "End")
+ stats.BookingReschedulingCompleted = true
+ }
+
+ logStats(stats, logger, config)
+}
diff --git a/order/orderTests.go b/order/orderTests.go
new file mode 100644
index 0000000..23c689d
--- /dev/null
+++ b/order/orderTests.go
@@ -0,0 +1,155 @@
+/*
+Copyright 2019 Google Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package order contains test logic for order related endpoints.
+package order
+
+import (
+ "context"
+ "log"
+
+ fpb "github.com/maps-booking-v3/feeds"
+ "github.com/maps-booking-v3/api"
+ mpb "github.com/maps-booking-v3/v3"
+ "github.com/maps-booking-v3/utils"
+)
+
+func logStats(stats *utils.TestSummary, logger *log.Logger, config *utils.Config) {
+ logger.Println("\n************* Begin Stats *************\n")
+ var totalErrors int
+ if config.OrderHealthFlow || config.OrderAllFlows {
+ if stats.OrderHealthCheckSuccess {
+ logger.Println("HealthCheck Succeeded")
+ } else {
+ totalErrors++
+ logger.Println("HealthCheck Failed")
+ }
+ stats.OrderHealthCheckCompleted = true
+ }
+ if config.OrderCheckFlow || config.OrderAllFlows {
+ totalErrors += stats.OrderCheckOrderFulfillabilityErrors
+ logger.Printf("CheckOrderFulfillability Errors: %d/%d", stats.OrderCheckOrderFulfillabilityErrors, stats.OrderCheckOrderFulfillabilityErrors+stats.OrderCheckOrderFulfillabilitySuccess)
+ }
+ if config.OrderOrderFlow || config.OrderAllFlows {
+ totalErrors += stats.OrderCreateOrderErrors
+ logger.Printf("CreateOrder Errors: %d/%d", stats.OrderCreateOrderErrors, stats.OrderCreateOrderErrors+stats.OrderCreateOrderSuccess)
+ }
+ if config.OrderAllFlows {
+ if stats.OrderListOrdersSuccess {
+ logger.Println("ListOrders Succeeded")
+ } else {
+ totalErrors++
+ logger.Println("ListOrders Failed")
+ }
+ }
+ if config.OrderCheckFlow || config.OrderOrderFlow || config.OrderAllFlows {
+ logger.Printf("Total Slots Processed: %d", stats.OrderTotalSlotsProcessed)
+ }
+
+ logger.Println("\n\n\n")
+ if totalErrors == 0 {
+ logger.Println("All Tests Pass!")
+ } else {
+ logger.Printf("Found %d Errors", totalErrors)
+ }
+
+ logger.Println("\n************* End Stats *************\n")
+}
+
+// RunTests runs order tests.
+func RunTests(ctx context.Context, logger *log.Logger, config *utils.Config, av []*fpb.Availability, services []*fpb.Service, stats *utils.TestSummary) {
+ conn := config.Conn
+ // HealthCheck Flow
+ if config.OrderHealthFlow || config.OrderAllFlows {
+ stats.OrderHealthCheckSuccess = true
+ if err := api.HealthCheck(ctx, logger, conn); err != nil {
+ stats.OrderHealthCheckSuccess = false
+ logger.Println(err.Error())
+ }
+ stats.OrderHealthCheckCompleted = true
+ if !config.OrderAllFlows && !config.OrderCheckFlow && !config.OrderOrderFlow {
+ logStats(stats, logger, config)
+ return
+ }
+ }
+ testInventory, err := utils.BuildLineItemMap(services, av)
+ if err != nil {
+ logger.Printf("Remaining tests cannot run due to error building line items: %s\n", err)
+ return
+ }
+
+ // CheckOrderFulfillability Flow
+ if config.OrderCheckFlow || config.OrderAllFlows {
+ utils.LogFlow(logger, "CheckOrderFulfillability", "Start")
+ for _, value := range testInventory {
+ stats.OrderTotalSlotsProcessed += len(value)
+ }
+
+ i := 0
+ for merchantID, lineItems := range testInventory {
+ if err := api.CheckOrderFulfillability(ctx, logger, merchantID, lineItems, conn); err != nil {
+ logger.Printf("%s. skipping slots %d-%d/%d", err.Error(), i, i+len(lineItems)-1, stats.OrderTotalSlotsProcessed)
+ stats.OrderCheckOrderFulfillabilityErrors += len(lineItems)
+ delete(testInventory, merchantID)
+ i += len(lineItems)
+ continue
+ }
+ stats.OrderCheckOrderFulfillabilitySuccess += len(lineItems)
+ i += len(lineItems)
+ }
+ stats.OrderCheckOrderFulfillabilityCompleted = true
+ utils.LogFlow(logger, "CheckOrderFulfillability", "End")
+ }
+ // CreateOrder Flow.
+ var orders []*mpb.Order
+ if config.OrderOrderFlow || config.OrderAllFlows {
+ utils.LogFlow(logger, "CreateOrder", "Start")
+ if stats.OrderTotalSlotsProcessed == 0 {
+ for _, value := range testInventory {
+ stats.OrderTotalSlotsProcessed += len(value)
+ }
+ }
+
+ i := 0
+ for merchantID, lineItems := range testInventory {
+ order, err := api.CreateOrder(ctx, logger, merchantID, lineItems, conn)
+ if err != nil {
+ logger.Printf("%s. skipping slot %d-%d/%d", err.Error(), i, i+len(lineItems)-1, stats.OrderTotalSlotsProcessed)
+ stats.OrderCreateOrderErrors += len(lineItems)
+ delete(testInventory, merchantID)
+ i += len(lineItems)
+ continue
+ }
+ orders = append(orders, order)
+ stats.OrderCreateOrderSuccess += len(lineItems)
+ i += len(lineItems)
+ }
+ stats.OrderCreateOrderCompleted = true
+ utils.LogFlow(logger, "CreateOrder", "End")
+ }
+ // ListOrders Flow
+ if config.OrderAllFlows || config.OrderListFlow {
+ utils.LogFlow(logger, "ListOrders", "Start")
+ stats.OrderListOrdersSuccess = true
+ if err := api.ListOrders(ctx, logger, orders, conn); err != nil {
+ stats.OrderListOrdersSuccess = false
+ logger.Println(err.Error())
+ }
+ stats.OrderListOrdersCompleted = true
+ utils.LogFlow(logger, "ListOrders", "End")
+ }
+ logStats(stats, logger, config)
+}
diff --git a/proto/waitlist.proto b/proto/waitlist.proto
index 218e868..d432edc 100644
--- a/proto/waitlist.proto
+++ b/proto/waitlist.proto
@@ -100,6 +100,17 @@
EstimatedSeatTimeRange estimated_seat_time_range = 2;
}
+// The confirmation modes used when joining the waitlist.
+enum WaitlistConfirmationMode {
+ // The confirmation mode was not specified.
+ // Synchronous confirmation will be assumed.
+ WAITLIST_CONFIRMATION_MODE_UNSPECIFIED = 0;
+ // Waitlist entries will be confirmed synchronously.
+ WAITLIST_CONFIRMATION_MODE_SYNCHRONOUS = 1;
+ // Waitlist entries will be confirmed asynchronously.
+ WAITLIST_CONFIRMATION_MODE_ASYNCHRONOUS = 2;
+}
+
// The wait estimate for a particular party size, merchant and service.
message WaitEstimate {
// Required. The party size this wait estimate applies to.
@@ -108,6 +119,11 @@
// Required. Contains fields measuring how long (in time or # of people) until
// the user is ready to leave the waitlist and be seated.
WaitLength wait_length = 2;
+
+ // Required. Indicates whether waitlist entries for this wait estimate will be
+ // confirmed synchronously or asynchronously. An UNSPECIFIED value will be
+ // interpreted as synchronous.
+ WaitlistConfirmationMode waitlist_confirmation_mode = 3;
}
// CreateWaitlistEntry method
@@ -186,6 +202,8 @@
// The waitlist entry was created and the user is currently waiting in the
// waitlist.
WAITING = 1;
+ // The waitlist entry is awaiting confirmation by the merchant.
+ PENDING_MERCHANT_CONFIRMATION = 8;
// The waitlist entry has been canceled by the user. Cancellation for no-shows
// should use the NO_SHOW state.
CANCELED = 2;
diff --git a/testclient/.bookingClient.go.swp b/testclient/.bookingClient.go.swp
deleted file mode 100644
index b3ae8ec..0000000
--- a/testclient/.bookingClient.go.swp
+++ /dev/null
Binary files differ
diff --git a/testclient/bookingClient.go b/testclient/bookingClient.go
index eb23a84..8462716 100644
--- a/testclient/bookingClient.go
+++ b/testclient/bookingClient.go
@@ -1,5 +1,5 @@
/*
-Copyright 2017 Google Inc.
+Copyright 2019 Google Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -16,29 +16,23 @@
package main
import (
+ "context"
"flag"
- "fmt"
"log"
- "os"
- "path/filepath"
- "time"
"github.com/maps-booking-v3/api"
- "github.com/maps-booking-v3/utils"
-
+ "github.com/maps-booking-v3/booking"
fpb "github.com/maps-booking-v3/feeds"
- mpb "github.com/maps-booking-v3/v3"
+ "github.com/maps-booking-v3/utils"
)
-const logFile = "http_test_client_log_"
-
var (
serverAddr = flag.String("server_addr", "example.com:80", "Your http server's address in the format of host:port")
credentialsFile = flag.String("credentials_file", "", "File containing credentials for your server. Leave blank to bypass authentication. File should have exactly one line of the form 'username:password'.")
testSlots = flag.Int("num_test_slots", 10, "Maximum number of slots to test from availability_feed. Slots will be selected randomly")
allFlows = flag.Bool("all_tests", false, "Whether to test all endpoints.")
healthFlow = flag.Bool("health_check_test", false, "Whether to test the Health endpoint.")
- checkFlow = flag.Bool("check_availability_test", false, "Whether to test the CheckAvailability endpoint.")
+ checkFlow = flag.Bool("check_availability_test", false, "Whether to test availability lookup. Will use BatchAvailabilityLookup or CheckAvailability endpoint depending on value of the use_batch_availability_lookup flag.")
bookFlow = flag.Bool("booking_test", false, "Whether to test the CreateBooking endpoint.")
listFlow = flag.Bool("list_bookings_test", false, "Whether to test the ListBookings endpoint")
statusFlow = flag.Bool("booking_status_test", false, "Whether to test the GetBookingStatus endpoint.")
@@ -52,297 +46,61 @@
useBal = flag.Bool("use_batch_availability_lookup", false, "Whether to use the BatchAvailabilityLookup RPC (as opposed to the deprecated CheckAvailability)")
)
-type counters struct {
- TotalSlotsProcessed int
- HealthCheckSuccess bool
- BatchAvailabilityLookupErrors int
- BatchAvailabilityLookupSuccess int
- CheckAvailabilitySuccess int
- CheckAvailabilityErrors int
- CreateBookingSuccess int
- CreateBookingErrors int
- ListBookingsSuccess bool
- GetBookingStatusSuccess int
- GetBookingStatusErrors int
- CancelBookingsSuccess int
- CancelBookingsErrors int
- ReschedulingSuccess bool
-}
-
-// GenerateBookings creates bookings from an availability feed.
-func GenerateBookings(av []*fpb.Availability, stats *counters, conn *api.HTTPConnection) api.Bookings {
- log.Println("no previous bookings to use, acquiring new inventory")
- utils.LogFlow("Generate Fresh Inventory", "Start")
- defer utils.LogFlow("Generate Fresh Inventory", "End")
-
- var out api.Bookings
- totalSlots := len(av)
- for i, a := range av {
- if *useBal {
- if err := api.BatchAvailabilityLookup([]*fpb.Availability{a}, conn); err != nil {
- log.Printf("BAL error: %s. skipping slot %d/%d", err.Error(), i, totalSlots)
- stats.BatchAvailabilityLookupErrors++
- continue
- }
- stats.BatchAvailabilityLookupSuccess++
- } else {
- if err := api.CheckAvailability(a, conn); err != nil {
- log.Printf("%s. skipping slot %d/%d", err.Error(), i, totalSlots)
- stats.CheckAvailabilityErrors++
- continue
- }
- stats.CheckAvailabilitySuccess++
- }
-
- booking, err := api.CreateBooking(a, conn)
- if err != nil {
- log.Printf("%s. skipping slot %d/%d", err.Error(), i, totalSlots)
- stats.CreateBookingErrors++
- continue
- }
- out = append(out, booking)
- stats.CreateBookingSuccess++
+func makeConfig(logger *log.Logger) *utils.Config {
+ conn, err := api.InitHTTPConnection(*serverAddr, *credentialsFile, *caFile, *fullServerName)
+ if err != nil {
+ logger.Fatalf("Failed to init http connection %v", err)
}
- return out
-}
-
-func createLogFile() (*os.File, error) {
- var err error
- outPath := *outputDir
- if outPath == "" {
- outPath, err = os.Getwd()
- if err != nil {
- return nil, err
- }
- }
-
- now := time.Now().UTC()
- nowString := fmt.Sprintf("%d-%02d-%02d_%02d-%02d-%02d", now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second())
- outFile := filepath.Join(outPath, fmt.Sprintf("%s%s", logFile, nowString))
-
- return os.Create(outFile)
-}
-
-func logStats(stats counters) {
- log.Println("\n************* Begin Stats *************\n")
- var totalErrors int
- if *healthFlow || *allFlows {
- if stats.HealthCheckSuccess {
- log.Println("HealthCheck Succeeded")
- } else {
- totalErrors++
- log.Println("HealthCheck Failed")
- }
- }
- if *useBal {
- totalErrors += stats.BatchAvailabilityLookupErrors
- log.Printf("BatchAvailabilityLookup Errors: %d/%d", stats.BatchAvailabilityLookupErrors, stats.BatchAvailabilityLookupErrors+stats.BatchAvailabilityLookupSuccess)
- } else if *checkFlow || *allFlows {
- totalErrors += stats.CheckAvailabilityErrors
- log.Printf("CheckAvailability Errors: %d/%d", stats.CheckAvailabilityErrors, stats.CheckAvailabilityErrors+stats.CheckAvailabilitySuccess)
- }
- if *bookFlow || *allFlows {
- totalErrors += stats.CreateBookingErrors
- log.Printf("CreateBooking Errors: %d/%d", stats.CreateBookingErrors, stats.CreateBookingErrors+stats.CreateBookingSuccess)
- }
- if *listFlow || *allFlows || *cancelAllBookings {
- if stats.ListBookingsSuccess {
- log.Println("ListBookings Succeeded")
- } else {
- totalErrors++
- log.Println("ListBookings Failed")
- }
- }
- if *statusFlow || *allFlows {
- totalErrors += stats.GetBookingStatusErrors
- log.Printf("GetBookingStatus Errors: %d/%d", stats.GetBookingStatusErrors, stats.GetBookingStatusErrors+stats.GetBookingStatusSuccess)
- }
- if *rescheduleFlow || *allFlows {
- if stats.ReschedulingSuccess {
- log.Println("Rescheduling Succeeded")
- } else {
- totalErrors++
- log.Println("Rescheduling Failed")
- }
- }
-
- log.Println("\n\n\n")
- if totalErrors == 0 {
- log.Println("All Tests Pass!")
- } else {
- log.Printf("Found %d Errors", totalErrors)
- }
-
- log.Println("\n************* End Stats *************\n")
- os.Exit(totalErrors)
+ return &utils.Config{Conn: conn,
+ BookingAllFlows: *allFlows,
+ BookingHealthFlow: *healthFlow,
+ BookingCheckFlow: *checkFlow,
+ BookingBookFlow: *bookFlow,
+ BookingListFlow: *listFlow,
+ BookingStatusFlow: *statusFlow,
+ BookingRescheduleFlow: *rescheduleFlow,
+ BookingCancelAllBookings: *cancelAllBookings,
+ BookingUseBal: *useBal}
}
func main() {
flag.Parse()
- var stats counters
- if !*outputToTerminal {
- // Set up logging before continuing with flows
- f, err := createLogFile()
- if err != nil {
- log.Fatalf("Failed to create log file %v", err)
- }
- defer f.Close()
- log.SetOutput(f)
- }
-
- conn, err := api.InitHTTPConnection(*serverAddr, *credentialsFile, *caFile, *fullServerName)
+ logger, f, err := utils.MakeLogger(*outputToTerminal, *outputDir)
if err != nil {
- log.Fatalf("Failed to init http connection %v", err)
+ log.Fatal("Could not create logger: ", err)
}
+ if f != nil {
+ defer f.Close()
+ }
+
+ config := makeConfig(logger)
// Health check doesn't affect the cancel booking flow so we let it through.
if *cancelAllBookings && (*allFlows || *checkFlow || *bookFlow || *listFlow || *statusFlow || *rescheduleFlow) {
- log.Fatal("cancel_all_bookings is not supported with other test flows")
+ logger.Fatal("cancel_all_bookings is not supported with other test flows")
}
- // HealthCheck Flow
- if *healthFlow || *allFlows {
- stats.HealthCheckSuccess = true
- if err := api.HealthCheck(conn); err != nil {
- stats.HealthCheckSuccess = false
- log.Println(err.Error())
- }
- if !*allFlows && !*checkFlow && !*bookFlow &&
- !*listFlow && !*statusFlow && !*rescheduleFlow {
- logStats(stats)
- }
- }
-
+ var summary utils.TestSummary
var av []*fpb.Availability
var avForRescheduling []*fpb.Availability
- if !*cancelAllBookings {
+
+ needAvailability := !*cancelAllBookings || *allFlows || *checkFlow || *bookFlow || *listFlow || *statusFlow || *rescheduleFlow
+
+ if needAvailability {
// Build availablility records.
if *availabilityFeed == "" {
- log.Fatal("please set availability_feed flag if you wish to test additional flows")
+ logger.Fatal("Please set availability_feed flag if you wish to test anything except health check.")
}
- av, err = utils.AvailabilityFrom(*availabilityFeed, *testSlots, false)
+ av, err = utils.AvailabilityFrom(logger, *availabilityFeed, *testSlots, false)
if err != nil {
- log.Fatalf("Failed to get availability: %v", err.Error())
+ logger.Fatalf("Failed to get availability: %v", err.Error())
}
- stats.TotalSlotsProcessed += len(av)
-
- avForRescheduling, err = utils.AvailabilityFrom(*availabilityFeed, *testSlots, true)
+ summary.BookingTotalSlotsProcessed += len(av)
+ avForRescheduling, err = utils.AvailabilityFrom(logger, *availabilityFeed, *testSlots, true)
if err != nil {
- log.Fatalf("Failed to get availability for rescheduling test: %v", err.Error())
+ logger.Fatalf("Failed to get availability for rescheduling test: %v", err.Error())
}
}
-
- if *useBal {
- utils.LogFlow("Batch Availability Lookup", "Start")
- for _, a := range utils.SplitAvailabilityByMerchant(av) {
- if err = api.BatchAvailabilityLookup(a, conn); err != nil {
- log.Printf("BatchAvailabilityLookup returned error: %v", err)
- stats.BatchAvailabilityLookupErrors++
- } else {
- stats.BatchAvailabilityLookupSuccess++
- }
- }
- utils.LogFlow("Batch Availability Lookup", "End")
- } else if *checkFlow || *allFlows {
- // AvailabilityCheck Flow
- utils.LogFlow("Availability Check", "Start")
- totalSlots := len(av)
-
- j := 0
- for i, a := range av {
- if err = api.CheckAvailability(a, conn); err != nil {
- log.Printf("%s. skipping slot %d/%d", err.Error(), i, totalSlots)
- stats.CheckAvailabilityErrors++
- continue
- }
- stats.CheckAvailabilitySuccess++
- av[j] = a
- j++
- }
- av = av[:j]
- utils.LogFlow("Availability Check", "End")
- }
- // CreateBooking Flow.
- var b []*mpb.Booking
- if *bookFlow || *allFlows {
- utils.LogFlow("Booking", "Start")
- totalSlots := len(av)
- for i, a := range av {
- booking, err := api.CreateBooking(a, conn)
- if err != nil {
- log.Printf("%s. skipping slot %d/%d", err.Error(), i, totalSlots)
- stats.CreateBookingErrors++
- continue
- }
- b = append(b, booking)
- stats.CreateBookingSuccess++
- }
- utils.LogFlow("Booking", "End")
- }
- // ListBookings Flow
- if *listFlow || *allFlows || *cancelAllBookings {
- if len(b) == 0 && !*cancelAllBookings {
- b = GenerateBookings(av, &stats, conn)
- }
- utils.LogFlow("List Bookings", "Start")
- b, err = api.ListBookings(b, conn)
- stats.ListBookingsSuccess = true
- if err != nil {
- stats.ListBookingsSuccess = false
- log.Println(err.Error())
- }
- utils.LogFlow("List Bookings", "End")
- }
-
- // GetBookingStatus Flow
- if *statusFlow || *allFlows {
- if len(b) == 0 {
- b = GenerateBookings(av, &stats, conn)
- }
-
- utils.LogFlow("BookingStatus", "Start")
- totalBookings := len(b)
-
- j := 0
- for i, booking := range b {
- if err = api.GetBookingStatus(booking, conn); err != nil {
- log.Printf("%s. abandoning booking %d/%d", err.Error(), i, totalBookings)
- stats.GetBookingStatusErrors++
- continue
- }
- stats.GetBookingStatusSuccess++
- b[j] = booking
- j++
- }
- b = b[:j]
- utils.LogFlow("BookingStatus", "End")
- }
- // CancelBooking Flow
- if len(b) > 0 {
- utils.LogFlow("Cancel Booking", "Start")
- for i, booking := range b {
- if err = api.CancelBooking(booking.GetBookingId(), conn); err != nil {
- log.Printf("%s. abandoning booking %d/%d", err.Error(), i, len(b))
- stats.CancelBookingsErrors++
- continue
- }
- stats.CancelBookingsSuccess++
- }
- utils.LogFlow("Cancel Booking", "End")
- }
-
- // Rescheduling is nuanced and can be isolated
- // from the rest of the tests.
- if *rescheduleFlow || *allFlows {
- utils.LogFlow("Rescheduling", "Start")
- stats.ReschedulingSuccess = true
- if err = api.Rescheduling(avForRescheduling, conn); err != nil {
- log.Println(err.Error())
- stats.ReschedulingSuccess = false
- }
- utils.LogFlow("Rescheduling", "End")
- }
-
- logStats(stats)
+ booking.RunTests(context.Background(), logger, config, av, avForRescheduling, &summary)
}
diff --git a/testclient/orderClient.go b/testclient/orderClient.go
index 718ff23..a3ee63d 100644
--- a/testclient/orderClient.go
+++ b/testclient/orderClient.go
@@ -1,5 +1,5 @@
/*
-Copyright 2017 Google Inc.
+Copyright 2019 Google Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -16,21 +16,17 @@
package main
import (
+ "context"
"flag"
- "fmt"
"log"
- "os"
- "path/filepath"
- "time"
+
+ fpb "github.com/maps-booking-v3/feeds"
"github.com/maps-booking-v3/api"
+ "github.com/maps-booking-v3/order"
"github.com/maps-booking-v3/utils"
-
- mpb "github.com/maps-booking-v3/v3"
)
-const logFile = "http_test_client_log_"
-
var (
serverAddr = flag.String("server_addr", "example.com:80", "Your http server's address in the format of host:port")
credentialsFile = flag.String("credentials_file", "", "File containing credentials for your server. Leave blank to bypass authentication. File should have exactly one line of the form 'username:password'.")
@@ -47,172 +43,48 @@
outputToTerminal = flag.Bool("output_to_terminal", false, "Output to terminal rather than a file.")
)
-type counters struct {
- TotalSlotsProcessed int
- HealthCheckSuccess bool
- CheckOrderFulfillabilitySuccess int
- CheckOrderFulfillabilityErrors int
- CreateOrderSuccess int
- CreateOrderErrors int
- ListOrdersSuccess bool
-}
-
-func createLogFile() (*os.File, error) {
- var err error
- outPath := *outputDir
- if outPath == "" {
- outPath, err = os.Getwd()
- if err != nil {
- return nil, err
- }
+func makeConfig(logger *log.Logger) *utils.Config {
+ conn, err := api.InitHTTPConnection(*serverAddr, *credentialsFile, *caFile, *fullServerName)
+ if err != nil {
+ logger.Fatalf("Failed to init http connection %v", err)
}
-
- now := time.Now().UTC()
- nowString := fmt.Sprintf("%d-%02d-%02d_%02d-%02d-%02d", now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second())
- outFile := filepath.Join(outPath, fmt.Sprintf("%s%s", logFile, nowString))
-
- return os.Create(outFile)
-}
-
-func logStats(stats counters) {
- log.Println("\n************* Begin Stats *************\n")
- var totalErrors int
- if *healthFlow || *allFlows {
- if stats.HealthCheckSuccess {
- log.Println("HealthCheck Succeeded")
- } else {
- totalErrors++
- log.Println("HealthCheck Failed")
- }
+ return &utils.Config{Conn: conn,
+ OrderAllFlows: *allFlows,
+ OrderHealthFlow: *healthFlow,
+ OrderCheckFlow: *checkFlow,
+ OrderOrderFlow: *orderFlow,
}
- if *checkFlow || *allFlows {
- totalErrors += stats.CheckOrderFulfillabilityErrors
- log.Printf("CheckOrderFulfillability Errors: %d/%d", stats.CheckOrderFulfillabilityErrors, stats.CheckOrderFulfillabilityErrors+stats.CheckOrderFulfillabilitySuccess)
- }
- if *orderFlow || *allFlows {
- totalErrors += stats.CreateOrderErrors
- log.Printf("CreateOrder Errors: %d/%d", stats.CreateOrderErrors, stats.CreateOrderErrors+stats.CreateOrderSuccess)
- }
- if *allFlows {
- if stats.ListOrdersSuccess {
- log.Println("ListOrders Succeeded")
- } else {
- totalErrors++
- log.Println("ListOrders Failed")
- }
- }
- if *checkFlow || *orderFlow || *allFlows {
- log.Printf("Total Slots Processed: %d", stats.TotalSlotsProcessed)
- }
-
- log.Println("\n\n\n")
- if totalErrors == 0 {
- log.Println("All Tests Pass!")
- } else {
- log.Printf("Found %d Errors", totalErrors)
- }
-
- log.Println("\n************* End Stats *************\n")
- os.Exit(totalErrors)
}
func main() {
flag.Parse()
- var stats counters
- if !*outputToTerminal {
- // Set up logging before continuing with flows
- f, err := createLogFile()
- if err != nil {
- log.Fatalf("Failed to create log file %v", err)
- }
+ logger, f, err := utils.MakeLogger(*outputToTerminal, *outputDir)
+ if err != nil {
+ log.Fatal("Could not create logger: ", err)
+ }
+ if f != nil {
defer f.Close()
- log.SetOutput(f)
}
- conn, err := api.InitHTTPConnection(*serverAddr, *credentialsFile, *caFile, *fullServerName)
- if err != nil {
- log.Fatalf("Failed to init http connection %v", err)
- }
-
- // HealthCheck Flow
- if *healthFlow || *allFlows {
- stats.HealthCheckSuccess = true
- if err := api.HealthCheck(conn); err != nil {
- stats.HealthCheckSuccess = false
- log.Println(err.Error())
- }
- if !*allFlows && !*checkFlow && !*orderFlow {
- logStats(stats)
- }
- }
-
- if *availabilityFeed == "" || *serviceFeed == "" {
- log.Fatal("please set both availability_feed and service_feed flags")
- }
-
- testInventory, err := utils.MerchantLineItemMapFrom(*serviceFeed, *availabilityFeed, *testSlots)
- if err != nil {
- log.Fatal(err.Error())
- }
-
- // CheckOrderFulfillability Flow
- if *checkFlow || *allFlows {
- utils.LogFlow("CheckOrderFulfillability", "Start")
- for _, value := range testInventory {
- stats.TotalSlotsProcessed += len(value)
+ config := makeConfig(logger)
+ var summary utils.TestSummary
+ var services []*fpb.Service
+ var av []*fpb.Availability
+ if config.OrderAllFlows || config.OrderCheckFlow || config.OrderOrderFlow {
+ if *availabilityFeed == "" || *serviceFeed == "" {
+ log.Fatal("please set both availability_feed and service_feed flags")
}
- i := 0
- for merchantID, lineItems := range testInventory {
- if err = api.CheckOrderFulfillability(merchantID, lineItems, conn); err != nil {
- log.Printf("%s. skipping slots %d-%d/%d", err.Error(), i, i+len(lineItems)-1, stats.TotalSlotsProcessed)
- stats.CheckOrderFulfillabilityErrors += len(lineItems)
- delete(testInventory, merchantID)
- i += len(lineItems)
- continue
- }
- stats.CheckOrderFulfillabilitySuccess += len(lineItems)
- i += len(lineItems)
- }
- utils.LogFlow("CheckOrderFulfillability", "End")
- }
- // CreateOrder Flow.
- var orders []*mpb.Order
- if *orderFlow || *allFlows {
- utils.LogFlow("CreateOrder", "Start")
- if stats.TotalSlotsProcessed == 0 {
- for _, value := range testInventory {
- stats.TotalSlotsProcessed += len(value)
- }
+ services, err = utils.ParseServiceFeed(*serviceFeed)
+ if err != nil {
+ log.Fatal(err.Error())
}
- i := 0
- for merchantID, lineItems := range testInventory {
- order, err := api.CreateOrder(merchantID, lineItems, conn)
- if err != nil {
- log.Printf("%s. skipping slot %d-%d/%d", err.Error(), i, i+len(lineItems)-1, stats.TotalSlotsProcessed)
- stats.CreateOrderErrors += len(lineItems)
- delete(testInventory, merchantID)
- i += len(lineItems)
- continue
- }
- orders = append(orders, order)
- stats.CreateOrderSuccess += len(lineItems)
- i += len(lineItems)
+ av, err = utils.AvailabilityFrom(logger, *availabilityFeed, *testSlots, false)
+ if err != nil {
+ log.Fatal(err.Error())
}
- utils.LogFlow("CreateOrder", "End")
}
- // ListOrders Flow
- if *allFlows {
- utils.LogFlow("ListOrders", "Start")
- stats.ListOrdersSuccess = true
- if err = api.ListOrders(orders, conn); err != nil {
- stats.ListOrdersSuccess = false
- log.Println(err.Error())
- }
- utils.LogFlow("ListOrders", "End")
- }
-
- logStats(stats)
+ order.RunTests(context.Background(), logger, config, av, services, &summary)
}
diff --git a/testclient/waitlistClient.go b/testclient/waitlistClient.go
index 4f673e7..5260a74 100644
--- a/testclient/waitlistClient.go
+++ b/testclient/waitlistClient.go
@@ -1,5 +1,5 @@
/*
-Copyright 2017 Google Inc.
+Copyright 2019 Google Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -16,21 +16,16 @@
package main
import (
+ "context"
"flag"
- "fmt"
"log"
- "os"
- "path/filepath"
- "time"
"github.com/maps-booking-v3/api"
- "github.com/maps-booking-v3/utils"
-
fpb "github.com/maps-booking-v3/feeds"
+ "github.com/maps-booking-v3/utils"
+ "github.com/maps-booking-v3/waitlist"
)
-const logFile = "http_test_client_log_"
-
var (
serverAddr = flag.String("server_addr", "example.com:80", "Your http server's address in the format of host:port")
credentialsFile = flag.String("credentials_file", "", "File containing credentials for your server. Leave blank to bypass authentication. File should have exactly one line of the form 'username:password'.")
@@ -48,206 +43,64 @@
outputToTerminal = flag.Bool("output_to_terminal", false, "Output to terminal rather than a file.")
)
-type counters struct {
- TotalServicesProcessed int
- HealthCheckSuccess bool
- BatchGetWaitEstimatesSuccess int
- BatchGetWaitEstimatesErrors int
- CreateWaitlistEntrySuccess int
- CreateWaitlistEntryErrors int
- GetWaitlistEntrySuccess int
- GetWaitlistEntryErrors int
- DeleteWaitlistEntrySuccess int
- DeleteWaitlistEntryErrors int
-}
-
-// GenerateWaitlistEntries creates a waitlist entry for each provided service.
-func GenerateWaitlistEntries(services []*fpb.Service, stats *counters, conn *api.HTTPConnection) []string {
- log.Println("no previous waitlist entries to use, acquiring new inventory")
- utils.LogFlow("Generate Fresh Entries", "Start")
- defer utils.LogFlow("Generate Fresh Entries", "End")
-
- var out []string
- totalServices := len(services)
- for i, s := range services {
- id, err := api.CreateWaitlistEntry(s, conn)
- if err != nil {
- log.Printf("%s. skipping waitlistEntry %d/%d, serviceID: %s",
- err.Error(), i, totalServices, s.GetServiceId())
- stats.CreateWaitlistEntryErrors++
- continue
- }
- out = append(out, id)
- stats.CreateWaitlistEntrySuccess++
+func makeConfig(logger *log.Logger) *utils.Config {
+ conn, err := api.InitHTTPConnection(*serverAddr, *credentialsFile, *caFile, *fullServerName)
+ if err != nil {
+ logger.Fatalf("Failed to init http connection %v", err)
}
- return out
-}
-
-func createLogFile() (*os.File, error) {
- var err error
- outPath := *outputDir
- if outPath == "" {
- outPath, err = os.Getwd()
- if err != nil {
- return nil, err
- }
+ return &utils.Config{Conn: conn,
+ WaitlistAllFlows: *allFlows,
+ WaitlistHealthFlow: *healthFlow,
+ WaitlistBatchGetWaitEstimatesFlow: *batchGetWaitEstimatesFlow,
+ WaitlistCreateWaitlistEntryFlow: *createWaitlistEntryFlow,
+ WaitlistGetWaitlistEntryFlow: *getWaitlistEntryFlow,
+ WaitlistDeleteWaitlistEntryFlow: *deleteWaitlistEntryFlow,
}
-
- now := time.Now().UTC()
- nowString := fmt.Sprintf("%d-%02d-%02d_%02d-%02d-%02d", now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second())
- outFile := filepath.Join(outPath, fmt.Sprintf("%s%s", logFile, nowString))
-
- return os.Create(outFile)
-}
-
-func logStats(stats counters) {
- log.Println("\n************* Begin Stats *************\n")
- var totalErrors int
- if *healthFlow || *allFlows {
- if stats.HealthCheckSuccess {
- log.Println("HealthCheck Succeeded")
- } else {
- totalErrors++
- log.Println("HealthCheck Failed")
- }
- }
- if *batchGetWaitEstimatesFlow || *allFlows {
- totalErrors += stats.BatchGetWaitEstimatesErrors
- log.Printf("BatchGetWaitEstimates Errors: %d/%d", stats.BatchGetWaitEstimatesErrors, stats.BatchGetWaitEstimatesErrors+stats.BatchGetWaitEstimatesSuccess)
- }
- if *createWaitlistEntryFlow || *allFlows {
- totalErrors += stats.CreateWaitlistEntryErrors
- log.Printf("CreateWaitlistEntry Errors: %d/%d", stats.CreateWaitlistEntryErrors, stats.CreateWaitlistEntryErrors+stats.CreateWaitlistEntrySuccess)
- }
- if *getWaitlistEntryFlow || *allFlows {
- totalErrors += stats.GetWaitlistEntryErrors
- log.Printf("GetWaitlistEntry Errors: %d/%d", stats.GetWaitlistEntryErrors, stats.GetWaitlistEntryErrors+stats.GetWaitlistEntrySuccess)
- }
- if *deleteWaitlistEntryFlow || *allFlows {
- totalErrors += stats.DeleteWaitlistEntryErrors
- log.Printf("DeleteWaitlistEntry Errors: %d/%d", stats.DeleteWaitlistEntryErrors, stats.DeleteWaitlistEntryErrors+stats.DeleteWaitlistEntrySuccess)
- }
-
- log.Println("\n\n\n")
- if totalErrors == 0 {
- log.Println("All Tests Pass!")
- } else {
- log.Printf("Found %d Errors", totalErrors)
- }
-
- log.Println("\n************* End Stats *************\n")
- os.Exit(totalErrors)
}
func main() {
flag.Parse()
- var stats counters
- if !*outputToTerminal {
- // Set up logging before continuing with flows
- f, err := createLogFile()
- if err != nil {
- log.Fatalf("Failed to create log file %v", err)
- }
- defer f.Close()
- log.SetOutput(f)
- }
-
- conn, err := api.InitHTTPConnection(*serverAddr, *credentialsFile, *caFile, *fullServerName)
+ logger, f, err := utils.MakeLogger(*outputToTerminal, *outputDir)
if err != nil {
- log.Fatalf("Failed to init http connection %v", err)
+ log.Fatal("Could not create logger: ", err)
}
+ if f != nil {
+ defer f.Close()
+ }
+ config := makeConfig(logger)
+ var summary utils.TestSummary
- // HealthCheck Flow
- if *healthFlow || *allFlows {
- stats.HealthCheckSuccess = true
- if err := api.HealthCheck(conn); err != nil {
- stats.HealthCheckSuccess = false
- log.Println(err.Error())
- }
- if !*allFlows && !*batchGetWaitEstimatesFlow && !*createWaitlistEntryFlow &&
- !*getWaitlistEntryFlow && !*deleteWaitlistEntryFlow {
- logStats(stats)
- }
- }
+ needService := config.WaitlistAllFlows || config.WaitlistBatchGetWaitEstimatesFlow || config.WaitlistCreateWaitlistEntryFlow ||
+ config.WaitlistGetWaitlistEntryFlow || config.WaitlistDeleteWaitlistEntryFlow
// Build services.
- if *serviceFeed == "" {
- log.Fatal("please set service_feed flag if you wish to test additional flows")
- }
-
- var services []*fpb.Service
- services, err = utils.ParseServiceFeed(*serviceFeed)
- if err != nil {
- log.Fatalf("Failed to get services: %v", err.Error())
- }
- // Remove services without waitlist rules.
- waitlistServices := services[:0]
- for _, s := range services {
- if s.GetWaitlistRules() != nil {
- waitlistServices = append(waitlistServices, s)
+ var reducedServices []*fpb.Service
+ if needService {
+ if *serviceFeed == "" {
+ logger.Fatal("please set service_feed flag if you wish to test additional flows")
}
- }
- if len(waitlistServices) == 0 {
- log.Fatal("no services have waitlist rules")
- }
- reducedServices := utils.ReduceServices(waitlistServices, *numTestServices)
- stats.TotalServicesProcessed += len(reducedServices)
-
- // BatchGetWaitEstimates Flow
- if *batchGetWaitEstimatesFlow || *allFlows {
- utils.LogFlow("BatchGetWaitEstimates", "Start")
-
- for i, s := range reducedServices {
- if err = api.BatchGetWaitEstimates(s, conn); err != nil {
- log.Printf("%s. BatchGerWaitEstimates failed for service %d/%d. Service_id:",
- err.Error(), i, stats.TotalServicesProcessed, s.GetServiceId())
- stats.BatchGetWaitEstimatesErrors++
- continue
+ var services []*fpb.Service
+ services, err = utils.ParseServiceFeed(*serviceFeed)
+ if err != nil {
+ logger.Fatalf("Failed to get services: %v", err.Error())
+ }
+ // Remove services without waitlist rules.
+ waitlistServices := services[:0]
+ for _, s := range services {
+ if s.GetWaitlistRules() != nil {
+ waitlistServices = append(waitlistServices, s)
}
- stats.BatchGetWaitEstimatesSuccess++
}
- utils.LogFlow("BatchGetWaitEstimates", "End")
- }
- // CreateWaitlistEntry Flow.
- var ids []string
- if *createWaitlistEntryFlow || *getWaitlistEntryFlow ||
- *deleteWaitlistEntryFlow || *allFlows {
- utils.LogFlow("CreateWaitlistEntry", "Start")
- ids = GenerateWaitlistEntries(reducedServices, &stats, conn)
- utils.LogFlow("CreateWaitlistEntry", "End")
- }
- // GetWaitlistEntry Flow
- if *getWaitlistEntryFlow || *allFlows {
- utils.LogFlow("GetWaitlistEntry", "Start")
- for _, id := range ids {
- if _, err = api.GetWaitlistEntry(id, conn); err != nil {
- log.Printf("%s. get waitlist entry failed for waitlist entry id: %s",
- err.Error(), id)
- stats.GetWaitlistEntryErrors++
- continue
- }
- stats.GetWaitlistEntrySuccess++
+
+ if len(waitlistServices) == 0 {
+ logger.Fatal("no services have waitlist rules")
}
- utils.LogFlow("GetWaitlistEntry", "End")
+ reducedServices = utils.ReduceServices(logger, waitlistServices, *numTestServices)
+ } else {
+ reducedServices = []*fpb.Service{}
}
-
- // DeleteWaitlistentry Flow
- if *deleteWaitlistEntryFlow || *allFlows {
- utils.LogFlow("DeleteWaitlistEntry", "Start")
-
- for _, id := range ids {
- if err = api.DeleteWaitlistEntry(id, conn); err != nil {
- log.Printf("%s. Delete waitlist entry failed for waitlist entry id: %s",
- err.Error(), id)
- stats.DeleteWaitlistEntryErrors++
- continue
- }
- stats.DeleteWaitlistEntrySuccess++
- }
- utils.LogFlow("DeleteWaitlistEntry", "End")
- }
-
- logStats(stats)
+ summary.WaitlistTotalServicesProcessed += len(reducedServices)
+ waitlist.RunTests(context.Background(), logger, config, reducedServices, &summary)
}
diff --git a/utils/structs.go b/utils/structs.go
new file mode 100644
index 0000000..689c35e
--- /dev/null
+++ b/utils/structs.go
@@ -0,0 +1,152 @@
+/*
+Copyright 2019 Google Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package utils
+
+import (
+ "net/http"
+
+ "github.com/golang/protobuf/jsonpb"
+)
+
+// Config holds all test configuration options.
+type Config struct {
+ BookingAllFlows bool
+ BookingHealthFlow bool
+ BookingCheckFlow bool
+ BookingBookFlow bool
+ BookingListFlow bool
+ BookingStatusFlow bool
+ BookingRescheduleFlow bool
+ BookingCancelAllBookings bool
+ BookingUseBal bool
+
+ OrderAllFlows bool
+ OrderHealthFlow bool
+ OrderCheckFlow bool
+ OrderOrderFlow bool
+ OrderListFlow bool
+
+ WaitlistAllFlows bool
+ WaitlistHealthFlow bool
+ WaitlistBatchGetWaitEstimatesFlow bool
+ WaitlistCreateWaitlistEntryFlow bool
+ WaitlistGetWaitlistEntryFlow bool
+ WaitlistDeleteWaitlistEntryFlow bool
+
+ Conn *HTTPConnection
+}
+
+// ShouldTestBookings determines whether any booking tests need to be run.
+func (c *Config) ShouldTestBookings() bool {
+ return c.BookingAllFlows ||
+ c.BookingHealthFlow ||
+ c.BookingCheckFlow ||
+ c.BookingBookFlow ||
+ c.BookingListFlow ||
+ c.BookingStatusFlow ||
+ c.BookingRescheduleFlow ||
+ c.BookingCancelAllBookings
+}
+
+// ShouldTestOrders determines whether any orders tests need to be run.
+func (c *Config) ShouldTestOrders() bool {
+ return c.OrderAllFlows ||
+ c.OrderHealthFlow ||
+ c.OrderCheckFlow ||
+ c.OrderOrderFlow ||
+ c.OrderListFlow
+}
+
+// ShouldTestWaitlists determines whether any waitlist tests need to be run.
+func (c *Config) ShouldTestWaitlists() bool {
+ return c.WaitlistAllFlows ||
+ c.WaitlistHealthFlow ||
+ c.WaitlistBatchGetWaitEstimatesFlow ||
+ c.WaitlistCreateWaitlistEntryFlow ||
+ c.WaitlistGetWaitlistEntryFlow ||
+ c.WaitlistDeleteWaitlistEntryFlow
+}
+
+// TestSummary contains a summary of all test results.
+type TestSummary struct {
+ BookingTotalSlotsProcessed int
+ BookingHealthCheckSuccess bool
+ BookingHealthCheckCompleted bool
+ BookingBatchAvailabilityLookupErrors int
+ BookingBatchAvailabilityLookupSuccess int
+ BookingBatchAvailabilityLookupCompleted bool
+ BookingCheckAvailabilitySuccess int
+ BookingCheckAvailabilityErrors int
+ BookingCheckAvailabilityCompleted bool
+ BookingCreateBookingSuccess int
+ BookingCreateBookingErrors int
+ BookingCreateBookingCompleted bool
+ BookingListBookingsSuccess bool
+ BookingListBookingsCompleted bool
+ BookingGetBookingStatusSuccess int
+ BookingGetBookingStatusErrors int
+ BookingGetBookingStatusCompleted bool
+ BookingCancelBookingsSuccess int
+ BookingCancelBookingsErrors int
+ BookingCancelBookingsCompleted bool
+ BookingReschedulingSuccess bool
+ BookingReschedulingCompleted bool
+
+ OrderTotalSlotsProcessed int
+ OrderHealthCheckSuccess bool
+ OrderHealthCheckCompleted bool
+ OrderCheckOrderFulfillabilitySuccess int
+ OrderCheckOrderFulfillabilityErrors int
+ OrderCheckOrderFulfillabilityCompleted bool
+ OrderCreateOrderSuccess int
+ OrderCreateOrderErrors int
+ OrderCreateOrderCompleted bool
+ OrderListOrdersSuccess bool
+ OrderListOrdersCompleted bool
+
+ WaitlistTotalServicesProcessed int
+ WaitlistHealthCheckSuccess bool
+ WaitlistHealthCheckCompleted bool
+ WaitlistBatchGetWaitEstimatesSuccess int
+ WaitlistBatchGetWaitEstimatesErrors int
+ WaitlistBatchGetWaitEstimatesCompleted bool
+ WaitlistCreateWaitlistEntrySuccess int
+ WaitlistCreateWaitlistEntryErrors int
+ WaitlistCreateWaitlistEntryCompleted bool
+ WaitlistGetWaitlistEntrySuccess int
+ WaitlistGetWaitlistEntryErrors int
+ WaitlistGetWaitlistEntryCompleted bool
+ WaitlistDeleteWaitlistEntrySuccess int
+ WaitlistDeleteWaitlistEntryErrors int
+ WaitlistDeleteWaitlistEntryCompleted bool
+}
+
+// HTTPConnection is a convenience struct for holding connection-related objects.
+type HTTPConnection struct {
+ Client *http.Client
+ Credentials string
+ Marshaler *jsonpb.Marshaler
+ BaseURL string
+}
+
+// GetURL computes the URL for an RPC.
+func (h HTTPConnection) GetURL(rpcName string) string {
+ if rpcName != "" {
+ return h.BaseURL + "/v3/" + rpcName
+ }
+ return h.BaseURL
+}
diff --git a/utils/utils.go b/utils/utils.go
index c5e102f..03984b2 100644
--- a/utils/utils.go
+++ b/utils/utils.go
@@ -1,5 +1,5 @@
/*
-Copyright 2017 Google Inc.
+Copyright 2019 Google Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -18,25 +18,32 @@
package utils
import (
- "crypto/md5"
+ "crypto/sha256"
"errors"
"fmt"
"io/ioutil"
"log"
"math/rand"
+ "os"
"path"
+ "path/filepath"
"sort"
"strings"
+ "time"
"github.com/golang/protobuf/jsonpb"
"github.com/golang/protobuf/proto"
"github.com/google/go-cmp/cmp"
+
fpb "github.com/maps-booking-v3/feeds"
+
mpb "github.com/maps-booking-v3/v3"
- wpb "github.com/maps-booking-v3/waitlist"
+ wpb "github.com/maps-booking-v3/v3waitlist"
)
+const logFile = "http_test_client_log_"
+
// SlotKey is a struct representing a unique service.
type SlotKey struct {
MerchantID string
@@ -45,13 +52,45 @@
RoomID string
}
+func createLogFile(outPath string) (*os.File, error) {
+ var err error
+ if outPath == "" {
+ outPath, err = os.Getwd()
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ now := time.Now().UTC()
+ nowString := fmt.Sprintf("%d-%02d-%02d_%02d-%02d-%02d", now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second())
+ outFile := filepath.Join(outPath, fmt.Sprintf("%s%s", logFile, nowString))
+
+ return os.Create(outFile)
+}
+
+// MakeLogger creates a logger that either logs to terminal or to a file. If outputToTerminal
+// is true, outputDir will be ignored.
+func MakeLogger(outputToTerminal bool, outputDir string) (*log.Logger, *os.File, error) {
+ var logger *log.Logger
+ if outputToTerminal {
+ logger = log.New(os.Stderr, "", log.Flags())
+ return logger, nil, nil
+ }
+ f, err := createLogFile(outputDir)
+ if err != nil {
+ return nil, nil, err
+ }
+ logger = log.New(f, "", log.Flags())
+ return logger, f, nil
+}
+
// LogFlow is a convenience function for logging common flows..
-func LogFlow(f string, status string) {
- log.Println(strings.Join([]string{"\n##########\n", status, f, "Flow", "\n##########"}, " "))
+func LogFlow(logger *log.Logger, f string, status string) {
+ logger.Println(strings.Join([]string{"\n##########\n", status, f, "Flow", "\n##########"}, " "))
}
// ReduceServices randomly selects and returns numTestServices from the provided services.
-func ReduceServices(allServices []*fpb.Service, numTestServices int) []*fpb.Service {
+func ReduceServices(logger *log.Logger, allServices []*fpb.Service, numTestServices int) []*fpb.Service {
reducedServices := make([]*fpb.Service, 0, numTestServices)
if len(allServices) <= numTestServices {
@@ -61,7 +100,7 @@
reducedServices = append(reducedServices, allServices[n])
}
}
- log.Printf("Selected %d services out of a possible %d", len(reducedServices), len(allServices))
+ logger.Printf("Selected %d services out of a possible %d", len(reducedServices), len(allServices))
return reducedServices
}
@@ -152,13 +191,8 @@
return lineItem
}
-// MerchantLineItemMapFrom attempts to build a collection of LineItems from a service and availability feed.
-func MerchantLineItemMapFrom(serviceFeed, availabilityFeed string, testSlots int) (map[string][]*mpb.LineItem, error) {
- services, err := ParseServiceFeed(serviceFeed)
- if err != nil {
- return nil, err
- }
-
+// BuildLineItemMap creats a collection of LineItems from slices of services and availabilities.
+func BuildLineItemMap(services []*fpb.Service, availabilities []*fpb.Availability) (map[string][]*mpb.LineItem, error) {
feedHasTicketType := false
serviceTicketTypeMap := make(map[string][]*fpb.TicketType)
for _, service := range services {
@@ -178,12 +212,7 @@
}
if !feedHasTicketType {
- return nil, errors.New("no valid ticket types found in service feed, please update service feed and retry")
- }
-
- availabilities, err := AvailabilityFrom(availabilityFeed, testSlots, false)
- if err != nil {
- return nil, err
+ return nil, errors.New("no valid ticket types found in services, please update services and retry")
}
merchantLineItemMap := make(map[string][]*mpb.LineItem)
@@ -198,14 +227,16 @@
merchantLineItemMap[availability.GetMerchantId()] = append(merchantLineItemMap[availability.GetMerchantId()], lineItem)
}
}
-
+ if len(merchantLineItemMap) == 0 {
+ return nil, errors.New("no availability slots with ticket type IDs matching those in the service were found")
+ }
return merchantLineItemMap, nil
}
// AvailabilityFrom parses the file specified in availabilityFeed, returning a random permutation of availability data, maximum entries specified in testSlots
-func AvailabilityFrom(availabilityFeed string, testSlots int, forRescheduling bool) ([]*fpb.Availability, error) {
- LogFlow("Parse Input Feed", "Start")
- defer LogFlow("Parse Input Feed", "End")
+func AvailabilityFrom(logger *log.Logger, availabilityFeed string, testSlots int, forRescheduling bool) ([]*fpb.Availability, error) {
+ LogFlow(logger, "Parse Input Feed", "Start")
+ defer LogFlow(logger, "Parse Input Feed", "End")
var feed fpb.AvailabilityFeed
content, err := ioutil.ReadFile(availabilityFeed)
@@ -248,16 +279,40 @@
}
}
}
- log.Printf("Selected %d slots out of a possible %d", len(finalAvailability), len(rawAvailability))
+ logger.Printf("Selected %d slots out of a possible %d", len(finalAvailability), len(rawAvailability))
return finalAvailability, nil
}
+func slotDiff(got, want *mpb.Slot) string {
+ // CONFIRMATION_MODE_SYNCHRONOUS and CONFIRMATION_MODE_UNSPECIFIED should be treated as equivalent.
+ var gotConfirmationMode, wantConfirmationMode mpb.ConfirmationMode
+ var gotComp, wantComp mpb.Slot
+ if got != nil {
+ gotComp = *got
+ gotConfirmationMode = got.GetConfirmationMode()
+ gotComp.ConfirmationMode = mpb.ConfirmationMode_CONFIRMATION_MODE_UNSPECIFIED
+ }
+ if want != nil {
+ wantComp = *want
+ wantConfirmationMode = want.GetConfirmationMode()
+ wantComp.ConfirmationMode = mpb.ConfirmationMode_CONFIRMATION_MODE_UNSPECIFIED
+ }
+ if diff := cmp.Diff(gotComp, wantComp, cmp.Comparer(proto.Equal)); diff != "" {
+ return diff
+ }
+ if (wantConfirmationMode == mpb.ConfirmationMode_CONFIRMATION_MODE_ASYNCHRONOUS) !=
+ (gotConfirmationMode == mpb.ConfirmationMode_CONFIRMATION_MODE_ASYNCHRONOUS) {
+ return cmp.Diff(gotConfirmationMode, wantConfirmationMode)
+ }
+ return ""
+}
+
// ValidateBooking performs granular comparisons between all got and want Bookings.
func ValidateBooking(got, want *mpb.Booking) error {
if got.GetBookingId() == "" {
return errors.New("booking_id is empty")
}
- if diff := cmp.Diff(got.GetSlot(), want.GetSlot(), cmp.Comparer(proto.Equal)); diff != "" {
+ if diff := slotDiff(got.GetSlot(), want.GetSlot()); diff != "" {
return fmt.Errorf("slots differ (-got +want)\n%s", diff)
}
// UserId is the only required field for the partner to return.
@@ -362,7 +417,7 @@
for _, ticket := range l.GetTickets() {
uID = append(uID, ticket.GetTicketId())
}
- return fmt.Sprintf("%x", md5.Sum([]byte(strings.Join(uID, `|`))))
+ return fmt.Sprintf("%x", sha256.Sum256([]byte(strings.Join(uID, `|`))))
}
// Orders is a convenience type for an Orders array
@@ -500,20 +555,20 @@
}
waitLength := waitEstimate.GetWaitLength()
if waitLength == nil {
- return errors.New("wait estimate not specified")
+ return errors.New("wait length not specified")
}
if waitLength.GetPartiesAheadCount() < 0 {
return errors.New("parties ahead count < 0")
}
estimatedSeatTimeRange := waitLength.GetEstimatedSeatTimeRange()
if estimatedSeatTimeRange == nil {
- return errors.New("estimated seat time range not specified")
+ return nil
}
if estimatedSeatTimeRange.GetStartSeconds() <= 0 {
- return errors.New("start seconds <= 0")
+ return errors.New("estimated seat time range provided and start seconds <= 0")
}
if estimatedSeatTimeRange.GetEndSeconds() <= 0 {
- return errors.New("end seconds <= 0")
+ return errors.New("estimated seat time range provided and end seconds <= 0")
}
return nil
}
diff --git a/waitlist/waitlist.pb.go b/v3waitlist/v3waitlist.pb.go
similarity index 100%
rename from waitlist/waitlist.pb.go
rename to v3waitlist/v3waitlist.pb.go
diff --git a/waitlist/waitlistTests.go b/waitlist/waitlistTests.go
new file mode 100644
index 0000000..d67c6ef
--- /dev/null
+++ b/waitlist/waitlistTests.go
@@ -0,0 +1,165 @@
+/*
+Copyright 2019 Google Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package waitlist contains test logic for waitlist related endpoints.
+package waitlist
+
+import (
+ "context"
+ "log"
+
+ fpb "github.com/maps-booking-v3/feeds"
+ "github.com/maps-booking-v3/api"
+ "github.com/maps-booking-v3/utils"
+)
+
+func logStats(stats *utils.TestSummary, logger *log.Logger, config *utils.Config) {
+ logger.Println("\n************* Begin Stats *************\n")
+ var totalErrors int
+ if config.WaitlistHealthFlow || config.WaitlistAllFlows {
+ if stats.WaitlistHealthCheckSuccess {
+ logger.Println("HealthCheck Succeeded")
+ } else {
+ totalErrors++
+ logger.Println("HealthCheck Failed")
+ }
+ }
+ if config.WaitlistBatchGetWaitEstimatesFlow || config.WaitlistAllFlows {
+ totalErrors += stats.WaitlistBatchGetWaitEstimatesErrors
+ logger.Printf("BatchGetWaitEstimates Errors: %d/%d", stats.WaitlistBatchGetWaitEstimatesErrors, stats.WaitlistBatchGetWaitEstimatesErrors+stats.WaitlistBatchGetWaitEstimatesSuccess)
+ }
+ if config.WaitlistCreateWaitlistEntryFlow || config.WaitlistAllFlows {
+ totalErrors += stats.WaitlistCreateWaitlistEntryErrors
+ logger.Printf("CreateWaitlistEntry Errors: %d/%d", stats.WaitlistCreateWaitlistEntryErrors, stats.WaitlistCreateWaitlistEntryErrors+stats.WaitlistCreateWaitlistEntrySuccess)
+ }
+ if config.WaitlistGetWaitlistEntryFlow || config.WaitlistAllFlows {
+ totalErrors += stats.WaitlistGetWaitlistEntryErrors
+ logger.Printf("GetWaitlistEntry Errors: %d/%d", stats.WaitlistGetWaitlistEntryErrors, stats.WaitlistGetWaitlistEntryErrors+stats.WaitlistGetWaitlistEntrySuccess)
+ }
+ if config.WaitlistDeleteWaitlistEntryFlow || config.WaitlistAllFlows {
+ totalErrors += stats.WaitlistDeleteWaitlistEntryErrors
+ logger.Printf("DeleteWaitlistEntry Errors: %d/%d", stats.WaitlistDeleteWaitlistEntryErrors, stats.WaitlistDeleteWaitlistEntryErrors+stats.WaitlistDeleteWaitlistEntrySuccess)
+ }
+
+ logger.Println("\n\n\n")
+ if totalErrors == 0 {
+ logger.Println("All Tests Pass!")
+ } else {
+ logger.Printf("Found %d Errors", totalErrors)
+ }
+
+ logger.Println("\n************* End Stats *************\n")
+}
+
+// generateWaitlistEntries creates a waitlist entry for each provided service.
+func generateWaitlistEntries(ctx context.Context, logger *log.Logger, services []*fpb.Service, stats *utils.TestSummary, conn *utils.HTTPConnection) []string {
+ logger.Println("no previous waitlist entries to use, acquiring new inventory")
+ utils.LogFlow(logger, "Generate Fresh Entries", "Start")
+ defer utils.LogFlow(logger, "Generate Fresh Entries", "End")
+
+ var out []string
+ totalServices := len(services)
+ for i, s := range services {
+ id, err := api.CreateWaitlistEntry(ctx, logger, s, conn)
+ if err != nil {
+ logger.Printf("%s. skipping waitlistEntry %d/%d, serviceID: %s",
+ err.Error(), i, totalServices, s.GetServiceId())
+ stats.WaitlistCreateWaitlistEntryErrors++
+ continue
+ }
+ out = append(out, id)
+ stats.WaitlistCreateWaitlistEntrySuccess++
+ }
+ return out
+}
+
+// RunTests runs waitlist tests.
+func RunTests(ctx context.Context, logger *log.Logger, config *utils.Config, reducedServices []*fpb.Service, stats *utils.TestSummary) {
+ // HealthCheck Flow
+ conn := config.Conn
+ if config.WaitlistHealthFlow || config.WaitlistAllFlows {
+ stats.WaitlistHealthCheckSuccess = true
+ if err := api.HealthCheck(ctx, logger, conn); err != nil {
+ stats.WaitlistHealthCheckSuccess = false
+ logger.Println(err.Error())
+ }
+ stats.WaitlistHealthCheckCompleted = true
+ if !config.WaitlistAllFlows && !config.WaitlistBatchGetWaitEstimatesFlow && !config.WaitlistCreateWaitlistEntryFlow &&
+ !config.WaitlistGetWaitlistEntryFlow && !config.WaitlistDeleteWaitlistEntryFlow {
+ logStats(stats, logger, config)
+ return
+ }
+ }
+
+ // BatchGetWaitEstimates Flow
+ if config.WaitlistBatchGetWaitEstimatesFlow || config.WaitlistAllFlows {
+ utils.LogFlow(logger, "BatchGetWaitEstimates", "Start")
+
+ for i, s := range reducedServices {
+ if err := api.BatchGetWaitEstimates(ctx, logger, s, conn); err != nil {
+ logger.Printf("%s. BatchGerWaitEstimates failed for service %d/%d. Service_id: %s",
+ err.Error(), i, stats.WaitlistTotalServicesProcessed, s.GetServiceId())
+ stats.WaitlistBatchGetWaitEstimatesErrors++
+ continue
+ }
+ stats.WaitlistBatchGetWaitEstimatesSuccess++
+ }
+ stats.WaitlistBatchGetWaitEstimatesCompleted = true
+ utils.LogFlow(logger, "BatchGetWaitEstimates", "End")
+ }
+ // CreateWaitlistEntry Flow.
+ var ids []string
+ if config.WaitlistCreateWaitlistEntryFlow || config.WaitlistGetWaitlistEntryFlow ||
+ config.WaitlistDeleteWaitlistEntryFlow || config.WaitlistAllFlows {
+ utils.LogFlow(logger, "CreateWaitlistEntry", "Start")
+ ids = generateWaitlistEntries(ctx, logger, reducedServices, stats, conn)
+ stats.WaitlistCreateWaitlistEntryCompleted = true
+ utils.LogFlow(logger, "CreateWaitlistEntry", "End")
+ }
+ // GetWaitlistEntry Flow
+ if config.WaitlistGetWaitlistEntryFlow || config.WaitlistAllFlows {
+ utils.LogFlow(logger, "GetWaitlistEntry", "Start")
+ for _, id := range ids {
+ if _, err := api.GetWaitlistEntry(ctx, logger, id, conn); err != nil {
+ logger.Printf("%s. get waitlist entry failed for waitlist entry id: %s",
+ err.Error(), id)
+ stats.WaitlistGetWaitlistEntryErrors++
+ continue
+ }
+ stats.WaitlistGetWaitlistEntrySuccess++
+ }
+ stats.WaitlistGetWaitlistEntryCompleted = true
+ utils.LogFlow(logger, "GetWaitlistEntry", "End")
+ }
+
+ // DeleteWaitlistentry Flow
+ if config.WaitlistDeleteWaitlistEntryFlow || config.WaitlistAllFlows {
+ utils.LogFlow(logger, "DeleteWaitlistEntry", "Start")
+
+ for _, id := range ids {
+ if err := api.DeleteWaitlistEntry(ctx, logger, id, conn); err != nil {
+ logger.Printf("%s. Delete waitlist entry failed for waitlist entry id: %s",
+ err.Error(), id)
+ stats.WaitlistDeleteWaitlistEntryErrors++
+ continue
+ }
+ stats.WaitlistDeleteWaitlistEntrySuccess++
+ }
+ stats.WaitlistDeleteWaitlistEntryCompleted = true
+ utils.LogFlow(logger, "DeleteWaitlistEntry", "End")
+ }
+ logStats(stats, logger, config)
+}
