vendor: add github.com/Azure/azure-sdk-for-go and dependencies
This commit is contained in:
Nick Craig-Wood
+137
@@ -0,0 +1,137 @@
|
||||
package mocks
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
"time"
|
||||
)
|
||||
|
||||
const (
|
||||
// TestAuthorizationHeader is a faux HTTP Authorization header value
|
||||
TestAuthorizationHeader = "BEARER SECRETTOKEN"
|
||||
|
||||
// TestBadURL is a malformed URL
|
||||
TestBadURL = " "
|
||||
|
||||
// TestDelay is the Retry-After delay used in tests.
|
||||
TestDelay = 0 * time.Second
|
||||
|
||||
// TestHeader is the header used in tests.
|
||||
TestHeader = "x-test-header"
|
||||
|
||||
// TestURL is the URL used in tests.
|
||||
TestURL = "https://microsoft.com/a/b/c/"
|
||||
|
||||
// TestAzureAsyncURL is a URL used in Azure asynchronous tests
|
||||
TestAzureAsyncURL = "https://microsoft.com/a/b/c/async"
|
||||
|
||||
// TestLocationURL is a URL used in Azure asynchronous tests
|
||||
TestLocationURL = "https://microsoft.com/a/b/c/location"
|
||||
)
|
||||
|
||||
const (
|
||||
headerLocation = "Location"
|
||||
headerRetryAfter = "Retry-After"
|
||||
)
|
||||
|
||||
// NewRequest instantiates a new request.
|
||||
func NewRequest() *http.Request {
|
||||
return NewRequestWithContent("")
|
||||
}
|
||||
|
||||
// NewRequestWithContent instantiates a new request using the passed string for the body content.
|
||||
func NewRequestWithContent(c string) *http.Request {
|
||||
r, _ := http.NewRequest("GET", "https://microsoft.com/a/b/c/", NewBody(c))
|
||||
return r
|
||||
}
|
||||
|
||||
// NewRequestWithCloseBody instantiates a new request.
|
||||
func NewRequestWithCloseBody() *http.Request {
|
||||
return NewRequestWithCloseBodyContent("request body")
|
||||
}
|
||||
|
||||
// NewRequestWithCloseBodyContent instantiates a new request using the passed string for the body content.
|
||||
func NewRequestWithCloseBodyContent(c string) *http.Request {
|
||||
r, _ := http.NewRequest("GET", "https://microsoft.com/a/b/c/", NewBodyClose(c))
|
||||
return r
|
||||
}
|
||||
|
||||
// NewRequestForURL instantiates a new request using the passed URL.
|
||||
func NewRequestForURL(u string) *http.Request {
|
||||
r, err := http.NewRequest("GET", u, NewBody(""))
|
||||
if err != nil {
|
||||
panic(fmt.Sprintf("mocks: ERROR (%v) parsing testing URL %s", err, u))
|
||||
}
|
||||
return r
|
||||
}
|
||||
|
||||
// NewResponse instantiates a new response.
|
||||
func NewResponse() *http.Response {
|
||||
return NewResponseWithContent("")
|
||||
}
|
||||
|
||||
// NewResponseWithContent instantiates a new response with the passed string as the body content.
|
||||
func NewResponseWithContent(c string) *http.Response {
|
||||
return &http.Response{
|
||||
Status: "200 OK",
|
||||
StatusCode: 200,
|
||||
Proto: "HTTP/1.0",
|
||||
ProtoMajor: 1,
|
||||
ProtoMinor: 0,
|
||||
Body: NewBody(c),
|
||||
Request: NewRequest(),
|
||||
}
|
||||
}
|
||||
|
||||
// NewResponseWithStatus instantiates a new response using the passed string and integer as the
|
||||
// status and status code.
|
||||
func NewResponseWithStatus(s string, c int) *http.Response {
|
||||
resp := NewResponse()
|
||||
resp.Status = s
|
||||
resp.StatusCode = c
|
||||
return resp
|
||||
}
|
||||
|
||||
// NewResponseWithBodyAndStatus instantiates a new response using the specified mock body,
|
||||
// status and status code
|
||||
func NewResponseWithBodyAndStatus(body *Body, c int, s string) *http.Response {
|
||||
resp := NewResponse()
|
||||
resp.Body = body
|
||||
resp.Status = s
|
||||
resp.StatusCode = c
|
||||
return resp
|
||||
}
|
||||
|
||||
// SetResponseHeader adds a header to the passed response.
|
||||
func SetResponseHeader(resp *http.Response, h string, v string) {
|
||||
if resp.Header == nil {
|
||||
resp.Header = make(http.Header)
|
||||
}
|
||||
resp.Header.Set(h, v)
|
||||
}
|
||||
|
||||
// SetResponseHeaderValues adds a header containing all the passed string values.
|
||||
func SetResponseHeaderValues(resp *http.Response, h string, values []string) {
|
||||
if resp.Header == nil {
|
||||
resp.Header = make(http.Header)
|
||||
}
|
||||
for _, v := range values {
|
||||
resp.Header.Add(h, v)
|
||||
}
|
||||
}
|
||||
|
||||
// SetAcceptedHeaders adds the headers usually associated with a 202 Accepted response.
|
||||
func SetAcceptedHeaders(resp *http.Response) {
|
||||
SetLocationHeader(resp, TestURL)
|
||||
SetRetryHeader(resp, TestDelay)
|
||||
}
|
||||
|
||||
// SetLocationHeader adds the Location header.
|
||||
func SetLocationHeader(resp *http.Response, location string) {
|
||||
SetResponseHeader(resp, http.CanonicalHeaderKey(headerLocation), location)
|
||||
}
|
||||
|
||||
// SetRetryHeader adds the Retry-After header.
|
||||
func SetRetryHeader(resp *http.Response, delay time.Duration) {
|
||||
SetResponseHeader(resp, http.CanonicalHeaderKey(headerRetryAfter), fmt.Sprintf("%v", delay.Seconds()))
|
||||
}
|
||||
+1
@@ -0,0 +1 @@
|
||||
package mocks
|
||||
+162
@@ -0,0 +1,162 @@
|
||||
/*
|
||||
Package mocks provides mocks and helpers used in testing.
|
||||
*/
|
||||
package mocks
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
)
|
||||
|
||||
// Body implements acceptable body over a string.
|
||||
type Body struct {
|
||||
s string
|
||||
b []byte
|
||||
isOpen bool
|
||||
closeAttempts int
|
||||
}
|
||||
|
||||
// NewBody creates a new instance of Body.
|
||||
func NewBody(s string) *Body {
|
||||
return (&Body{s: s}).reset()
|
||||
}
|
||||
|
||||
// NewBodyClose creates a new instance of Body.
|
||||
func NewBodyClose(s string) *Body {
|
||||
return &Body{s: s}
|
||||
}
|
||||
|
||||
// Read reads into the passed byte slice and returns the bytes read.
|
||||
func (body *Body) Read(b []byte) (n int, err error) {
|
||||
if !body.IsOpen() {
|
||||
return 0, fmt.Errorf("ERROR: Body has been closed")
|
||||
}
|
||||
if len(body.b) == 0 {
|
||||
return 0, io.EOF
|
||||
}
|
||||
n = copy(b, body.b)
|
||||
body.b = body.b[n:]
|
||||
return n, nil
|
||||
}
|
||||
|
||||
// Close closes the body.
|
||||
func (body *Body) Close() error {
|
||||
if body.isOpen {
|
||||
body.isOpen = false
|
||||
body.closeAttempts++
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CloseAttempts returns the number of times Close was called.
|
||||
func (body *Body) CloseAttempts() int {
|
||||
return body.closeAttempts
|
||||
}
|
||||
|
||||
// IsOpen returns true if the Body has not been closed, false otherwise.
|
||||
func (body *Body) IsOpen() bool {
|
||||
return body.isOpen
|
||||
}
|
||||
|
||||
func (body *Body) reset() *Body {
|
||||
body.isOpen = true
|
||||
body.b = []byte(body.s)
|
||||
return body
|
||||
}
|
||||
|
||||
// Sender implements a simple null sender.
|
||||
type Sender struct {
|
||||
attempts int
|
||||
responses []*http.Response
|
||||
repeatResponse []int
|
||||
err error
|
||||
repeatError int
|
||||
emitErrorAfter int
|
||||
}
|
||||
|
||||
// NewSender creates a new instance of Sender.
|
||||
func NewSender() *Sender {
|
||||
return &Sender{}
|
||||
}
|
||||
|
||||
// Do accepts the passed request and, based on settings, emits a response and possible error.
|
||||
func (c *Sender) Do(r *http.Request) (resp *http.Response, err error) {
|
||||
c.attempts++
|
||||
|
||||
if len(c.responses) > 0 {
|
||||
resp = c.responses[0]
|
||||
if resp != nil {
|
||||
if b, ok := resp.Body.(*Body); ok {
|
||||
b.reset()
|
||||
}
|
||||
}
|
||||
c.repeatResponse[0]--
|
||||
if c.repeatResponse[0] == 0 {
|
||||
c.responses = c.responses[1:]
|
||||
c.repeatResponse = c.repeatResponse[1:]
|
||||
}
|
||||
} else {
|
||||
resp = NewResponse()
|
||||
}
|
||||
if resp != nil {
|
||||
resp.Request = r
|
||||
}
|
||||
|
||||
if c.emitErrorAfter > 0 {
|
||||
c.emitErrorAfter--
|
||||
} else if c.err != nil {
|
||||
err = c.err
|
||||
c.repeatError--
|
||||
if c.repeatError == 0 {
|
||||
c.err = nil
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// AppendResponse adds the passed http.Response to the response stack.
|
||||
func (c *Sender) AppendResponse(resp *http.Response) {
|
||||
c.AppendAndRepeatResponse(resp, 1)
|
||||
}
|
||||
|
||||
// AppendAndRepeatResponse adds the passed http.Response to the response stack along with a
|
||||
// repeat count. A negative repeat count will return the response for all remaining calls to Do.
|
||||
func (c *Sender) AppendAndRepeatResponse(resp *http.Response, repeat int) {
|
||||
if c.responses == nil {
|
||||
c.responses = []*http.Response{resp}
|
||||
c.repeatResponse = []int{repeat}
|
||||
} else {
|
||||
c.responses = append(c.responses, resp)
|
||||
c.repeatResponse = append(c.repeatResponse, repeat)
|
||||
}
|
||||
}
|
||||
|
||||
// Attempts returns the number of times Do was called.
|
||||
func (c *Sender) Attempts() int {
|
||||
return c.attempts
|
||||
}
|
||||
|
||||
// SetError sets the error Do should return.
|
||||
func (c *Sender) SetError(err error) {
|
||||
c.SetAndRepeatError(err, 1)
|
||||
}
|
||||
|
||||
// SetAndRepeatError sets the error Do should return and how many calls to Do will return the error.
|
||||
// A negative repeat value will return the error for all remaining calls to Do.
|
||||
func (c *Sender) SetAndRepeatError(err error, repeat int) {
|
||||
c.err = err
|
||||
c.repeatError = repeat
|
||||
}
|
||||
|
||||
// SetEmitErrorAfter sets the number of attempts to be made before errors are emitted.
|
||||
func (c *Sender) SetEmitErrorAfter(ea int) {
|
||||
c.emitErrorAfter = ea
|
||||
}
|
||||
|
||||
// T is a simple testing struct.
|
||||
type T struct {
|
||||
Name string `json:"name" xml:"Name"`
|
||||
Age int `json:"age" xml:"Age"`
|
||||
}
|
||||
+1
@@ -0,0 +1 @@
|
||||
package mocks
|
||||
Reference in New Issue
Block a user