ooni-probe-cli/internal/ooapi/caching_test.go
Simone Basso 2e0118d1a6
refactor(netxlite): hide details without breaking the rest of the tree (#454)
## Description

This PR continues the refactoring of `netx` under the following principles:

1. do not break the rest of the tree and do not engage in extensive tree-wide refactoring yet
2. move under `netxlite` clearly related subpackages (e.g., `iox`, `netxmocks`)
3. move into `internal/netxlite/internal` stuff that is clearly private of `netxlite`
4. hide implementation details in `netxlite` pending new factories
5. refactor `tls` code in `netxlite` to clearly separate `crypto/tls` code from `utls` code

After each commit, I run `go test -short -race ./...` locally. Each individual commit explains what it does. I will squash, but this operation will preserve the original commit titles, so this will give further insight on each step.

## Commits

* refactor: rename netxmocks -> netxlite/mocks

Part of https://github.com/ooni/probe/issues/1591

* refactor: rename quicx -> netxlite/quicx

See https://github.com/ooni/probe/issues/1591

* refactor: rename iox -> netxlite/iox

Regenerate sources and make sure the tests pass.

See https://github.com/ooni/probe/issues/1591.

* refactor(iox): move MockableReader to netxlite/mocks

See https://github.com/ooni/probe/issues/1591

* refactor(netxlite): generator is an implementation detail

See https://github.com/ooni/probe/issues/1591

* refactor(netxlite): separate tls and utls code

See https://github.com/ooni/probe/issues/1591

* refactor(netxlite): hide most types but keep old names as legacy

With this change we avoid breaking the rest of the tree, but we start
hiding some implementation details a bit. Factories will follow.

See https://github.com/ooni/probe/issues/1591
2021-09-05 14:49:38 +02:00

224 lines
5.1 KiB
Go

// Code generated by go generate; DO NOT EDIT.
// 2021-09-05 13:54:19.945161 +0200 CEST m=+0.000190709
package ooapi
//go:generate go run ./internal/generator -file caching_test.go
import (
"context"
"errors"
"testing"
"github.com/google/go-cmp/cmp"
"github.com/ooni/probe-cli/v3/internal/kvstore"
"github.com/ooni/probe-cli/v3/internal/ooapi/apimodel"
)
func TestCachesimpleMeasurementMetaAPISuccess(t *testing.T) {
ff := &fakeFill{}
var expect *apimodel.MeasurementMetaResponse
ff.fill(&expect)
cache := &withCacheMeasurementMetaAPI{
API: &FakeMeasurementMetaAPI{
Response: expect,
},
KVStore: &kvstore.Memory{},
}
var req *apimodel.MeasurementMetaRequest
ff.fill(&req)
ctx := context.Background()
resp, err := cache.Call(ctx, req)
if err != nil {
t.Fatal(err)
}
if resp == nil {
t.Fatal("expected non-nil response")
}
if diff := cmp.Diff(expect, resp); diff != "" {
t.Fatal(diff)
}
}
func TestCachesimpleMeasurementMetaAPIWriteCacheError(t *testing.T) {
errMocked := errors.New("mocked error")
ff := &fakeFill{}
var expect *apimodel.MeasurementMetaResponse
ff.fill(&expect)
cache := &withCacheMeasurementMetaAPI{
API: &FakeMeasurementMetaAPI{
Response: expect,
},
KVStore: &FakeKVStore{SetError: errMocked},
}
var req *apimodel.MeasurementMetaRequest
ff.fill(&req)
ctx := context.Background()
resp, err := cache.Call(ctx, req)
if !errors.Is(err, errMocked) {
t.Fatal("not the error we expected", err)
}
if resp != nil {
t.Fatal("expected nil response")
}
}
func TestCachesimpleMeasurementMetaAPIFailureWithNoCache(t *testing.T) {
errMocked := errors.New("mocked error")
ff := &fakeFill{}
cache := &withCacheMeasurementMetaAPI{
API: &FakeMeasurementMetaAPI{
Err: errMocked,
},
KVStore: &kvstore.Memory{},
}
var req *apimodel.MeasurementMetaRequest
ff.fill(&req)
ctx := context.Background()
resp, err := cache.Call(ctx, req)
if !errors.Is(err, errMocked) {
t.Fatal("not the error we expected", err)
}
if resp != nil {
t.Fatal("expected nil response")
}
}
func TestCachesimpleMeasurementMetaAPIFailureWithPreviousCache(t *testing.T) {
ff := &fakeFill{}
var expect *apimodel.MeasurementMetaResponse
ff.fill(&expect)
fakeapi := &FakeMeasurementMetaAPI{
Response: expect,
}
cache := &withCacheMeasurementMetaAPI{
API: fakeapi,
KVStore: &kvstore.Memory{},
}
var req *apimodel.MeasurementMetaRequest
ff.fill(&req)
ctx := context.Background()
// first pass with no error at all
// use a separate scope to be sure we avoid mistakes
{
resp, err := cache.Call(ctx, req)
if err != nil {
t.Fatal(err)
}
if resp == nil {
t.Fatal("expected non-nil response")
}
if diff := cmp.Diff(expect, resp); diff != "" {
t.Fatal(diff)
}
}
// second pass with failure
errMocked := errors.New("mocked error")
fakeapi.Err = errMocked
fakeapi.Response = nil
resp2, err := cache.Call(ctx, req)
if err != nil {
t.Fatal(err)
}
if resp2 == nil {
t.Fatal("expected non-nil response")
}
if diff := cmp.Diff(expect, resp2); diff != "" {
t.Fatal(diff)
}
}
func TestCachesimpleMeasurementMetaAPISetcacheWithEncodeError(t *testing.T) {
ff := &fakeFill{}
errMocked := errors.New("mocked error")
var in []cacheEntryForMeasurementMetaAPI
ff.fill(&in)
cache := &withCacheMeasurementMetaAPI{
GobCodec: &FakeCodec{EncodeErr: errMocked},
}
err := cache.setcache(in)
if !errors.Is(err, errMocked) {
t.Fatal("not the error we expected", err)
}
}
func TestCachesimpleMeasurementMetaAPIReadCacheNotFound(t *testing.T) {
ff := &fakeFill{}
var incache []cacheEntryForMeasurementMetaAPI
ff.fill(&incache)
cache := &withCacheMeasurementMetaAPI{
KVStore: &kvstore.Memory{},
}
err := cache.setcache(incache)
if err != nil {
t.Fatal(err)
}
var req *apimodel.MeasurementMetaRequest
ff.fill(&req)
out, err := cache.readcache(req)
if !errors.Is(err, errCacheNotFound) {
t.Fatal("not the error we expected", err)
}
if out != nil {
t.Fatal("expected nil here")
}
}
func TestCachesimpleMeasurementMetaAPIWriteCacheDuplicate(t *testing.T) {
ff := &fakeFill{}
var req *apimodel.MeasurementMetaRequest
ff.fill(&req)
var resp1 *apimodel.MeasurementMetaResponse
ff.fill(&resp1)
var resp2 *apimodel.MeasurementMetaResponse
ff.fill(&resp2)
cache := &withCacheMeasurementMetaAPI{
KVStore: &kvstore.Memory{},
}
err := cache.writecache(req, resp1)
if err != nil {
t.Fatal(err)
}
err = cache.writecache(req, resp2)
if err != nil {
t.Fatal(err)
}
out, err := cache.readcache(req)
if err != nil {
t.Fatal(err)
}
if out == nil {
t.Fatal("expected non-nil here")
}
if diff := cmp.Diff(resp2, out); diff != "" {
t.Fatal(diff)
}
}
func TestCachesimpleMeasurementMetaAPICacheSizeLimited(t *testing.T) {
ff := &fakeFill{}
cache := &withCacheMeasurementMetaAPI{
KVStore: &kvstore.Memory{},
}
var prev int
for {
var req *apimodel.MeasurementMetaRequest
ff.fill(&req)
var resp *apimodel.MeasurementMetaResponse
ff.fill(&resp)
err := cache.writecache(req, resp)
if err != nil {
t.Fatal(err)
}
out, err := cache.getcache()
if err != nil {
t.Fatal(err)
}
if len(out) > prev {
prev = len(out)
continue
}
break
}
}