1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
package testutils
import (
"context"
"fmt"
"io"
"github.com/aws/aws-sdk-go-v2/aws/middleware/private/metrics"
"github.com/aws/smithy-go/middleware"
)
type MetricDataRecorderPublisher struct {
Data *metrics.MetricData
}
func (mdrp *MetricDataRecorderPublisher) PostRequestMetrics(data *metrics.MetricData) error {
mdrp.Data = data
return nil
}
func (mdrp *MetricDataRecorderPublisher) PostStreamMetrics(data *metrics.MetricData) error {
mdrp.Data = data
return nil
}
type NoopPublisher struct{}
func (np *NoopPublisher) PostRequestMetrics(data *metrics.MetricData) error {
return nil
}
func (np *NoopPublisher) PostStreamMetrics(data *metrics.MetricData) error {
return nil
}
type ErrorPublisher struct{}
func (tp *ErrorPublisher) PostRequestMetrics(data *metrics.MetricData) error {
return fmt.Errorf("publisher error")
}
func (tp *ErrorPublisher) PostStreamMetrics(data *metrics.MetricData) error {
return fmt.Errorf("publisher error")
}
type NoopInitializeHandler struct{}
type ErrorInitializeHandler struct{}
type NoopSerializeHandler struct{}
type NoopFinalizeHandler struct{}
type NoopDeserializeHandler struct{}
type StreamingBodyBuildHandler struct {
Result interface{}
}
func (NoopInitializeHandler) HandleInitialize(ctx context.Context, in middleware.InitializeInput) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
return middleware.InitializeOutput{}, middleware.Metadata{}, nil
}
func (ErrorInitializeHandler) HandleInitialize(ctx context.Context, in middleware.InitializeInput) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
return middleware.InitializeOutput{}, middleware.Metadata{}, fmt.Errorf("init error")
}
func (NoopFinalizeHandler) HandleFinalize(ctx context.Context, in middleware.FinalizeInput) (
out middleware.FinalizeOutput, metadata middleware.Metadata, err error,
) {
return middleware.FinalizeOutput{}, middleware.Metadata{}, nil
}
func (NoopDeserializeHandler) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
return middleware.DeserializeOutput{}, middleware.Metadata{}, nil
}
func (NoopSerializeHandler) HandleSerialize(ctx context.Context, in middleware.SerializeInput) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
return middleware.SerializeOutput{}, middleware.Metadata{}, nil
}
func (s *StreamingBodyBuildHandler) HandleBuild(ctx context.Context, in middleware.BuildInput) (
out middleware.BuildOutput, metadata middleware.Metadata, err error,
) {
return middleware.BuildOutput{Result: s.Result}, middleware.Metadata{}, nil
}
type TestReadCloser struct {
Data []byte
offset int
}
func (m *TestReadCloser) Read(p []byte) (int, error) {
if m.offset >= len(m.Data) {
return 0, io.EOF
}
n := copy(p, m.Data[m.offset:])
m.offset += n
return n, nil
}
func (m *TestReadCloser) Close() error {
return nil
}
|
