Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 README.md ## AWS SDK for Go awstesting packages ## `awstesting` is a collection of packages used internally by the SDK, and is subject to have breaking changes. This package is not `internal` so that if you really need to use its functionality, and understand breaking changes will be made, you are able to. These packages will be refactored in the future so that the API generator and model parsers are exposed cleanly on their own.	425 B	2025-05-25 12:27
📄 assert.go package awstesting import ( "encoding/json" "fmt" "net/url" "reflect" "regexp" "sort" "strings" "testing" "github.com/aws/aws-sdk-go/internal/smithytesting" ) // Match is a testing helper to test for testing error by comparing expected // with a regular expression. func Match(t testing.T, regex, expected string) { if !regexp.MustCompile(regex).Match([]byte(expected)) { t.Errorf("%q\n\tdoes not match /%s/", expected, regex) } } // AssertURL verifies the expected URL is matches the actual. func AssertURL(t testing.T, expect, actual string, msgAndArgs ...interface{}) bool { expectURL, err := url.Parse(expect) if err != nil { t.Errorf(errMsg("unable to parse expected URL", err, msgAndArgs)) return false } actualURL, err := url.Parse(actual) if err != nil { t.Errorf(errMsg("unable to parse actual URL", err, msgAndArgs)) return false } equal(t, expectURL.Host, actualURL.Host, msgAndArgs...) equal(t, expectURL.Scheme, actualURL.Scheme, msgAndArgs...) equal(t, expectURL.Path, actualURL.Path, msgAndArgs...) return AssertQuery(t, expectURL.Query().Encode(), actualURL.Query().Encode(), msgAndArgs...) } var queryMapKey = regexp.MustCompile("(.?)\\.[0-9]+\\.key") // AssertQuery verifies the expect HTTP query string matches the actual. func AssertQuery(t testing.T, expect, actual string, msgAndArgs ...interface{}) bool { expectQ, err := url.ParseQuery(expect) if err != nil { t.Errorf(errMsg("unable to parse expected Query", err, msgAndArgs)) return false } actualQ, err := url.ParseQuery(actual) if err != nil { t.Errorf(errMsg("unable to parse actual Query", err, msgAndArgs)) return false } // Make sure the keys are the same if !equal(t, queryValueKeys(expectQ), queryValueKeys(actualQ), msgAndArgs...) { return false } keys := map[string][]string{} for key, v := range expectQ { if queryMapKey.Match([]byte(key)) { submatch := queryMapKey.FindStringSubmatch(key) keys[submatch[1]] = append(keys[submatch[1]], v...) } } for k, v := range keys { // clear all keys that have prefix for key := range expectQ { if strings.HasPrefix(key, k) { delete(expectQ, key) } } sort.Strings(v) for i, value := range v { expectQ[fmt.Sprintf("%s.%d.key", k, i+1)] = []string{value} } } for k, expectQVals := range expectQ { sort.Strings(expectQVals) actualQVals := actualQ[k] sort.Strings(actualQVals) if !equal(t, expectQVals, actualQVals, msgAndArgs...) { return false } } return true } // AssertJSON verifies that the expect json string matches the actual. func AssertJSON(t testing.T, expect, actual string, msgAndArgs ...interface{}) bool { expectVal := map[string]interface{}{} if err := json.Unmarshal([]byte(expect), &expectVal); err != nil { t.Errorf(errMsg("unable to parse expected JSON", err, msgAndArgs...)) return false } actualVal := map[string]interface{}{} if err := json.Unmarshal([]byte(actual), &actualVal); err != nil { t.Errorf(errMsg("unable to parse actual JSON", err, msgAndArgs...)) return false } return equal(t, expectVal, actualVal, msgAndArgs...) } // AssertXML verifies that the expect XML string matches the actual. func AssertXML(t testing.T, expect, actual string, msgAndArgs ...interface{}) bool { if err := smithytesting.XMLEqual([]byte(expect), []byte(actual)); err != nil { t.Error("expect XML match", err, messageFromMsgAndArgs(msgAndArgs)) return false } return true } // DidPanic returns if the function paniced and returns true if the function paniced. func DidPanic(fn func()) (bool, interface{}) { var paniced bool var msg interface{} func() { defer func() { if msg = recover(); msg != nil { paniced = true } }() fn() }() return paniced, msg } // objectsAreEqual determines if two objects are considered equal. // // This function does no assertion of any kind. // // Based on github.com/stretchr/testify/assert.ObjectsAreEqual // Copied locally to prevent non-test build dependencies on testify func objectsAreEqual(expected, actual interface{}) bool { if expected == nil \|\| actual == nil { return expected == actual } return reflect.DeepEqual(expected, actual) } // Equal asserts that two objects are equal. // // assert.Equal(t, 123, 123, "123 and 123 should be equal") // // Returns whether the assertion was successful (true) or not (false). // // Based on github.com/stretchr/testify/assert.Equal // Copied locally to prevent non-test build dependencies on testify func equal(t *testing.T, expected, actual interface{}, msgAndArgs ...interface{}) bool { if !objectsAreEqual(expected, actual) { t.Errorf("%s\n%s", messageFromMsgAndArgs(msgAndArgs), SprintExpectActual(expected, actual)) return false } return true } func errMsg(baseMsg string, err error, msgAndArgs ...interface{}) string { message := messageFromMsgAndArgs(msgAndArgs) if message != "" { message += ", " } return fmt.Sprintf("%s%s, %v", message, baseMsg, err) } // Based on github.com/stretchr/testify/assert.messageFromMsgAndArgs // Copied locally to prevent non-test build dependencies on testify func messageFromMsgAndArgs(msgAndArgs []interface{}) string { if len(msgAndArgs) == 0 \|\| msgAndArgs == nil { return "" } if len(msgAndArgs) == 1 { return msgAndArgs[0].(string) } if len(msgAndArgs) > 1 { return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...) } return "" } func queryValueKeys(v url.Values) []string { keys := make([]string, 0, len(v)) for k := range v { keys = append(keys, k) } sort.Strings(keys) return keys } // SprintExpectActual returns a string for test failure cases when the actual // value is not the same as the expected. func SprintExpectActual(expect, actual interface{}) string { return fmt.Sprintf("expect: %+v\nactual: %+v\n", expect, actual) }	5.69 KB	2025-05-25 12:27
📄 assert_test.go package awstesting_test import ( "encoding/xml" "testing" "github.com/aws/aws-sdk-go/awstesting" ) func TestAssertJSON(t testing.T) { cases := []struct { e, a string asserts bool }{ { e: `{"RecursiveStruct":{"RecursiveMap":{"foo":{"NoRecurse":"foo"},"bar":{"NoRecurse":"bar"}}}}`, a: `{"RecursiveStruct":{"RecursiveMap":{"bar":{"NoRecurse":"bar"},"foo":{"NoRecurse":"foo"}}}}`, asserts: true, }, } for i, c := range cases { mockT := &testing.T{} if awstesting.AssertJSON(mockT, c.e, c.a) != c.asserts { t.Error("Assert JSON result was not expected.", i) } } } func TestAssertXML(t testing.T) { cases := []struct { e, a string asserts bool container struct { XMLName xml.Name `xml:"OperationRequest"` NS string `xml:"xmlns,attr"` RecursiveStruct struct { XMLName xml.Name RecursiveMap struct { XMLName xml.Name Entries []struct { Key string `xml:"key"` Value struct { XMLName xml.Name `xml:"value"` NoRecurse string } } `xml:"entry"` } } } }{ { e: `<OperationRequest xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><RecursiveMap xmlns="https://foo/"><entry xmlns="https://foo/"><key xmlns="https://foo/">foo</key><value xmlns="https://foo/"><NoRecurse xmlns="https://foo/">foo</NoRecurse></value></entry><entry xmlns="https://foo/"><key xmlns="https://foo/">bar</key><value xmlns="https://foo/"><NoRecurse xmlns="https://foo/">bar</NoRecurse></value></entry></RecursiveMap></RecursiveStruct></OperationRequest>`, a: `<OperationRequest xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><RecursiveMap xmlns="https://foo/"><entry xmlns="https://foo/"><key xmlns="https://foo/">foo</key><value xmlns="https://foo/"><NoRecurse xmlns="https://foo/">foo</NoRecurse></value></entry><entry xmlns="https://foo/"><key xmlns="https://foo/">bar</key><value xmlns="https://foo/"><NoRecurse xmlns="https://foo/">bar</NoRecurse></value></entry></RecursiveMap></RecursiveStruct></OperationRequest>`, asserts: true, }, { e: `<OperationRequest xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><RecursiveMap xmlns="https://foo/"><entry xmlns="https://foo/"><key xmlns="https://foo/">foo</key><value xmlns="https://foo/"><NoRecurse xmlns="https://foo/">foo</NoRecurse></value></entry><entry xmlns="https://foo/"><key xmlns="https://foo/">bar</key><value xmlns="https://foo/"><NoRecurse xmlns="https://foo/">bar</NoRecurse></value></entry></RecursiveMap></RecursiveStruct></OperationRequest>`, a: `<OperationRequest xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><RecursiveMap xmlns="https://foo/"><entry xmlns="https://foo/"><key xmlns="https://foo/">baz</key><value xmlns="https://foo/"><NoRecurse xmlns="https://foo/">baz</NoRecurse></value></entry></RecursiveMap></RecursiveStruct></OperationRequest>`, asserts: false, }, } for i, c := range cases { mockT := &testing.T{} if awstesting.AssertXML(mockT, c.e, c.a) != c.asserts { t.Error("Assert XML result was not expected.", i) } } } func TestAssertQuery(t *testing.T) { cases := []struct { e, a string asserts bool }{ { e: `Action=OperationName&Version=2014-01-01&Foo=val1&Bar=val2`, a: `Action=OperationName&Version=2014-01-01&Foo=val2&Bar=val3`, asserts: false, }, { e: `Action=OperationName&Version=2014-01-01&Foo=val1&Bar=val2`, a: `Action=OperationName&Version=2014-01-01&Foo=val1&Bar=val2`, asserts: true, }, } for i, c := range cases { mockT := &testing.T{} if awstesting.AssertQuery(mockT, c.e, c.a) != c.asserts { t.Error("Assert Query result was not expected.", i) } } }	3.68 KB	2025-05-25 12:27
📄 certificate_utils.go package awstesting import ( "bytes" "crypto/rand" "crypto/rsa" "crypto/tls" "crypto/x509" "crypto/x509/pkix" "encoding/pem" "fmt" "io/ioutil" "math/big" "net" "net/http" "net/http/httptest" "os" "strings" "time" ) var ( // TLSBundleCA is the CA PEM TLSBundleCA []byte // TLSBundleCert is the Server PEM TLSBundleCert []byte // TLSBundleKey is the Server private key PEM TLSBundleKey []byte // ClientTLSCert is the Client PEM ClientTLSCert []byte // ClientTLSKey is the Client private key PEM ClientTLSKey []byte ) func init() { caPEM, _, caCert, caPrivKey, err := generateRootCA() if err != nil { panic("failed to generate testing root CA, " + err.Error()) } TLSBundleCA = caPEM serverCertPEM, serverCertPrivKeyPEM, err := generateLocalCert(caCert, caPrivKey) if err != nil { panic("failed to generate testing server cert, " + err.Error()) } TLSBundleCert = serverCertPEM TLSBundleKey = serverCertPrivKeyPEM clientCertPEM, clientCertPrivKeyPEM, err := generateLocalCert(caCert, caPrivKey) if err != nil { panic("failed to generate testing client cert, " + err.Error()) } ClientTLSCert = clientCertPEM ClientTLSKey = clientCertPrivKeyPEM } func generateRootCA() ( caPEM, caPrivKeyPEM []byte, caCert x509.Certificate, caPrivKey rsa.PrivateKey, err error, ) { caCert = &x509.Certificate{ SerialNumber: big.NewInt(42), Subject: pkix.Name{ Country: []string{"US"}, Organization: []string{"AWS SDK for Go Test Certificate"}, CommonName: "Test Root CA", }, NotBefore: time.Now().Add(-time.Minute), NotAfter: time.Now().AddDate(1, 0, 0), KeyUsage: x509.KeyUsageCertSign \| x509.KeyUsageCRLSign \| x509.KeyUsageDigitalSignature, ExtKeyUsage: []x509.ExtKeyUsage{ x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth, }, BasicConstraintsValid: true, IsCA: true, } // Create CA private and public key caPrivKey, err = rsa.GenerateKey(rand.Reader, 4096) if err != nil { return nil, nil, nil, nil, fmt.Errorf("failed generate CA RSA key, %w", err) } // Create CA certificate caBytes, err := x509.CreateCertificate(rand.Reader, caCert, caCert, &caPrivKey.PublicKey, caPrivKey) if err != nil { return nil, nil, nil, nil, fmt.Errorf("failed generate CA certificate, %w", err) } // PEM encode CA certificate and private key var caPEMBuf bytes.Buffer pem.Encode(&caPEMBuf, &pem.Block{ Type: "CERTIFICATE", Bytes: caBytes, }) var caPrivKeyPEMBuf bytes.Buffer pem.Encode(&caPrivKeyPEMBuf, &pem.Block{ Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(caPrivKey), }) return caPEMBuf.Bytes(), caPrivKeyPEMBuf.Bytes(), caCert, caPrivKey, nil } func generateLocalCert(parentCert x509.Certificate, parentPrivKey rsa.PrivateKey) ( certPEM, certPrivKeyPEM []byte, err error, ) { cert := &x509.Certificate{ SerialNumber: big.NewInt(42), Subject: pkix.Name{ Country: []string{"US"}, Organization: []string{"AWS SDK for Go Test Certificate"}, CommonName: "Test Root CA", }, IPAddresses: []net.IP{ net.IPv4(127, 0, 0, 1), net.IPv6loopback, }, NotBefore: time.Now().Add(-time.Minute), NotAfter: time.Now().AddDate(1, 0, 0), ExtKeyUsage: []x509.ExtKeyUsage{ x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth, }, KeyUsage: x509.KeyUsageDigitalSignature, } // Create server private and public key certPrivKey, err := rsa.GenerateKey(rand.Reader, 4096) if err != nil { return nil, nil, fmt.Errorf("failed to generate server RSA private key, %w", err) } // Create server certificate certBytes, err := x509.CreateCertificate(rand.Reader, cert, parentCert, &certPrivKey.PublicKey, parentPrivKey) if err != nil { return nil, nil, fmt.Errorf("failed to generate server certificate, %w", err) } // PEM encode certificate and private key var certPEMBuf bytes.Buffer pem.Encode(&certPEMBuf, &pem.Block{ Type: "CERTIFICATE", Bytes: certBytes, }) var certPrivKeyPEMBuf bytes.Buffer pem.Encode(&certPrivKeyPEMBuf, &pem.Block{ Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(certPrivKey), }) return certPEMBuf.Bytes(), certPrivKeyPEMBuf.Bytes(), nil } // NewTLSClientCertServer creates a new HTTP test server initialize to require // HTTP clients authenticate with TLS client certificates. func NewTLSClientCertServer(handler http.Handler) (httptest.Server, error) { server := httptest.NewUnstartedServer(handler) if server.TLS == nil { server.TLS = &tls.Config{} } server.TLS.ClientAuth = tls.RequireAndVerifyClientCert if server.TLS.ClientCAs == nil { server.TLS.ClientCAs = x509.NewCertPool() } certPem := append(ClientTLSCert, ClientTLSKey...) if ok := server.TLS.ClientCAs.AppendCertsFromPEM(certPem); !ok { return nil, fmt.Errorf("failed to append client certs") } return server, nil } // CreateClientTLSCertFiles returns a set of temporary files for the client // certificate and key files. func CreateClientTLSCertFiles() (cert, key string, err error) { cert, err = createTmpFile(ClientTLSCert) if err != nil { return "", "", err } key, err = createTmpFile(ClientTLSKey) if err != nil { return "", "", err } return cert, key, nil } func availableLocalAddr(ip string) (string, error) { l, err := net.Listen("tcp", ip+":0") if err != nil { return "", err } defer l.Close() return l.Addr().String(), nil } // CreateTLSServer will create the TLS server on an open port using the // certificate and key. The address will be returned that the server is running on. func CreateTLSServer(cert, key string, mux http.ServeMux) (string, error) { addr, err := availableLocalAddr("127.0.0.1") if err != nil { return "", err } if mux == nil { mux = http.NewServeMux() mux.HandleFunc("/", func(w http.ResponseWriter, r http.Request) {}) } go func() { if err := http.ListenAndServeTLS(addr, cert, key, mux); err != nil { panic(err) } }() for i := 0; i < 60; i++ { if _, err := http.Get("https://" + addr); err != nil && !strings.Contains(err.Error(), "connection refused") { break } time.Sleep(1 time.Second) } return "https://" + addr, nil } // CreateTLSBundleFiles returns the temporary filenames for the certificate // key, and CA PEM content. These files should be deleted when no longer // needed. CleanupTLSBundleFiles can be used for this cleanup. func CreateTLSBundleFiles() (cert, key, ca string, err error) { cert, err = createTmpFile(TLSBundleCert) if err != nil { return "", "", "", err } key, err = createTmpFile(TLSBundleKey) if err != nil { return "", "", "", err } ca, err = createTmpFile(TLSBundleCA) if err != nil { return "", "", "", err } return cert, key, ca, nil } // CleanupTLSBundleFiles takes variadic list of files to be deleted. func CleanupTLSBundleFiles(files ...string) error { for _, file := range files { if err := os.Remove(file); err != nil { return err } } return nil } func createTmpFile(b []byte) (string, error) { bundleFile, err := ioutil.TempFile(os.TempDir(), "aws-sdk-go-session-test") if err != nil { return "", err } _, err = bundleFile.Write(b) if err != nil { return "", err } defer bundleFile.Close() return bundleFile.Name(), nil }	7.06 KB	2025-05-25 12:27
📄 client.go package awstesting import ( "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/client" "github.com/aws/aws-sdk-go/aws/client/metadata" "github.com/aws/aws-sdk-go/aws/defaults" ) // NewClient creates and initializes a generic service client for testing. func NewClient(cfgs ...aws.Config) client.Client { info := metadata.ClientInfo{ Endpoint: "http://endpoint", SigningName: "", } def := defaults.Get() def.Config.MergeIn(cfgs...) if v := aws.StringValue(def.Config.Endpoint); len(v) > 0 { info.Endpoint = v } return client.New(*def.Config, info, def.Handlers) }	601 B	2025-05-25 12:27
📁 cmd	-	2025-05-25 12:27
📄 discard.go package awstesting // DiscardAt is an io.WriteAt that discards // the requested bytes to be written type DiscardAt struct{} // WriteAt discards the given []byte slice and returns len(p) bytes // as having been written at the given offset. It will never return an error. func (d DiscardAt) WriteAt(p []byte, off int64) (n int, err error) { return len(p), nil }	363 B	2025-05-25 12:27
📄 endless_reader.go package awstesting // EndlessReader is an io.Reader that will always return // that bytes have been read. type EndlessReader struct{} // Read will report that it has read len(p) bytes in p. // The content in the []byte will be unmodified. // This will never return an error. func (e EndlessReader) Read(p []byte) (int, error) { return len(p), nil }	352 B	2025-05-25 12:27
📁 integration	-	2025-05-25 12:27
📁 mock	-	2025-05-25 12:27
📁 sandbox	-	2025-05-25 12:27
📁 unit	-	2025-05-25 12:27
📄 util.go package awstesting import ( "io" "os" "strings" "time" "github.com/aws/aws-sdk-go/private/util" ) // ZeroReader is a io.Reader which will always write zeros to the byte slice provided. type ZeroReader struct{} // Read fills the provided byte slice with zeros returning the number of bytes written. func (r ZeroReader) Read(b []byte) (int, error) { for i := 0; i < len(b); i++ { b[i] = 0 } return len(b), nil } // ReadCloser is a io.ReadCloser for unit testing. // Designed to test for leaks and whether a handle has // been closed type ReadCloser struct { Size int Closed bool set bool FillData func(bool, []byte, int, int) } // Read will call FillData and fill it with whatever data needed. // Decrements the size until zero, then return io.EOF. func (r ReadCloser) Read(b []byte) (int, error) { if r.Closed { return 0, io.EOF } delta := len(b) if delta > r.Size { delta = r.Size } r.Size -= delta for i := 0; i < delta; i++ { b[i] = 'a' } if r.FillData != nil { r.FillData(r.set, b, r.Size, delta) } r.set = true if r.Size > 0 { return delta, nil } return delta, io.EOF } // Close sets Closed to true and returns no error func (r ReadCloser) Close() error { r.Closed = true return nil } // SortedKeys returns a sorted slice of keys of a map. func SortedKeys(m map[string]interface{}) []string { return util.SortedKeys(m) } // A FakeContext provides a simple stub implementation of a Context type FakeContext struct { Error error DoneCh chan struct{} } // Deadline always will return not set func (c FakeContext) Deadline() (deadline time.Time, ok bool) { return time.Time{}, false } // Done returns a read channel for listening to the Done event func (c FakeContext) Done() <-chan struct{} { return c.DoneCh } // Err returns the error, is nil if not set. func (c FakeContext) Err() error { return c.Error } // Value ignores the Value and always returns nil func (c *FakeContext) Value(key interface{}) interface{} { return nil } // StashEnv stashes the current environment variables and returns an array of // all environment values as key=val strings. // // Deprecated: StashEnv exists for backward compatibility and may be removed from the future iterations. // It is not `internal` so that if you really need to use its functionality, and understand breaking // changes will be made, you are able to. func StashEnv() []string { env := os.Environ() os.Clearenv() return env } // PopEnv takes the list of the environment values and injects them into the // process's environment variable data. Clears any existing environment values // that may already exist. // // Deprecated: PopEnv exists for backward compatibility and may be removed from the future iterations. // It is not `internal` so that if you really need to use its functionality, and understand breaking // changes will be made, you are able to. func PopEnv(env []string) { os.Clearenv() for _, e := range env { p := strings.SplitN(e, "=", 2) k, v := p[0], "" if len(p) > 1 { v = p[1] } os.Setenv(k, v) } }	3 KB	2025-05-25 12:27
📄 util_test.go package awstesting_test import ( "io" "testing" "github.com/aws/aws-sdk-go/awstesting" ) func TestReadCloserClose(t testing.T) { rc := awstesting.ReadCloser{Size: 1} err := rc.Close() if err != nil { t.Errorf("expect nil, got %v", err) } if !rc.Closed { t.Errorf("expect closed, was not") } if e, a := rc.Size, 1; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestReadCloserRead(t testing.T) { rc := awstesting.ReadCloser{Size: 5} b := make([]byte, 2) n, err := rc.Read(b) if err != nil { t.Errorf("expect nil, got %v", err) } if e, a := n, 2; e != a { t.Errorf("expect %v, got %v", e, a) } if rc.Closed { t.Errorf("expect not to be closed") } if e, a := rc.Size, 3; e != a { t.Errorf("expect %v, got %v", e, a) } err = rc.Close() if err != nil { t.Errorf("expect nil, got %v", err) } n, err = rc.Read(b) if e, a := err, io.EOF; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := n, 0; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestReadCloserReadAll(t *testing.T) { rc := awstesting.ReadCloser{Size: 5} b := make([]byte, 5) n, err := rc.Read(b) if e, a := err, io.EOF; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := n, 5; e != a { t.Errorf("expect %v, got %v", e, a) } if rc.Closed { t.Errorf("expect not to be closed") } if e, a := rc.Size, 0; e != a { t.Errorf("expect %v, got %v", e, a) } }	1.38 KB	2025-05-25 12:27

Terminal