87e5234586
This change allows us to have all fasts tests together. They are mostly unit tests or integration tests that do not require the network. The advantage of this strategy is the following. We can now run all these tests with a single click in VSCode. In turn, doing that tells us which lines of code we are not covering. The tests requiring the network are in a separate file, so we can easily see which lines of code are testing without using the network and which ones instead depend on that. (Currently, 100% of the inputloader.go file is tested without using the network.) While there, rename the other file such that is clear that it contains tests requiring the network. We now have some tests in inputloader_test.go that are not strictly unit tests. This refactoring was identified as useful while working on https://github.com/ooni/probe/issues/1299.
419 lines
10 KiB
Go
419 lines
10 KiB
Go
package engine
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"os"
|
|
"syscall"
|
|
"testing"
|
|
|
|
"github.com/apex/log"
|
|
"github.com/google/go-cmp/cmp"
|
|
"github.com/ooni/probe-cli/v3/internal/engine/internal/fsx"
|
|
"github.com/ooni/probe-cli/v3/internal/engine/kvstore"
|
|
"github.com/ooni/probe-cli/v3/internal/engine/model"
|
|
)
|
|
|
|
func TestInputLoaderInputNoneWithStaticInputs(t *testing.T) {
|
|
il := NewInputLoader(InputLoaderConfig{
|
|
StaticInputs: []string{"https://www.google.com/"},
|
|
InputPolicy: InputNone,
|
|
})
|
|
ctx := context.Background()
|
|
out, err := il.Load(ctx)
|
|
if !errors.Is(err, ErrNoInputExpected) {
|
|
t.Fatalf("not the error we expected: %+v", err)
|
|
}
|
|
if out != nil {
|
|
t.Fatal("not the output we expected")
|
|
}
|
|
}
|
|
|
|
func TestInputLoaderInputNoneWithFilesInputs(t *testing.T) {
|
|
il := NewInputLoader(InputLoaderConfig{
|
|
SourceFiles: []string{
|
|
"testdata/inputloader1.txt",
|
|
"testdata/inputloader2.txt",
|
|
},
|
|
InputPolicy: InputNone,
|
|
})
|
|
ctx := context.Background()
|
|
out, err := il.Load(ctx)
|
|
if !errors.Is(err, ErrNoInputExpected) {
|
|
t.Fatalf("not the error we expected: %+v", err)
|
|
}
|
|
if out != nil {
|
|
t.Fatal("not the output we expected")
|
|
}
|
|
}
|
|
|
|
func TestInputLoaderInputNoneWithBothInputs(t *testing.T) {
|
|
il := NewInputLoader(InputLoaderConfig{
|
|
StaticInputs: []string{"https://www.google.com/"},
|
|
SourceFiles: []string{
|
|
"testdata/inputloader1.txt",
|
|
"testdata/inputloader2.txt",
|
|
},
|
|
InputPolicy: InputNone,
|
|
})
|
|
ctx := context.Background()
|
|
out, err := il.Load(ctx)
|
|
if !errors.Is(err, ErrNoInputExpected) {
|
|
t.Fatalf("not the error we expected: %+v", err)
|
|
}
|
|
if out != nil {
|
|
t.Fatal("not the output we expected")
|
|
}
|
|
}
|
|
|
|
func TestInputLoaderInputNoneWithNoInput(t *testing.T) {
|
|
il := NewInputLoader(InputLoaderConfig{
|
|
InputPolicy: InputNone,
|
|
})
|
|
ctx := context.Background()
|
|
out, err := il.Load(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(out) != 1 || out[0].URL != "" {
|
|
t.Fatal("not the output we expected")
|
|
}
|
|
}
|
|
|
|
func TestInputLoaderInputOptionalWithNoInput(t *testing.T) {
|
|
il := NewInputLoader(InputLoaderConfig{
|
|
InputPolicy: InputOptional,
|
|
})
|
|
ctx := context.Background()
|
|
out, err := il.Load(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(out) != 1 || out[0].URL != "" {
|
|
t.Fatal("not the output we expected")
|
|
}
|
|
}
|
|
|
|
func TestInputLoaderInputOptionalWithInput(t *testing.T) {
|
|
il := NewInputLoader(InputLoaderConfig{
|
|
StaticInputs: []string{"https://www.google.com/"},
|
|
SourceFiles: []string{
|
|
"testdata/inputloader1.txt",
|
|
"testdata/inputloader2.txt",
|
|
},
|
|
InputPolicy: InputOptional,
|
|
})
|
|
ctx := context.Background()
|
|
out, err := il.Load(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(out) != 5 {
|
|
t.Fatal("not the output length we expected")
|
|
}
|
|
expect := []model.URLInfo{
|
|
{URL: "https://www.google.com/"},
|
|
{URL: "https://www.x.org/"},
|
|
{URL: "https://www.slashdot.org/"},
|
|
{URL: "https://abc.xyz/"},
|
|
{URL: "https://run.ooni.io/"},
|
|
}
|
|
if diff := cmp.Diff(out, expect); diff != "" {
|
|
t.Fatal(diff)
|
|
}
|
|
}
|
|
|
|
func TestInputLoaderInputOptionalNonexistentFile(t *testing.T) {
|
|
il := NewInputLoader(InputLoaderConfig{
|
|
StaticInputs: []string{"https://www.google.com/"},
|
|
SourceFiles: []string{
|
|
"testdata/inputloader1.txt",
|
|
"/nonexistent",
|
|
"testdata/inputloader2.txt",
|
|
},
|
|
InputPolicy: InputOptional,
|
|
})
|
|
ctx := context.Background()
|
|
out, err := il.Load(ctx)
|
|
if !errors.Is(err, syscall.ENOENT) {
|
|
t.Fatalf("not the error we expected: %+v", err)
|
|
}
|
|
if out != nil {
|
|
t.Fatal("not the output we expected")
|
|
}
|
|
}
|
|
|
|
func TestInputLoaderInputStrictlyRequiredWithInput(t *testing.T) {
|
|
il := NewInputLoader(InputLoaderConfig{
|
|
StaticInputs: []string{"https://www.google.com/"},
|
|
SourceFiles: []string{
|
|
"testdata/inputloader1.txt",
|
|
"testdata/inputloader2.txt",
|
|
},
|
|
InputPolicy: InputStrictlyRequired,
|
|
})
|
|
ctx := context.Background()
|
|
out, err := il.Load(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(out) != 5 {
|
|
t.Fatal("not the output length we expected")
|
|
}
|
|
expect := []model.URLInfo{
|
|
{URL: "https://www.google.com/"},
|
|
{URL: "https://www.x.org/"},
|
|
{URL: "https://www.slashdot.org/"},
|
|
{URL: "https://abc.xyz/"},
|
|
{URL: "https://run.ooni.io/"},
|
|
}
|
|
if diff := cmp.Diff(out, expect); diff != "" {
|
|
t.Fatal(diff)
|
|
}
|
|
}
|
|
|
|
func TestInputLoaderInputStrictlyRequiredWithoutInput(t *testing.T) {
|
|
il := NewInputLoader(InputLoaderConfig{
|
|
InputPolicy: InputStrictlyRequired,
|
|
})
|
|
ctx := context.Background()
|
|
out, err := il.Load(ctx)
|
|
if !errors.Is(err, ErrInputRequired) {
|
|
t.Fatalf("not the error we expected: %+v", err)
|
|
}
|
|
if out != nil {
|
|
t.Fatal("not the output we expected")
|
|
}
|
|
}
|
|
|
|
func TestInputLoaderInputStrictlyRequiredWithEmptyFile(t *testing.T) {
|
|
il := NewInputLoader(InputLoaderConfig{
|
|
InputPolicy: InputStrictlyRequired,
|
|
SourceFiles: []string{
|
|
"testdata/inputloader1.txt",
|
|
"testdata/inputloader3.txt", // we want it before inputloader2.txt
|
|
"testdata/inputloader2.txt",
|
|
},
|
|
})
|
|
ctx := context.Background()
|
|
out, err := il.Load(ctx)
|
|
if !errors.Is(err, ErrDetectedEmptyFile) {
|
|
t.Fatalf("not the error we expected: %+v", err)
|
|
}
|
|
if out != nil {
|
|
t.Fatal("not the output we expected")
|
|
}
|
|
}
|
|
|
|
func TestInputLoaderInputOrQueryBackendWithInput(t *testing.T) {
|
|
il := NewInputLoader(InputLoaderConfig{
|
|
StaticInputs: []string{"https://www.google.com/"},
|
|
SourceFiles: []string{
|
|
"testdata/inputloader1.txt",
|
|
"testdata/inputloader2.txt",
|
|
},
|
|
InputPolicy: InputOrQueryBackend,
|
|
})
|
|
ctx := context.Background()
|
|
out, err := il.Load(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(out) != 5 {
|
|
t.Fatal("not the output length we expected")
|
|
}
|
|
expect := []model.URLInfo{
|
|
{URL: "https://www.google.com/"},
|
|
{URL: "https://www.x.org/"},
|
|
{URL: "https://www.slashdot.org/"},
|
|
{URL: "https://abc.xyz/"},
|
|
{URL: "https://run.ooni.io/"},
|
|
}
|
|
if diff := cmp.Diff(out, expect); diff != "" {
|
|
t.Fatal(diff)
|
|
}
|
|
}
|
|
|
|
func TestInputLoaderInputOrQueryBackendWithNoInputAndCancelledContext(t *testing.T) {
|
|
sess, err := NewSession(SessionConfig{
|
|
AssetsDir: "testdata",
|
|
KVStore: kvstore.NewMemoryKeyValueStore(),
|
|
Logger: log.Log,
|
|
SoftwareName: "miniooni",
|
|
SoftwareVersion: "0.1.0-dev",
|
|
TempDir: "testdata",
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer sess.Close()
|
|
il := NewInputLoader(InputLoaderConfig{
|
|
InputPolicy: InputOrQueryBackend,
|
|
Session: sess,
|
|
})
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel() // fail immediately
|
|
out, err := il.Load(ctx)
|
|
if !errors.Is(err, context.Canceled) {
|
|
t.Fatalf("not the error we expected: %+v", err)
|
|
}
|
|
if out != nil {
|
|
t.Fatal("not the output we expected")
|
|
}
|
|
}
|
|
|
|
func TestInputLoaderInputOrQueryBackendWithEmptyFile(t *testing.T) {
|
|
il := NewInputLoader(InputLoaderConfig{
|
|
InputPolicy: InputOrQueryBackend,
|
|
SourceFiles: []string{
|
|
"testdata/inputloader1.txt",
|
|
"testdata/inputloader3.txt", // we want it before inputloader2.txt
|
|
"testdata/inputloader2.txt",
|
|
},
|
|
})
|
|
ctx := context.Background()
|
|
out, err := il.Load(ctx)
|
|
if !errors.Is(err, ErrDetectedEmptyFile) {
|
|
t.Fatalf("not the error we expected: %+v", err)
|
|
}
|
|
if out != nil {
|
|
t.Fatal("not the output we expected")
|
|
}
|
|
}
|
|
|
|
type InputLoaderBrokenFS struct{}
|
|
|
|
func (InputLoaderBrokenFS) Open(filepath string) (fsx.File, error) {
|
|
return InputLoaderBrokenFile{}, nil
|
|
}
|
|
|
|
type InputLoaderBrokenFile struct{}
|
|
|
|
func (InputLoaderBrokenFile) Stat() (os.FileInfo, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (InputLoaderBrokenFile) Read([]byte) (int, error) {
|
|
return 0, syscall.EFAULT
|
|
}
|
|
|
|
func (InputLoaderBrokenFile) Close() error {
|
|
return nil
|
|
}
|
|
|
|
func TestInputLoaderReadfileScannerFailure(t *testing.T) {
|
|
il := inputLoader{}
|
|
out, err := il.readfile("", InputLoaderBrokenFS{}.Open)
|
|
if !errors.Is(err, syscall.EFAULT) {
|
|
t.Fatal("not the error we expected")
|
|
}
|
|
if out != nil {
|
|
t.Fatal("not the output we expected")
|
|
}
|
|
}
|
|
|
|
// InputLoaderMockableSession is a mockable session
|
|
// used by InputLoader tests.
|
|
type InputLoaderMockableSession struct {
|
|
// Output contains the output of CheckIn. It should
|
|
// be nil when Error is not-nil.
|
|
Output *model.CheckInInfo
|
|
|
|
// Error is the error to be returned by CheckIn. It
|
|
// should be nil when Output is not-nil.
|
|
Error error
|
|
}
|
|
|
|
// CheckIn implements InputLoaderSession.CheckIn.
|
|
func (sess *InputLoaderMockableSession) CheckIn(
|
|
ctx context.Context, config *model.CheckInConfig) (*model.CheckInInfo, error) {
|
|
if sess.Output == nil && sess.Error == nil {
|
|
return nil, errors.New("both Output and Error are nil")
|
|
}
|
|
return sess.Output, sess.Error
|
|
}
|
|
|
|
func TestInputLoaderCheckInFailure(t *testing.T) {
|
|
il := inputLoader{}
|
|
lrc := inputLoaderLoadRemoteConfig{
|
|
ctx: context.Background(),
|
|
session: &InputLoaderMockableSession{
|
|
Error: io.EOF,
|
|
},
|
|
}
|
|
out, err := il.loadRemote(lrc)
|
|
if !errors.Is(err, io.EOF) {
|
|
t.Fatalf("not the error we expected: %+v", err)
|
|
}
|
|
if out != nil {
|
|
t.Fatal("expected nil output here")
|
|
}
|
|
}
|
|
|
|
func TestInputLoaderCheckInSuccessWithNilWebConnectivity(t *testing.T) {
|
|
il := inputLoader{}
|
|
lrc := inputLoaderLoadRemoteConfig{
|
|
ctx: context.Background(),
|
|
session: &InputLoaderMockableSession{
|
|
Output: &model.CheckInInfo{},
|
|
},
|
|
}
|
|
out, err := il.loadRemote(lrc)
|
|
if !errors.Is(err, ErrNoURLsReturned) {
|
|
t.Fatalf("not the error we expected: %+v", err)
|
|
}
|
|
if out != nil {
|
|
t.Fatal("expected nil output here")
|
|
}
|
|
}
|
|
|
|
func TestInputLoaderCheckInSuccessWithNoURLs(t *testing.T) {
|
|
il := inputLoader{}
|
|
lrc := inputLoaderLoadRemoteConfig{
|
|
ctx: context.Background(),
|
|
session: &InputLoaderMockableSession{
|
|
Output: &model.CheckInInfo{
|
|
WebConnectivity: &model.CheckInInfoWebConnectivity{},
|
|
},
|
|
},
|
|
}
|
|
out, err := il.loadRemote(lrc)
|
|
if !errors.Is(err, ErrNoURLsReturned) {
|
|
t.Fatalf("not the error we expected: %+v", err)
|
|
}
|
|
if out != nil {
|
|
t.Fatal("expected nil output here")
|
|
}
|
|
}
|
|
|
|
func TestInputLoaderCheckInSuccessWithSomeURLs(t *testing.T) {
|
|
expect := []model.URLInfo{{
|
|
CategoryCode: "NEWS",
|
|
CountryCode: "IT",
|
|
URL: "https://repubblica.it",
|
|
}, {
|
|
CategoryCode: "NEWS",
|
|
CountryCode: "IT",
|
|
URL: "https://corriere.it",
|
|
}}
|
|
il := inputLoader{}
|
|
lrc := inputLoaderLoadRemoteConfig{
|
|
ctx: context.Background(),
|
|
session: &InputLoaderMockableSession{
|
|
Output: &model.CheckInInfo{
|
|
WebConnectivity: &model.CheckInInfoWebConnectivity{
|
|
URLs: expect,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
out, err := il.loadRemote(lrc)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if diff := cmp.Diff(expect, out); diff != "" {
|
|
t.Fatal(diff)
|
|
}
|
|
}
|