c/ooni-probe-cli
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ac2e0d718f
ooni-probe-cli/internal/archival/trace_test.go

922 lines
25 KiB
Go
Raw Normal View History

feature: merge measurex and netx archival layer (1/N) (#663) This diff introduces a new package called `./internal/archival`. This package collects data from `./internal/model` network interfaces (e.g., `Dialer`, `QUICDialer`, `HTTPTransport`), saves such data into an internal tabular data format suitable for on-line processing and analysis, and allows exporting data into the OONI data format. The code for collecting and the internal tabular data formats are adapted from `measurex`. The code for formatting and exporting OONI data-format-compliant structures is adapted from `netx/archival`. My original objective was to _also_ (1) fully replace `netx/archival` with this package and (2) adapt `measurex` to use this package rather than its own code. Both operations seem easily feasible because: (a) this code is `measurex` code without extensions that are `measurex` related, which will need to be added back as part of the process; (b) the API provided by this code allows for trivially converting from using `netx/archival` to using this code. Yet, both changes should not be taken lightly. After implementing them, there's need to spend some time doing QA and ensuring all nettests work as intended. However, I am planning a release in the next two weeks, and this QA task is likely going to defer the release. For this reason, I have chosen to commit the work done so far into the tree and defer the second part of this refactoring for a later moment in time. (This explains why the title mentions "1/N"). On a more high-level perspective, it would also be beneficial, I guess, to explain _why_ I am doing these changes. There are two intertwined reasons. The first reason is that `netx/archival` has shortcomings deriving from its original https://github.com/ooni/netx legacy. The most relevant shortcoming is that it saves all kind of data into the same tabular structure named `Event`. This design choice is unfortunate because it does not allow one to apply data-type specific logic when processing the results. In turn, this choice results in complex processing code. Therefore, I believe that replacing the code with event-specific data structures is clearly an improvement in terms of code maintainability and would quite likely lead us to more confidently change and evolve the codebase. The second reason why I would like to move forward these changes is to unify the codepaths used for measuring. At this point in time, we basically have two codepaths: `./internal/engine/netx` and `./internal/measurex`. They both have pros and cons and I don't think we want to rewrite whole experiments using `netx`. Rather, what we probably want is to gradually merge these two codepaths such that `netx` is a set of abstractions on top of `measurex` (which is more low-level and has a more-easily-testable design). Because saving events and generating an archival data format out of them consists of at least 50% of the complexity of both `netx` and `measurex`, it seems reasonable to unify this archival-related part of the two codebases as the first step. At the highest level of abstraction, these changes are part of the train of changes which will eventually lead us to bless `websteps` as a first class citizen in OONI land. Because `websteps` requires different underlying primitives, I chose to develop these primitives from scratch rather than wrestling with `netx`, which used another model. The model used by `websteps` is that we perform each operation in isolation and immediately we save the results, while `netx` creates whole data structures and collects all the events happening via tracing. We believe the model used by `websteps` to be better because it does not require your code to figure out everything that happened after the measurement, which is a source of subtle bugs in the current implementation. So, when I started implementing websteps I extracted the bits of `netx` that could also be beneficial to `websteps` into a separate library, thus `netxlite` was born. The reference issue describing merging the archival of `netx` and `measurex` is https://github.com/ooni/probe/issues/1957. As of this writing the issue still references the original plan, which I could not complete by the end of this Sprint, so I am going to adapt the text of the issue to only refer to what was done in here next. Of course, I also need follow-up issues.
2022-01-14 12:13:10 +01:00
package archival
import (
"errors"
"io"
"net/http"
"testing"
"time"
"github.com/google/go-cmp/cmp"
"github.com/ooni/probe-cli/v3/internal/model"
"github.com/ooni/probe-cli/v3/internal/netxlite"
)
// traceTime generates a time that is based off a fixed beginning
// in time, so we can easily compare times.
func traceTime(d int64) time.Time {
t := time.Date(2021, 01, 13, 14, 21, 59, 0, time.UTC)
return t.Add(time.Duration(d) * time.Millisecond)
}
// deltaSinceTraceTime computes the delta since the original
// trace time expressed in floating point seconds.
func deltaSinceTraceTime(d int64) float64 {
return (time.Duration(d) * time.Millisecond).Seconds()
}
// failureFromString converts a string to a failure.
func failureFromString(failure string) *string {
return &failure
}
func TestTraceNewArchivalTCPConnectResultList(t *testing.T) {
type fields struct {
DNSLookupHTTPS []*DNSLookupEvent
DNSLookupHost []*DNSLookupEvent
DNSRoundTrip []*DNSRoundTripEvent
HTTPRoundTrip []*HTTPRoundTripEvent
Network []*NetworkEvent
QUICHandshake []*QUICTLSHandshakeEvent
TLSHandshake []*QUICTLSHandshakeEvent
}
type args struct {
begin time.Time
}
tests := []struct {
name string
fields fields
args args
wantOut []model.ArchivalTCPConnectResult
}{{
name: "with empty trace",
fields: fields{
DNSLookupHTTPS: []*DNSLookupEvent{},
DNSLookupHost: []*DNSLookupEvent{},
DNSRoundTrip: []*DNSRoundTripEvent{},
HTTPRoundTrip: []*HTTPRoundTripEvent{},
Network: []*NetworkEvent{},
QUICHandshake: []*QUICTLSHandshakeEvent{},
TLSHandshake: []*QUICTLSHandshakeEvent{},
},
args: args{
begin: traceTime(0),
},
wantOut: nil,
}, {
name: "we ignore I/O operations",
fields: fields{
DNSLookupHTTPS: []*DNSLookupEvent{},
DNSLookupHost: []*DNSLookupEvent{},
DNSRoundTrip: []*DNSRoundTripEvent{},
HTTPRoundTrip: []*HTTPRoundTripEvent{},
Network: []*NetworkEvent{{
Count: 1024,
Failure: nil,
Finished: traceTime(2),
Network: "tcp",
Operation: netxlite.WriteOperation,
RemoteAddr: "8.8.8.8:443",
Started: traceTime(1),
}, {
Count: 4096,
Failure: nil,
Finished: traceTime(4),
Network: "tcp",
Operation: netxlite.ReadOperation,
RemoteAddr: "8.8.8.8:443",
Started: traceTime(3),
}},
QUICHandshake: []*QUICTLSHandshakeEvent{},
TLSHandshake: []*QUICTLSHandshakeEvent{},
},
args: args{
begin: traceTime(0),
},
wantOut: nil,
}, {
name: "we ignore UDP connect",
fields: fields{
DNSLookupHTTPS: []*DNSLookupEvent{},
DNSLookupHost: []*DNSLookupEvent{},
DNSRoundTrip: []*DNSRoundTripEvent{},
HTTPRoundTrip: []*HTTPRoundTripEvent{},
Network: []*NetworkEvent{{
Count: 0,
Failure: nil,
Finished: traceTime(2),
Network: "udp",
Operation: netxlite.ConnectOperation,
RemoteAddr: "8.8.8.8:53",
Started: traceTime(1),
}},
QUICHandshake: []*QUICTLSHandshakeEvent{},
TLSHandshake: []*QUICTLSHandshakeEvent{},
},
args: args{
begin: traceTime(0),
},
wantOut: nil,
}, {
name: "with TCP connect success",
fields: fields{
DNSLookupHTTPS: []*DNSLookupEvent{},
DNSLookupHost: []*DNSLookupEvent{},
DNSRoundTrip: []*DNSRoundTripEvent{},
HTTPRoundTrip: []*HTTPRoundTripEvent{},
Network: []*NetworkEvent{{
Count: 0,
Failure: nil,
Finished: traceTime(2),
Network: "tcp",
Operation: netxlite.ConnectOperation,
RemoteAddr: "8.8.8.8:443",
Started: traceTime(1),
}},
QUICHandshake: []*QUICTLSHandshakeEvent{},
TLSHandshake: []*QUICTLSHandshakeEvent{},
},
args: args{
begin: traceTime(0),
},
wantOut: []model.ArchivalTCPConnectResult{{
IP: "8.8.8.8",
Port: 443,
Status: model.ArchivalTCPConnectStatus{
Blocked: nil,
Failure: nil,
Success: true,
},
T: deltaSinceTraceTime(2),
}},
}, {
name: "with TCP connect failure",
fields: fields{
DNSLookupHTTPS: []*DNSLookupEvent{},
DNSLookupHost: []*DNSLookupEvent{},
DNSRoundTrip: []*DNSRoundTripEvent{},
HTTPRoundTrip: []*HTTPRoundTripEvent{},
Network: []*NetworkEvent{{
Count: 0,
Failure: netxlite.NewTopLevelGenericErrWrapper(netxlite.ECONNREFUSED),
Finished: traceTime(2),
Network: "tcp",
Operation: netxlite.ConnectOperation,
RemoteAddr: "8.8.8.8:443",
Started: traceTime(1),
}},
QUICHandshake: []*QUICTLSHandshakeEvent{},
TLSHandshake: []*QUICTLSHandshakeEvent{},
},
args: args{
begin: traceTime(0),
},
wantOut: []model.ArchivalTCPConnectResult{{
IP: "8.8.8.8",
Port: 443,
Status: model.ArchivalTCPConnectStatus{
Blocked: nil,
Failure: failureFromString(netxlite.FailureConnectionRefused),
Success: false,
},
T: deltaSinceTraceTime(2),
}},
}}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tr := &Trace{
DNSLookupHTTPS: tt.fields.DNSLookupHTTPS,
DNSLookupHost: tt.fields.DNSLookupHost,
DNSRoundTrip: tt.fields.DNSRoundTrip,
HTTPRoundTrip: tt.fields.HTTPRoundTrip,
Network: tt.fields.Network,
QUICHandshake: tt.fields.QUICHandshake,
TLSHandshake: tt.fields.TLSHandshake,
}
gotOut := tr.NewArchivalTCPConnectResultList(tt.args.begin)
if diff := cmp.Diff(tt.wantOut, gotOut); diff != "" {
t.Fatal(diff)
}
})
}
}
func TestTraceNewArchivalHTTPRequestResultList(t *testing.T) {
type fields struct {
DNSLookupHTTPS []*DNSLookupEvent
DNSLookupHost []*DNSLookupEvent
DNSRoundTrip []*DNSRoundTripEvent
HTTPRoundTrip []*HTTPRoundTripEvent
Network []*NetworkEvent
QUICHandshake []*QUICTLSHandshakeEvent
TLSHandshake []*QUICTLSHandshakeEvent
}
type args struct {
begin time.Time
}
tests := []struct {
name string
fields fields
args args
wantOut []model.ArchivalHTTPRequestResult
}{{
name: "with empty trace",
fields: fields{
DNSLookupHTTPS: []*DNSLookupEvent{},
DNSLookupHost: []*DNSLookupEvent{},
DNSRoundTrip: []*DNSRoundTripEvent{},
HTTPRoundTrip: []*HTTPRoundTripEvent{},
Network: []*NetworkEvent{},
QUICHandshake: []*QUICTLSHandshakeEvent{},
TLSHandshake: []*QUICTLSHandshakeEvent{},
},
args: args{
begin: traceTime(0),
},
wantOut: nil,
}, {
name: "with failure",
fields: fields{
DNSLookupHTTPS: []*DNSLookupEvent{},
DNSLookupHost: []*DNSLookupEvent{},
DNSRoundTrip: []*DNSRoundTripEvent{},
HTTPRoundTrip: []*HTTPRoundTripEvent{{
Failure: netxlite.NewTopLevelGenericErrWrapper(netxlite.ECONNRESET),
Finished: traceTime(2),
Method: "GET",
RequestHeaders: http.Header{
"Accept": {"*/*"},
"X-Cookie": {"A", "B", "C"},
},
ResponseBody: nil,
ResponseBodyIsTruncated: false,
ResponseBodyLength: 0,
ResponseHeaders: nil,
Started: traceTime(1),
StatusCode: 0,
Transport: "tcp",
URL: "http://x.org/",
}},
Network: []*NetworkEvent{},
QUICHandshake: []*QUICTLSHandshakeEvent{},
TLSHandshake: []*QUICTLSHandshakeEvent{},
},
args: args{
begin: traceTime(0),
},
wantOut: []model.ArchivalHTTPRequestResult{{
Failure: failureFromString(netxlite.FailureConnectionReset),
Request: model.ArchivalHTTPRequest{
Body: model.ArchivalMaybeBinaryData{},
BodyIsTruncated: false,
HeadersList: []model.ArchivalHTTPHeader{{
Key: "Accept",
Value: model.ArchivalMaybeBinaryData{
Value: "*/*",
},
}, {
Key: "X-Cookie",
Value: model.ArchivalMaybeBinaryData{
Value: "A",
},
}, {
Key: "X-Cookie",
Value: model.ArchivalMaybeBinaryData{
Value: "B",
},
}, {
Key: "X-Cookie",
Value: model.ArchivalMaybeBinaryData{
Value: "C",
},
}},
Headers: map[string]model.ArchivalMaybeBinaryData{
"Accept": {Value: "*/*"},
"X-Cookie": {Value: "A"},
},
Method: "GET",
Tor: model.ArchivalHTTPTor{},
Transport: "tcp",
URL: "http://x.org/",
},
Response: model.ArchivalHTTPResponse{
Body: model.ArchivalMaybeBinaryData{},
BodyIsTruncated: false,
Code: 0,
HeadersList: nil,
Headers: nil,
Locations: nil,
},
T: deltaSinceTraceTime(2),
}},
}, {
name: "with success",
fields: fields{
DNSLookupHTTPS: []*DNSLookupEvent{},
DNSLookupHost: []*DNSLookupEvent{},
DNSRoundTrip: []*DNSRoundTripEvent{},
HTTPRoundTrip: []*HTTPRoundTripEvent{{
Failure: nil,
Finished: traceTime(2),
Method: "GET",
RequestHeaders: http.Header{
"Accept": {"*/*"},
"X-Cookie": {"A", "B", "C"},
},
ResponseBody: []byte("0xdeadbeef"),
ResponseBodyIsTruncated: true,
ResponseBodyLength: 10,
ResponseHeaders: http.Header{
"Server": {"antani/1.0"},
"X-Cookie-Reply": {"C", "D", "F"},
"Location": {"https://x.org/", "https://x.org/robots.txt"},
},
Started: traceTime(1),
StatusCode: 302,
Transport: "tcp",
URL: "http://x.org/",
}},
Network: []*NetworkEvent{},
QUICHandshake: []*QUICTLSHandshakeEvent{},
TLSHandshake: []*QUICTLSHandshakeEvent{},
},
args: args{
begin: traceTime(0),
},
wantOut: []model.ArchivalHTTPRequestResult{{
Failure: nil,
Request: model.ArchivalHTTPRequest{
Body: model.ArchivalMaybeBinaryData{},
BodyIsTruncated: false,
HeadersList: []model.ArchivalHTTPHeader{{
Key: "Accept",
Value: model.ArchivalMaybeBinaryData{
Value: "*/*",
},
}, {
Key: "X-Cookie",
Value: model.ArchivalMaybeBinaryData{
Value: "A",
},
}, {
Key: "X-Cookie",
Value: model.ArchivalMaybeBinaryData{
Value: "B",
},
}, {
Key: "X-Cookie",
Value: model.ArchivalMaybeBinaryData{
Value: "C",
},
}},
Headers: map[string]model.ArchivalMaybeBinaryData{
"Accept": {Value: "*/*"},
"X-Cookie": {Value: "A"},
},
Method: "GET",
Tor: model.ArchivalHTTPTor{},
Transport: "tcp",
URL: "http://x.org/",
},
Response: model.ArchivalHTTPResponse{
Body: model.ArchivalMaybeBinaryData{
Value: "0xdeadbeef",
},
BodyIsTruncated: true,
Code: 302,
HeadersList: []model.ArchivalHTTPHeader{{
Key: "Location",
Value: model.ArchivalMaybeBinaryData{
Value: "https://x.org/",
},
}, {
Key: "Location",
Value: model.ArchivalMaybeBinaryData{
Value: "https://x.org/robots.txt",
},
}, {
Key: "Server",
Value: model.ArchivalMaybeBinaryData{
Value: "antani/1.0",
},
}, {
Key: "X-Cookie-Reply",
Value: model.ArchivalMaybeBinaryData{
Value: "C",
},
}, {
Key: "X-Cookie-Reply",
Value: model.ArchivalMaybeBinaryData{
Value: "D",
},
}, {
Key: "X-Cookie-Reply",
Value: model.ArchivalMaybeBinaryData{
Value: "F",
},
}},
Headers: map[string]model.ArchivalMaybeBinaryData{
"Server": {Value: "antani/1.0"},
"X-Cookie-Reply": {Value: "C"},
"Location": {Value: "https://x.org/"},
},
Locations: []string{
"https://x.org/",
"https://x.org/robots.txt",
},
},
T: deltaSinceTraceTime(2),
}},
}, {
name: "The result is sorted by the value of T",
fields: fields{
DNSLookupHTTPS: []*DNSLookupEvent{},
DNSLookupHost: []*DNSLookupEvent{},
DNSRoundTrip: []*DNSRoundTripEvent{},
HTTPRoundTrip: []*HTTPRoundTripEvent{{
Failure: nil,
Finished: traceTime(3),
Method: "",
RequestHeaders: map[string][]string{},
ResponseBody: []byte{},
ResponseBodyIsTruncated: false,
ResponseBodyLength: 0,
ResponseHeaders: map[string][]string{},
Started: time.Time{},
StatusCode: 0,
Transport: "",
URL: "",
}, {
Failure: nil,
Finished: traceTime(2),
Method: "",
RequestHeaders: map[string][]string{},
ResponseBody: []byte{},
ResponseBodyIsTruncated: false,
ResponseBodyLength: 0,
ResponseHeaders: map[string][]string{},
Started: time.Time{},
StatusCode: 0,
Transport: "",
URL: "",
}, {
Failure: nil,
Finished: traceTime(5),
Method: "",
RequestHeaders: map[string][]string{},
ResponseBody: []byte{},
ResponseBodyIsTruncated: false,
ResponseBodyLength: 0,
ResponseHeaders: map[string][]string{},
Started: time.Time{},
StatusCode: 0,
Transport: "",
URL: "",
}},
Network: []*NetworkEvent{},
QUICHandshake: []*QUICTLSHandshakeEvent{},
TLSHandshake: []*QUICTLSHandshakeEvent{},
},
args: args{
begin: traceTime(0),
},
wantOut: []model.ArchivalHTTPRequestResult{{
Failure: nil,
Request: model.ArchivalHTTPRequest{},
Response: model.ArchivalHTTPResponse{},
T: deltaSinceTraceTime(5),
}, {
Failure: nil,
Request: model.ArchivalHTTPRequest{},
Response: model.ArchivalHTTPResponse{},
T: deltaSinceTraceTime(3),
}, {
Failure: nil,
Request: model.ArchivalHTTPRequest{},
Response: model.ArchivalHTTPResponse{},
T: deltaSinceTraceTime(2),
}},
}}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tr := &Trace{
DNSLookupHTTPS: tt.fields.DNSLookupHTTPS,
DNSLookupHost: tt.fields.DNSLookupHost,
DNSRoundTrip: tt.fields.DNSRoundTrip,
HTTPRoundTrip: tt.fields.HTTPRoundTrip,
Network: tt.fields.Network,
QUICHandshake: tt.fields.QUICHandshake,
TLSHandshake: tt.fields.TLSHandshake,
}
gotOut := tr.NewArchivalHTTPRequestResultList(tt.args.begin)
if diff := cmp.Diff(tt.wantOut, gotOut); diff != "" {
t.Fatal(diff)
}
})
}
}
func TestTraceNewArchivalDNSLookupResultList(t *testing.T) {
type fields struct {
DNSLookupHTTPS []*DNSLookupEvent
DNSLookupHost []*DNSLookupEvent
DNSRoundTrip []*DNSRoundTripEvent
HTTPRoundTrip []*HTTPRoundTripEvent
Network []*NetworkEvent
QUICHandshake []*QUICTLSHandshakeEvent
TLSHandshake []*QUICTLSHandshakeEvent
}
type args struct {
begin time.Time
}
tests := []struct {
name string
fields fields
args args
wantOut []model.ArchivalDNSLookupResult
}{{
name: "with empty trace",
fields: fields{
DNSLookupHTTPS: []*DNSLookupEvent{},
DNSLookupHost: []*DNSLookupEvent{},
DNSRoundTrip: []*DNSRoundTripEvent{},
HTTPRoundTrip: []*HTTPRoundTripEvent{},
Network: []*NetworkEvent{},
QUICHandshake: []*QUICTLSHandshakeEvent{},
TLSHandshake: []*QUICTLSHandshakeEvent{},
},
args: args{
begin: traceTime(0),
},
wantOut: nil,
}, {
name: "with NXDOMAIN failure",
fields: fields{
DNSLookupHTTPS: []*DNSLookupEvent{},
DNSLookupHost: []*DNSLookupEvent{{
ALPNs: nil,
Addresses: nil,
Domain: "example.com",
Failure: netxlite.NewTopLevelGenericErrWrapper(errors.New(netxlite.DNSNoSuchHostSuffix)),
Finished: traceTime(2),
LookupType: "", // not processed
ResolverAddress: "8.8.8.8:53",
ResolverNetwork: "udp",
Started: traceTime(1),
}},
DNSRoundTrip: []*DNSRoundTripEvent{},
HTTPRoundTrip: []*HTTPRoundTripEvent{},
Network: []*NetworkEvent{},
QUICHandshake: []*QUICTLSHandshakeEvent{},
TLSHandshake: []*QUICTLSHandshakeEvent{},
},
args: args{
begin: traceTime(0),
},
wantOut: []model.ArchivalDNSLookupResult{{
Answers: nil,
Engine: "udp",
Failure: failureFromString(netxlite.FailureDNSNXDOMAINError),
Hostname: "example.com",
QueryType: "A",
ResolverHostname: nil,
ResolverPort: nil,
ResolverAddress: "8.8.8.8:53",
T: deltaSinceTraceTime(2),
}, {
Answers: nil,
Engine: "udp",
Failure: failureFromString(netxlite.FailureDNSNXDOMAINError),
Hostname: "example.com",
QueryType: "AAAA",
ResolverHostname: nil,
ResolverPort: nil,
ResolverAddress: "8.8.8.8:53",
T: deltaSinceTraceTime(2),
}},
}, {
name: "with success for A and AAAA",
fields: fields{
DNSLookupHTTPS: []*DNSLookupEvent{},
DNSLookupHost: []*DNSLookupEvent{{
ALPNs: nil,
Addresses: []string{
"8.8.8.8", "8.8.4.4", "2001:4860:4860::8844",
},
Domain: "dns.google",
Failure: nil,
Finished: traceTime(2),
LookupType: "", // not processed
ResolverAddress: "8.8.8.8:53",
ResolverNetwork: "udp",
Started: traceTime(1),
}},
DNSRoundTrip: []*DNSRoundTripEvent{},
HTTPRoundTrip: []*HTTPRoundTripEvent{},
Network: []*NetworkEvent{},
QUICHandshake: []*QUICTLSHandshakeEvent{},
TLSHandshake: []*QUICTLSHandshakeEvent{},
},
args: args{
begin: traceTime(0),
},
wantOut: []model.ArchivalDNSLookupResult{{
Answers: []model.ArchivalDNSAnswer{{
ASN: 15169,
ASOrgName: "Google LLC",
AnswerType: "A",
Hostname: "",
IPv4: "8.8.8.8",
IPv6: "",
TTL: nil,
}, {
ASN: 15169,
ASOrgName: "Google LLC",
AnswerType: "A",
Hostname: "",
IPv4: "8.8.4.4",
IPv6: "",
TTL: nil,
}},
Engine: "udp",
Failure: nil,
Hostname: "dns.google",
QueryType: "A",
ResolverHostname: nil,
ResolverPort: nil,
ResolverAddress: "8.8.8.8:53",
T: deltaSinceTraceTime(2),
}, {
Answers: []model.ArchivalDNSAnswer{{
ASN: 15169,
ASOrgName: "Google LLC",
AnswerType: "AAAA",
Hostname: "",
IPv4: "",
IPv6: "2001:4860:4860::8844",
TTL: nil,
}},
Engine: "udp",
Failure: nil,
Hostname: "dns.google",
QueryType: "AAAA",
ResolverHostname: nil,
ResolverPort: nil,
ResolverAddress: "8.8.8.8:53",
T: deltaSinceTraceTime(2),
}},
}, {
name: "when a domain has no AAAA addresses",
fields: fields{
DNSLookupHTTPS: []*DNSLookupEvent{},
DNSLookupHost: []*DNSLookupEvent{{
ALPNs: nil,
Addresses: []string{
"8.8.8.8", "8.8.4.4",
},
Domain: "dns.google",
Failure: nil,
Finished: traceTime(2),
LookupType: "", // not processed
ResolverAddress: "8.8.8.8:53",
ResolverNetwork: "udp",
Started: traceTime(1),
}},
DNSRoundTrip: []*DNSRoundTripEvent{},
HTTPRoundTrip: []*HTTPRoundTripEvent{},
Network: []*NetworkEvent{},
QUICHandshake: []*QUICTLSHandshakeEvent{},
TLSHandshake: []*QUICTLSHandshakeEvent{},
},
args: args{
begin: traceTime(0),
},
wantOut: []model.ArchivalDNSLookupResult{{
Answers: []model.ArchivalDNSAnswer{{
ASN: 15169,
ASOrgName: "Google LLC",
AnswerType: "A",
Hostname: "",
IPv4: "8.8.8.8",
IPv6: "",
TTL: nil,
}, {
ASN: 15169,
ASOrgName: "Google LLC",
AnswerType: "A",
Hostname: "",
IPv4: "8.8.4.4",
IPv6: "",
TTL: nil,
}},
Engine: "udp",
Failure: nil,
Hostname: "dns.google",
QueryType: "A",
ResolverHostname: nil,
ResolverPort: nil,
ResolverAddress: "8.8.8.8:53",
T: deltaSinceTraceTime(2),
}},
}}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tr := &Trace{
DNSLookupHTTPS: tt.fields.DNSLookupHTTPS,
DNSLookupHost: tt.fields.DNSLookupHost,
DNSRoundTrip: tt.fields.DNSRoundTrip,
HTTPRoundTrip: tt.fields.HTTPRoundTrip,
Network: tt.fields.Network,
QUICHandshake: tt.fields.QUICHandshake,
TLSHandshake: tt.fields.TLSHandshake,
}
gotOut := tr.NewArchivalDNSLookupResultList(tt.args.begin)
if diff := cmp.Diff(tt.wantOut, gotOut); diff != "" {
t.Fatal(diff)
}
})
}
}
func TestTraceNewArchivalNetworkEventList(t *testing.T) {
type fields struct {
DNSLookupHTTPS []*DNSLookupEvent
DNSLookupHost []*DNSLookupEvent
DNSRoundTrip []*DNSRoundTripEvent
HTTPRoundTrip []*HTTPRoundTripEvent
Network []*NetworkEvent
QUICHandshake []*QUICTLSHandshakeEvent
TLSHandshake []*QUICTLSHandshakeEvent
}
type args struct {
begin time.Time
}
tests := []struct {
name string
fields fields
args args
wantOut []model.ArchivalNetworkEvent
}{{
name: "with empty trace",
fields: fields{
DNSLookupHTTPS: []*DNSLookupEvent{},
DNSLookupHost: []*DNSLookupEvent{},
DNSRoundTrip: []*DNSRoundTripEvent{},
HTTPRoundTrip: []*HTTPRoundTripEvent{},
Network: []*NetworkEvent{},
QUICHandshake: []*QUICTLSHandshakeEvent{},
TLSHandshake: []*QUICTLSHandshakeEvent{},
},
args: args{
begin: traceTime(0),
},
wantOut: nil,
}, {
name: "we fill all the fields we should be filling",
fields: fields{
DNSLookupHTTPS: []*DNSLookupEvent{},
DNSLookupHost: []*DNSLookupEvent{},
DNSRoundTrip: []*DNSRoundTripEvent{},
HTTPRoundTrip: []*HTTPRoundTripEvent{},
Network: []*NetworkEvent{{
Count: 1234,
Failure: netxlite.NewTopLevelGenericErrWrapper(io.EOF),
Finished: traceTime(2),
Network: "tcp",
Operation: netxlite.ReadOperation,
RemoteAddr: "8.8.8.8:443",
Started: traceTime(1),
}},
QUICHandshake: []*QUICTLSHandshakeEvent{},
TLSHandshake: []*QUICTLSHandshakeEvent{},
},
args: args{
begin: traceTime(0),
},
wantOut: []model.ArchivalNetworkEvent{{
Address: "8.8.8.8:443",
Failure: failureFromString(netxlite.FailureEOFError),
NumBytes: 1234,
Operation: netxlite.ReadOperation,
Proto: "tcp",
T: deltaSinceTraceTime(2),
Tags: nil,
}},
}}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tr := &Trace{
DNSLookupHTTPS: tt.fields.DNSLookupHTTPS,
DNSLookupHost: tt.fields.DNSLookupHost,
DNSRoundTrip: tt.fields.DNSRoundTrip,
HTTPRoundTrip: tt.fields.HTTPRoundTrip,
Network: tt.fields.Network,
QUICHandshake: tt.fields.QUICHandshake,
TLSHandshake: tt.fields.TLSHandshake,
}
gotOut := tr.NewArchivalNetworkEventList(tt.args.begin)
if diff := cmp.Diff(tt.wantOut, gotOut); diff != "" {
t.Fatal(diff)
}
})
}
}
func TestTraceNewArchivalTLSHandshakeResultList(t *testing.T) {
type fields struct {
DNSLookupHTTPS []*DNSLookupEvent
DNSLookupHost []*DNSLookupEvent
DNSRoundTrip []*DNSRoundTripEvent
HTTPRoundTrip []*HTTPRoundTripEvent
Network []*NetworkEvent
QUICHandshake []*QUICTLSHandshakeEvent
TLSHandshake []*QUICTLSHandshakeEvent
}
type args struct {
begin time.Time
}
tests := []struct {
name string
fields fields
args args
wantOut []model.ArchivalTLSOrQUICHandshakeResult
}{{
name: "with empty trace",
fields: fields{
DNSLookupHTTPS: []*DNSLookupEvent{},
DNSLookupHost: []*DNSLookupEvent{},
DNSRoundTrip: []*DNSRoundTripEvent{},
HTTPRoundTrip: []*HTTPRoundTripEvent{},
Network: []*NetworkEvent{},
QUICHandshake: []*QUICTLSHandshakeEvent{},
TLSHandshake: []*QUICTLSHandshakeEvent{},
},
args: args{
begin: traceTime(0),
},
wantOut: nil,
}, {
name: "we fill all the fields we should be filling",
fields: fields{
DNSLookupHTTPS: []*DNSLookupEvent{},
DNSLookupHost: []*DNSLookupEvent{},
DNSRoundTrip: []*DNSRoundTripEvent{},
HTTPRoundTrip: []*HTTPRoundTripEvent{},
Network: []*NetworkEvent{},
QUICHandshake: []*QUICTLSHandshakeEvent{},
TLSHandshake: []*QUICTLSHandshakeEvent{{
ALPN: []string{"h2", "http/1.1"},
CipherSuite: "TLS_AES_128_GCM_SHA256",
Failure: netxlite.NewTopLevelGenericErrWrapper(io.EOF),
Finished: traceTime(2),
NegotiatedProto: "h2",
Network: "tcp",
PeerCerts: [][]byte{
[]byte("deadbeef"),
[]byte("xox"),
},
RemoteAddr: "8.8.8.8:443",
SNI: "dns.google",
SkipVerify: true,
Started: traceTime(1),
TLSVersion: "TLSv1.3",
}},
},
args: args{
begin: traceTime(0),
},
wantOut: []model.ArchivalTLSOrQUICHandshakeResult{{
CipherSuite: "TLS_AES_128_GCM_SHA256",
Failure: failureFromString(netxlite.FailureEOFError),
NegotiatedProtocol: "h2",
NoTLSVerify: true,
PeerCertificates: []model.ArchivalMaybeBinaryData{{
Value: "deadbeef",
}, {
Value: "xox",
}},
ServerName: "dns.google",
T: deltaSinceTraceTime(2),
Tags: nil,
TLSVersion: "TLSv1.3",
}},
}}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tr := &Trace{
DNSLookupHTTPS: tt.fields.DNSLookupHTTPS,
DNSLookupHost: tt.fields.DNSLookupHost,
DNSRoundTrip: tt.fields.DNSRoundTrip,
HTTPRoundTrip: tt.fields.HTTPRoundTrip,
Network: tt.fields.Network,
QUICHandshake: tt.fields.QUICHandshake,
TLSHandshake: tt.fields.TLSHandshake,
}
gotOut := tr.NewArchivalTLSHandshakeResultList(tt.args.begin)
if diff := cmp.Diff(tt.wantOut, gotOut); diff != "" {
t.Fatal(diff)
}
})
}
}
Reference in New Issue Copy Permalink