Add fakes (#37)

* Create fakes to allow others to create and start a real server to use for testing their own clients.
* 100% coverage
* added issue  about packages

Author: pboothe

asnannotator/asn.go

@@ -169,3 +169,45 @@ func loadNames(ctx context.Context, src content.Provider, oldvalue ipinfo.ASName
 	}
 	return ipinfo.Parse(data)
 }
+
+// fakeASNAnnotator is just a real asnAnnotator that has a fixed dataset and
+// can't be reloaded.
+type fakeASNAnnotator struct {
+	asnAnnotator
+}
+
+func (*fakeASNAnnotator) Reload(ctx context.Context) {}
+
+// NewFake returns an annotator that know about just one v4 IP (1.2.3.4) and one
+// v6 IP (1111:2222:3333:4444:5555:6666:7777:8888). This is useful for testing
+// other components when you don't want to carry around canonical datafiles, or
+// for building up a local IP annotation service with known outputs for testing.
+//
+// TODO(http://github.com/m-lab/uuid-annotator/issues/38): Consider moving this
+// fake to its own subpackage.
+func NewFake() ASNAnnotator {
+	f := &fakeASNAnnotator{}
+
+	// Set up v4 data for 1.2.3.4.
+	asn4Entry := routeview.IPNet{}
+	_, v4net, err := net.ParseCIDR("1.2.3.4/32")
+	rtx.Must(err, "Could not parse fixed string")
+	asn4Entry.IPNet = *v4net
+	asn4Entry.Systems = "5"
+	f.asn4 = routeview.Index{asn4Entry}
+
+	// Set up v6 data for 1111:2222:3333:4444:5555:6666:7777:8888.
+	asn6Entry := routeview.IPNet{}
+	_, v6net, err := net.ParseCIDR("1111:2222:3333:4444:5555:6666:7777:8888/128")
+	rtx.Must(err, "Could not parse fixed string")
+	asn6Entry.IPNet = *v6net
+	asn6Entry.Systems = "9"
+	f.asn6 = routeview.Index{asn6Entry}
+
+	// Set up AS name entries for AS5 and AS9
+	f.asnames = ipinfo.ASNames{
+		5: "Test Number Five",
+		9: "Test Number Nine",
+	}
+	return f
+}

asnannotator/asn_test.go

@@ -288,3 +288,20 @@ func Test_loadGZ_errors(t *testing.T) {
 		t.Error("Should have had an error, not nil")
 	}
 }
+
+func TestNewFake(t *testing.T) {
+	f := NewFake()
+	f.Reload(context.Background()) // no crash == success
+	n1 := f.AnnotateIP("1.2.3.4")
+	if n1.ASName != "Test Number Five" {
+		t.Error("Bad return value from AnnotateIP for 1.2.3.4:", n1)
+	}
+	n2 := f.AnnotateIP("1111:2222:3333:4444:5555:6666:7777:8888")
+	if n2.ASName != "Test Number Nine" {
+		t.Error("Bad return value from AnnotateIP for 1111:2222:3333:4444:5555:6666:7777:8888:", n2)
+	}
+	n3 := f.AnnotateIP("1.0.0.0")
+	if !n3.Missing {
+		t.Error("Should have had a missing return value, not", n3)
+	}
+}

geoannotator/ipannotator.go

@@ -74,6 +74,13 @@ func (g *geoannotator) annotateIPHoldingLock(ip net.IP, geo **annotator.Geolocat
 	if ip == nil {
 		return errors.New("can't annotate nil IP")
 	}
+	if g.maxmind == nil {
+		log.Println("No maxmind DB present. This should only occur during testing.")
+		*geo = &annotator.Geolocation{
+			Missing: true,
+		}
+		return nil
+	}
 	record, err := g.maxmind.City(ip)
 	if err != nil {
 		return err
@@ -164,3 +171,19 @@ func New(ctx context.Context, geo content.Provider, localIPs []net.IP) GeoAnnota
 	rtx.Must(err, "Could not load annotation db")
 	return g
 }
+
+type fakegeoannotator struct {
+	geoannotator
+}
+
+// Reload does nothing because you can't reload a fake.
+func (*fakegeoannotator) Reload(ctx context.Context) {}
+
+// NewFake creates a fake GeoAnnotator that contains no data. This is to aid
+// others in creating their own annotation services for testing.
+//
+// TODO(http://github.com/m-lab/uuid-annotator/issues/38): Consider moving this
+// fake to its own subpackage.
+func NewFake() GeoAnnotator {
+	return &fakegeoannotator{}
+}

geoannotator/ipannotator_test.go

@@ -14,10 +14,9 @@ import (
 	"github.com/m-lab/go/pretty"
 	"github.com/m-lab/go/rtx"
 	"github.com/m-lab/tcp-info/inetdiag"
-	"github.com/oschwald/geoip2-golang"
-
 	"github.com/m-lab/uuid-annotator/annotator"
 	"github.com/m-lab/uuid-annotator/tarreader"
+	geoip2 "github.com/oschwald/geoip2-golang"
 )
 
 var localRawfile content.Provider
@@ -302,3 +301,14 @@ func TestIPAnnotationMissingCityDB(t *testing.T) {
 		t.Errorf("geoannotator.load() return non-nil ptr; got %v, want nil", mm)
 	}
 }
+
+func TestNewFake(t *testing.T) {
+	f := NewFake()
+	f.Reload(context.Background()) // no crash == success
+	ann := &annotator.Geolocation{}
+	ip := net.ParseIP("1.2.3.4")
+	rtx.Must(f.AnnotateIP(ip, &ann), "could not annotate IP")
+	if !ann.Missing {
+		t.Error("Annotation should be missing.")
+	}
+}

ipservice/ipservice_test.go

@@ -219,7 +219,19 @@ func TestNewServerWithExistingFile(t *testing.T) {
 	defer os.Remove(f.Name())
 
 	_, err = NewServer(f.Name(), asn, geo)
-	rtx.Must(err, "Should not have had an error when starting NewServer wth an existing file")
+	rtx.Must(err, "Should not have had an error when starting NewServer with an existing file")
+}
+
+func TestNewServerWithBadFile(t *testing.T) {
+	// Server creation should fail when the filename can't be created.
+	dir, err := ioutil.TempDir("", "TextNewServerWithBadFile")
+	rtx.Must(err, "Could not create tempdir")
+	defer os.RemoveAll(dir)
+
+	_, err = NewServer(dir+"/this/subdir/does/not/exist/file.sock", asn, geo)
+	if err == nil {
+		t.Error("Should have had an error when starting NewServer with an uncreateable file")
+	}
 }
 
 func TestNewClient(t *testing.T) {

ipservice/server_test.go

@@ -3,10 +3,16 @@ package ipservice
 import (
 	"bytes"
 	"errors"
+	"io/ioutil"
 	"log"
+	"os"
 	"testing"
+	"time"
 
 	"github.com/m-lab/go/rtx"
+	"github.com/m-lab/go/warnonerror"
+	"github.com/m-lab/uuid-annotator/asnannotator"
+	"github.com/m-lab/uuid-annotator/geoannotator"
 )
 
 func Test_logOnError(t *testing.T) {
@@ -109,3 +115,25 @@ func Test_logOnNil(t *testing.T) {
 		})
 	}
 }
+
+func ExampleServer_forTesting() {
+	dir, err := ioutil.TempDir("", "ExampleFakeServerForTesting")
+	rtx.Must(err, "could not create tempdir")
+	defer os.RemoveAll(dir)
+
+	*SocketFilename = dir + "/ipservice.sock"
+	srv, err := NewServer(*SocketFilename, asnannotator.NewFake(), geoannotator.NewFake())
+	rtx.Must(err, "Could not create server")
+	defer warnonerror.Close(srv, "Could not stop the server")
+
+	go srv.Serve()
+	_, err = os.Stat(*SocketFilename)
+	for err != nil {
+		time.Sleep(time.Millisecond)
+		_, err = os.Stat(*SocketFilename)
+	}
+
+	// Now the server exists, and clients can connect to it via:
+	// c := NewClient(*SocketFilename)
+	// and then you can call c.Annotate() and use the returned values.
+}