automagic sql db migrations (#461)

* adds migrations closes #57 migrations only run if the database is not brand new. brand new databases will contain all the right fields when CREATE TABLE is called, this is for readability mostly more than efficiency (do not want to have to go through all of the database migrations to ascertain what columns a table has). upon startup of a new database, the migrations will be analyzed and the highest version set, so that future migrations will be run. this should also avoid running through all the migrations, which could bork db's easily enough (if the user just exits from impatience, say). otherwise, all migrations that a db has not yet seen will be run against it upon startup, this should be seamless to the user whether they had a db that had 0 migrations run on it before or N. this means users will not have to explicitly run any migrations on their dbs nor see any errors when we upgrade the db (so long as things go well). if migrations do not go so well, users will have to manually repair dbs (this is the intention of the `migrate` library and it seems sane), this should be rare, and I'm unsure myself how best to resolve not having gone through this myself, I would assume it will require running down migrations and then manually updating the migration field; in any case, docs once one of us has to go through this. migrations are written to files and checked into version control, and then use go-bindata to generate those files into go code and compiled in to be consumed by the migrate library (so that we don't have to put migration files on any servers) -- this is also in vcs. this seems to work ok. I don't like having to use the separate go-bindata tool but it wasn't really hard to install and then go generate takes care of the args. adding migrations should be relatively rare anyway, but tried to make it pretty painless. 1 migration to add created_at to the route is done here as an example of how to do migrations, as well as testing these things ;) -- `created_at` will be `0001-01-01T00:00:00.000Z` for any existing routes after a user runs this version. could spend the extra time adding 'today's date to any outstanding records, but that's not really accurate, the main thing is nobody will have to nuke their db with the migrations in place & we don't have any prod clusters really to worry about. all future routes will correctly have `created_at` set, and plan to add other timestamps but wanted to keep this patch as small as possible so only did routes.created_at. there are tests that a spankin new db will work as expected as well as a db after running all down & up migrations works. the latter tests only run on mysql and postgres, since sqlite3 does not like ALTER TABLE DROP COLUMN; up migrations will need to be tested manually for sqlite3 only, but in theory if they are simple and work on postgres and mysql, there is a good likelihood of success; the new migration from this patch works on sqlite3 fine. for now, we need to use `github.com/rdallman/migrate` to move forward, as getting integrated into upstream is proving difficult due to `github.com/go-sql-driver/mysql` being broken on master (yay dependencies). Fortunately for us, we vendor a version of the `mysql` bindings that actually works, thus, we are capable of using the `mattes/migrate` library with success due to that. this also will require go1.9 to use the new `database/sql.Conn` type, CI has been updated accordingly. some doc fixes too from testing.. and of course updated all deps. anyway, whew. this should let us add fields to the db without busting everybody's dbs. open to feedback on better ways, but this was overall pretty simple despite futzing with mysql. * add migrate pkg to deps, update deps use rdallman/migrate until we resolve in mattes land * add README in migrations package * add ref to mattes lib
2022-10-28 21:29:17 +03:00 · 2017-11-14 12:54:33 -08:00
parent 91962e50b9
commit 61b416a9b5
397 changed files with 20532 additions and 4335 deletions
--- a/api/datastore/internal/datastoretest/test.go
+++ b/api/datastore/internal/datastoretest/test.go
@@ -25,8 +25,13 @@ func setLogBuffer() *bytes.Buffer {
 	return &buf
 }

-func Test(t *testing.T, dsf func() models.Datastore) {
+func Test(t *testing.T, dsf func(t *testing.T) models.Datastore) {
 	buf := setLogBuffer()
+	defer func() {
+		if t.Failed() {
+			t.Log(buf.String())
+		}
+	}()

 	ctx := context.Background()

@@ -39,17 +44,16 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 	call.Path = testRoute.Path

 	t.Run("call-insert", func(t *testing.T) {
-		ds := dsf()
+		ds := dsf(t)
 		call.ID = id.New().String()
 		err := ds.InsertCall(ctx, call)
 		if err != nil {
-			t.Log(buf.String())
 			t.Fatalf("Test InsertCall(ctx, &call): unexpected error `%v`", err)
 		}
 	})

 	t.Run("call-get", func(t *testing.T) {
-		ds := dsf()
+		ds := dsf(t)
 		call.ID = id.New().String()
 		ds.InsertCall(ctx, call)
 		newCall, err := ds.GetCall(ctx, call.AppName, call.ID)
@@ -57,13 +61,12 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 			t.Fatalf("Test GetCall(ctx, call.ID): unexpected error `%v`", err)
 		}
 		if call.ID != newCall.ID {
-			t.Log(buf.String())
 			t.Fatalf("Test GetCall(ctx, call.ID): unexpected error `%v`", err)
 		}
 	})

 	t.Run("calls-get", func(t *testing.T) {
-		ds := dsf()
+		ds := dsf(t)
 		filter := &models.CallFilter{AppName: call.AppName, Path: call.Path, PerPage: 100}
 		call.ID = id.New().String()
 		call.CreatedAt = strfmt.DateTime(time.Now())
@@ -76,7 +79,6 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 			t.Fatalf("Test GetCalls(ctx, filter): unexpected error `%v`", err)
 		}
 		if len(calls) != 1 {
-			t.Log(buf.String())
 			t.Fatalf("Test GetCalls(ctx, filter): unexpected length `%v`", len(calls))
 		}

@@ -102,7 +104,6 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 			t.Fatalf("Test GetCalls(ctx, filter): unexpected error `%v`", err)
 		}
 		if len(calls) != 3 {
-			t.Log(buf.String())
 			t.Fatalf("Test GetCalls(ctx, filter): unexpected length `%v`", len(calls))
 		}

@@ -113,10 +114,8 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 			t.Fatalf("Test GetCalls(ctx, filter): unexpected error `%v`", err)
 		}
 		if len(calls) != 1 {
-			t.Log(buf.String())
 			t.Fatalf("Test GetCalls(ctx, filter): unexpected length `%v`", len(calls))
 		} else if calls[0].ID != c3.ID {
-			t.Log(buf.String())
 			t.Fatalf("Test GetCalls: call ids not in expected order: %v %v", calls[0].ID, c3.ID)
 		}

@@ -127,13 +126,10 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 			t.Fatalf("Test GetCalls(ctx, filter): unexpected error `%v`", err)
 		}
 		if len(calls) != 2 {
-			t.Log(buf.String())
 			t.Fatalf("Test GetCalls(ctx, filter): unexpected length `%v`", len(calls))
 		} else if calls[0].ID != c2.ID {
-			t.Log(buf.String())
 			t.Fatalf("Test GetCalls: call ids not in expected order: %v %v", calls[0].ID, c2.ID)
 		} else if calls[1].ID != call.ID {
-			t.Log(buf.String())
 			t.Fatalf("Test GetCalls: call ids not in expected order: %v %v", calls[1].ID, call.ID)
 		}

@@ -143,7 +139,6 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 			t.Fatalf("Test GetCalls(ctx, filter): unexpected error `%v`", err)
 		}
 		if len(calls) != 0 {
-			t.Log(buf.String())
 			t.Fatalf("Test GetCalls(ctx, filter): unexpected length `%v`", len(calls))
 		}

@@ -152,7 +147,6 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 			t.Fatalf("Test GetCalls(ctx, filter): unexpected error `%v`", err)
 		}
 		if len(calls) != 0 {
-			t.Log(buf.String())
 			t.Fatalf("Test GetCalls(ctx, filter): unexpected length `%v`", len(calls))
 		}

@@ -167,42 +161,35 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 			t.Fatalf("Test GetCalls(ctx, filter): unexpected error `%v`", err)
 		}
 		if len(calls) != 1 {
-			t.Log(buf.String())
 			t.Fatalf("Test GetCalls(ctx, filter): unexpected length `%v`", len(calls))
 		} else if calls[0].ID != c2.ID {
-			t.Log(buf.String())
 			t.Fatalf("Test GetCalls: call id not expected %s vs %s", calls[0].ID, c2.ID)
 		}
 	})

 	t.Run("apps", func(t *testing.T) {
-		ds := dsf()
+		ds := dsf(t)
 		// Testing insert app
 		_, err := ds.InsertApp(ctx, nil)
 		if err != models.ErrDatastoreEmptyApp {
-			t.Log(buf.String())
 			t.Fatalf("Test InsertApp(nil): expected error `%v`, but it was `%v`", models.ErrDatastoreEmptyApp, err)
 		}

 		_, err = ds.InsertApp(ctx, &models.App{})
 		if err != models.ErrDatastoreEmptyAppName {
-			t.Log(buf.String())
 			t.Fatalf("Test InsertApp(&{}): expected error `%v`, but it was `%v`", models.ErrDatastoreEmptyAppName, err)
 		}

 		inserted, err := ds.InsertApp(ctx, testApp)
 		if err != nil {
-			t.Log(buf.String())
 			t.Fatalf("Test InsertApp: error when storing new app: %s", err)
 		}
 		if !reflect.DeepEqual(*inserted, *testApp) {
-			t.Log(buf.String())
 			t.Fatalf("Test InsertApp: expected to insert:\n%v\nbut got:\n%v", testApp, inserted)
 		}

 		_, err = ds.InsertApp(ctx, testApp)
 		if err != models.ErrAppsAlreadyExists {
-			t.Log(buf.String())
 			t.Fatalf("Test InsertApp duplicated: expected error `%v`, but it was `%v`", models.ErrAppsAlreadyExists, err)
 		}

@@ -211,12 +198,10 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 			updated, err := ds.UpdateApp(ctx,
 				&models.App{Name: testApp.Name, Config: map[string]string{"TEST": "1"}})
 			if err != nil {
-				t.Log(buf.String())
 				t.Fatalf("Test UpdateApp: error when updating app: %v", err)
 			}
 			expected := &models.App{Name: testApp.Name, Config: map[string]string{"TEST": "1"}}
 			if !reflect.DeepEqual(*updated, *expected) {
-				t.Log(buf.String())
 				t.Fatalf("Test UpdateApp: expected updated `%v` but got `%v`", expected, updated)
 			}

@@ -224,12 +209,10 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 			updated, err = ds.UpdateApp(ctx,
 				&models.App{Name: testApp.Name, Config: map[string]string{"OTHER": "TEST"}})
 			if err != nil {
-				t.Log(buf.String())
 				t.Fatalf("Test UpdateApp: error when updating app: %v", err)
 			}
 			expected = &models.App{Name: testApp.Name, Config: map[string]string{"TEST": "1", "OTHER": "TEST"}}
 			if !reflect.DeepEqual(*updated, *expected) {
-				t.Log(buf.String())
 				t.Fatalf("Test UpdateApp: expected updated `%v` but got `%v`", expected, updated)
 			}

@@ -237,12 +220,10 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 			updated, err = ds.UpdateApp(ctx,
 				&models.App{Name: testApp.Name, Config: map[string]string{"TEST": ""}})
 			if err != nil {
-				t.Log(buf.String())
 				t.Fatalf("Test UpdateApp: error when updating app: %v", err)
 			}
 			expected = &models.App{Name: testApp.Name, Config: map[string]string{"OTHER": "TEST"}}
 			if !reflect.DeepEqual(*updated, *expected) {
-				t.Log(buf.String())
 				t.Fatalf("Test UpdateApp: expected updated `%v` but got `%v`", expected, updated)
 			}
 		}
@@ -250,31 +231,26 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 		// Testing get app
 		_, err = ds.GetApp(ctx, "")
 		if err != models.ErrDatastoreEmptyAppName {
-			t.Log(buf.String())
 			t.Fatalf("Test GetApp: expected error to be %v, but it was %s", models.ErrDatastoreEmptyAppName, err)
 		}

 		app, err := ds.GetApp(ctx, testApp.Name)
 		if err != nil {
-			t.Log(buf.String())
 			t.Fatalf("Test GetApp: error: %s", err)
 		}
 		if app.Name != testApp.Name {
-			t.Log(buf.String())
 			t.Fatalf("Test GetApp: expected `app.Name` to be `%s` but it was `%s`", app.Name, testApp.Name)
 		}

 		// Testing list apps
 		apps, err := ds.GetApps(ctx, &models.AppFilter{PerPage: 100})
 		if err != nil {
-			t.Log(buf.String())
 			t.Fatalf("Test GetApps: unexpected error %v", err)
 		}
 		if len(apps) == 0 {
 			t.Fatal("Test GetApps: expected result count to be greater than 0")
 		}
 		if apps[0].Name != testApp.Name {
-			t.Log(buf.String())
 			t.Fatalf("Test GetApps: expected `app.Name` to be `%s` but it was `%s`", app.Name, testApp.Name)
 		}

@@ -292,28 +268,23 @@ func Test(t *testing.T, dsf func() models.Datastore) {

 		apps, err = ds.GetApps(ctx, &models.AppFilter{PerPage: 1})
 		if err != nil {
-			t.Log(buf.String())
 			t.Fatalf("Test GetApps: error: %s", err)
 		}
 		if len(apps) != 1 {
 			t.Fatalf("Test GetApps: expected result count to be 1 but got %d", len(apps))
 		} else if apps[0].Name != testApp.Name {
-			t.Log(buf.String())
 			t.Fatalf("Test GetApps: expected `app.Name` to be `%s` but it was `%s`", testApp.Name, apps[0].Name)
 		}

 		apps, err = ds.GetApps(ctx, &models.AppFilter{PerPage: 100, Cursor: apps[0].Name})
 		if err != nil {
-			t.Log(buf.String())
 			t.Fatalf("Test GetApps: error: %s", err)
 		}
 		if len(apps) != 2 {
 			t.Fatalf("Test GetApps: expected result count to be 2 but got %d", len(apps))
 		} else if apps[0].Name != a2.Name {
-			t.Log(buf.String())
 			t.Fatalf("Test GetApps: expected `app.Name` to be `%s` but it was `%s`", a2.Name, apps[0].Name)
 		} else if apps[1].Name != a3.Name {
-			t.Log(buf.String())
 			t.Fatalf("Test GetApps: expected `app.Name` to be `%s` but it was `%s`", a3.Name, apps[1].Name)
 		}

@@ -326,20 +297,17 @@ func Test(t *testing.T, dsf func() models.Datastore) {

 		apps, err = ds.GetApps(ctx, &models.AppFilter{PerPage: 100})
 		if err != nil {
-			t.Log(buf.String())
 			t.Fatalf("Test GetApps: error: %s", err)
 		}
 		if len(apps) != 4 {
 			t.Fatalf("Test GetApps: expected result count to be 4 but got %d", len(apps))
 		} else if apps[0].Name != a4.Name {
-			t.Log(buf.String())
 			t.Fatalf("Test GetApps: expected `app.Name` to be `%s` but it was `%s`", a4.Name, apps[0].Name)
 		}

 		// TODO fix up prefix stuff
 		//apps, err = ds.GetApps(ctx, &models.AppFilter{Name: "Tes"})
 		//if err != nil {
-		//t.Log(buf.String())
 		//t.Fatalf("Test GetApps(filter): unexpected error %v", err)
 		//}
 		//if len(apps) != 3 {
@@ -349,22 +317,18 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 		// Testing app delete
 		err = ds.RemoveApp(ctx, "")
 		if err != models.ErrDatastoreEmptyAppName {
-			t.Log(buf.String())
 			t.Fatalf("Test RemoveApp: expected error `%v`, but it was `%v`", models.ErrDatastoreEmptyAppName, err)
 		}

 		err = ds.RemoveApp(ctx, testApp.Name)
 		if err != nil {
-			t.Log(buf.String())
 			t.Fatalf("Test RemoveApp: error: %s", err)
 		}
 		app, err = ds.GetApp(ctx, testApp.Name)
 		if err != models.ErrAppsNotFound {
-			t.Log(buf.String())
 			t.Fatalf("Test GetApp(removed): expected error `%v`, but it was `%v`", models.ErrAppsNotFound, err)
 		}
 		if app != nil {
-			t.Log(buf.String())
 			t.Fatal("Test RemoveApp: failed to remove the app")
 		}

@@ -376,17 +340,15 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 			},
 		})
 		if err != models.ErrAppsNotFound {
-			t.Log(buf.String())
 			t.Fatalf("Test UpdateApp(inexistent): expected error `%v`, but it was `%v`", models.ErrAppsNotFound, err)
 		}
 	})

 	t.Run("routes", func(t *testing.T) {
-		ds := dsf()
+		ds := dsf(t)
 		// Insert app again to test routes
 		_, err := ds.InsertApp(ctx, testApp)
 		if err != nil && err != models.ErrAppsAlreadyExists {
-			t.Log(buf.String())
 			t.Fatal("Test InsertRoute Prep: failed to insert app: ", err)
 		}

@@ -394,25 +356,21 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 		{
 			_, err = ds.InsertRoute(ctx, nil)
 			if err != models.ErrDatastoreEmptyRoute {
-				t.Log(buf.String())
 				t.Fatalf("Test InsertRoute(nil): expected error `%v`, but it was `%v`", models.ErrDatastoreEmptyRoute, err)
 			}

 			_, err = ds.InsertRoute(ctx, &models.Route{AppName: "notreal", Path: "/test"})
 			if err != models.ErrAppsNotFound {
-				t.Log(buf.String())
 				t.Fatalf("Test InsertRoute: expected error `%v`, but it was `%v`", models.ErrAppsNotFound, err)
 			}

 			_, err = ds.InsertRoute(ctx, testRoute)
 			if err != nil {
-				t.Log(buf.String())
 				t.Fatalf("Test InsertRoute: error when storing new route: %s", err)
 			}

 			_, err = ds.InsertRoute(ctx, testRoute)
 			if err != models.ErrRoutesAlreadyExists {
-				t.Log(buf.String())
 				t.Fatalf("Test InsertRoute duplicated: expected error to be `%v`, but it was `%v`", models.ErrRoutesAlreadyExists, err)
 			}
 		}
@@ -421,24 +379,20 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 		{
 			_, err = ds.GetRoute(ctx, "a", "")
 			if err != models.ErrDatastoreEmptyRoutePath {
-				t.Log(buf.String())
 				t.Fatalf("Test GetRoute(empty route path): expected error `%v`, but it was `%v`", models.ErrDatastoreEmptyRoutePath, err)
 			}

 			_, err = ds.GetRoute(ctx, "", "a")
 			if err != models.ErrDatastoreEmptyAppName {
-				t.Log(buf.String())
 				t.Fatalf("Test GetRoute(empty app name): expected error `%v`, but it was `%v`", models.ErrDatastoreEmptyAppName, err)
 			}

 			route, err := ds.GetRoute(ctx, testApp.Name, testRoute.Path)
 			if err != nil {
-				t.Log(buf.String())
 				t.Fatalf("Test GetRoute: unexpected error %v", err)
 			}
 			var expected models.Route = *testRoute
 			if !reflect.DeepEqual(*route, expected) {
-				t.Log(buf.String())
 				t.Fatalf("Test InsertApp: expected to insert:\n%v\nbut got:\n%v", expected, *route)
 			}
 		}
@@ -462,7 +416,6 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 				},
 			})
 			if err != nil {
-				t.Log(buf.String())
 				t.Fatalf("Test UpdateRoute: unexpected error: %v", err)
 			}
 			expected := &models.Route{
@@ -488,7 +441,6 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 				},
 			}
 			if !reflect.DeepEqual(*updated, *expected) {
-				t.Log(buf.String())
 				t.Fatalf("Test UpdateRoute: expected updated `%v` but got `%v`", expected, updated)
 			}

@@ -507,7 +459,6 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 				},
 			})
 			if err != nil {
-				t.Log(buf.String())
 				t.Fatalf("Test UpdateRoute: unexpected error: %v", err)
 			}
 			expected = &models.Route{
@@ -531,7 +482,6 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 				},
 			}
 			if !reflect.DeepEqual(*updated, *expected) {
-				t.Log(buf.String())
 				t.Fatalf("Test UpdateRoute: expected updated:\n`%v`\nbut got:\n`%v`", expected, updated)
 			}
 		}
@@ -539,39 +489,32 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 		// Testing list routes
 		routes, err := ds.GetRoutesByApp(ctx, testApp.Name, &models.RouteFilter{PerPage: 1})
 		if err != nil {
-			t.Log(buf.String())
 			t.Fatalf("Test GetRoutesByApp: unexpected error %v", err)
 		}
 		if len(routes) == 0 {
 			t.Fatal("Test GetRoutesByApp: expected result count to be greater than 0")
 		}
 		if routes[0] == nil {
-			t.Log(buf.String())
 			t.Fatalf("Test GetRoutes: expected non-nil route")
 		} else if routes[0].Path != testRoute.Path {
-			t.Log(buf.String())
 			t.Fatalf("Test GetRoutes: expected `app.Name` to be `%s` but it was `%s`", testRoute.Path, routes[0].Path)
 		}

 		routes, err = ds.GetRoutesByApp(ctx, testApp.Name, &models.RouteFilter{Image: testRoute.Image, PerPage: 1})
 		if err != nil {
-			t.Log(buf.String())
 			t.Fatalf("Test GetRoutesByApp: unexpected error %v", err)
 		}
 		if len(routes) == 0 {
 			t.Fatal("Test GetRoutesByApp: expected result count to be greater than 0")
 		}
 		if routes[0] == nil {
-			t.Log(buf.String())
 			t.Fatalf("Test GetRoutesByApp: expected non-nil route")
 		} else if routes[0].Path != testRoute.Path {
-			t.Log(buf.String())
 			t.Fatalf("Test GetRoutesByApp: expected `route.Path` to be `%s` but it was `%s`", testRoute.Path, routes[0].Path)
 		}

 		routes, err = ds.GetRoutesByApp(ctx, "notreal", &models.RouteFilter{PerPage: 1})
 		if err != nil {
-			t.Log(buf.String())
 			t.Fatalf("Test GetRoutesByApp: error: %s", err)
 		}
 		if len(routes) != 0 {
@@ -593,28 +536,23 @@ func Test(t *testing.T, dsf func() models.Datastore) {

 		routes, err = ds.GetRoutesByApp(ctx, testApp.Name, &models.RouteFilter{PerPage: 1})
 		if err != nil {
-			t.Log(buf.String())
 			t.Fatalf("Test GetRoutesByApp: error: %s", err)
 		}
 		if len(routes) != 1 {
 			t.Fatalf("Test GetRoutesByApp: expected result count to be 1 but got %d", len(routes))
 		} else if routes[0].Path != testRoute.Path {
-			t.Log(buf.String())
 			t.Fatalf("Test GetRoutesByApp: expected `route.Path` to be `%s` but it was `%s`", testRoute.Path, routes[0].Path)
 		}

 		routes, err = ds.GetRoutesByApp(ctx, testApp.Name, &models.RouteFilter{PerPage: 2, Cursor: routes[0].Path})
 		if err != nil {
-			t.Log(buf.String())
 			t.Fatalf("Test GetRoutesByApp: error: %s", err)
 		}
 		if len(routes) != 2 {
 			t.Fatalf("Test GetRoutesByApp: expected result count to be 2 but got %d", len(routes))
 		} else if routes[0].Path != r2.Path {
-			t.Log(buf.String())
 			t.Fatalf("Test GetRoutesByApp: expected `route.Path` to be `%s` but it was `%s`", r2.Path, routes[0].Path)
 		} else if routes[1].Path != r3.Path {
-			t.Log(buf.String())
 			t.Fatalf("Test GetRoutesByApp: expected `route.Path` to be `%s` but it was `%s`", r3.Path, routes[1].Path)
 		}

@@ -627,13 +565,11 @@ func Test(t *testing.T, dsf func() models.Datastore) {

 		routes, err = ds.GetRoutesByApp(ctx, testApp.Name, &models.RouteFilter{PerPage: 100})
 		if err != nil {
-			t.Log(buf.String())
 			t.Fatalf("Test GetRoutesByApp: error: %s", err)
 		}
 		if len(routes) != 4 {
 			t.Fatalf("Test GetRoutesByApp: expected result count to be 4 but got %d", len(routes))
 		} else if routes[0].Path != r4.Path {
-			t.Log(buf.String())
 			t.Fatalf("Test GetRoutesByApp: expected `route.Path` to be `%s` but it was `%s`", r4.Path, routes[0].Path)
 		}

@@ -643,29 +579,24 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 		// Testing route delete
 		err = ds.RemoveRoute(ctx, "", "")
 		if err != models.ErrDatastoreEmptyAppName {
-			t.Log(buf.String())
 			t.Fatalf("Test RemoveRoute(empty app name): expected error `%v`, but it was `%v`", models.ErrDatastoreEmptyAppName, err)
 		}

 		err = ds.RemoveRoute(ctx, "a", "")
 		if err != models.ErrDatastoreEmptyRoutePath {
-			t.Log(buf.String())
 			t.Fatalf("Test RemoveRoute(empty route path): expected error `%v`, but it was `%v`", models.ErrDatastoreEmptyRoutePath, err)
 		}

 		err = ds.RemoveRoute(ctx, testRoute.AppName, testRoute.Path)
 		if err != nil {
-			t.Log(buf.String())
 			t.Fatalf("Test RemoveApp: unexpected error: %v", err)
 		}

 		route, err := ds.GetRoute(ctx, testRoute.AppName, testRoute.Path)
 		if err != nil && err != models.ErrRoutesNotFound {
-			t.Log(buf.String())
 			t.Fatalf("Test GetRoute: expected error `%v`, but it was `%v`", models.ErrRoutesNotFound, err)
 		}
 		if route != nil {
-			t.Log(buf.String())
 			t.Fatalf("Test RemoveApp: failed to remove the route: %v", route)
 		}

@@ -675,7 +606,6 @@ func Test(t *testing.T, dsf func() models.Datastore) {
 			Image:   "test",
 		})
 		if err != models.ErrRoutesNotFound {
-			t.Log(buf.String())
 			t.Fatalf("Test UpdateRoute inexistent: expected error to be `%v`, but it was `%v`", models.ErrRoutesNotFound, err)
 		}
 	})
--- a/api/datastore/mock_test.go
+++ b/api/datastore/mock_test.go
@@ -4,8 +4,12 @@ import (
 	"testing"

 	"github.com/fnproject/fn/api/datastore/internal/datastoretest"
+	"github.com/fnproject/fn/api/models"
 )

 func TestDatastore(t *testing.T) {
-	datastoretest.Test(t, NewMock)
+	f := func(t *testing.T) models.Datastore {
+		return NewMock()
+	}
+	datastoretest.Test(t, f)
 }
--- a/api/datastore/sql/migrations/1_add_route_created_at.down.sql
+++ b/api/datastore/sql/migrations/1_add_route_created_at.down.sql
@@ -0,0 +1 @@
+ALTER TABLE routes DROP COLUMN created_at;
--- a/api/datastore/sql/migrations/1_add_route_created_at.up.sql
+++ b/api/datastore/sql/migrations/1_add_route_created_at.up.sql
@@ -0,0 +1 @@
+ALTER TABLE routes ADD created_at text;
--- a/api/datastore/sql/migrations/README.md
+++ b/api/datastore/sql/migrations/README.md
@@ -0,0 +1,40 @@
+# Migrations How-To
+
+All migration files should be of the format:
+
+`[0-9]+_[add|remove]_model[_field]*.[up|down].sql`
+
+The number at the beginning of the file name should be monotonically
+increasing, from the last highest file number in this directory. E.g. if there
+is `11_add_foo_bar.up.sql`, your new file should be `12_add_bar_baz.up.sql`.
+
+All `*.up.sql` files must have an accompanying `*.down.sql` file in order to
+pass review.
+
+The contents of each file should contain only 1 ANSI sql query. For help, you
+may refer to https://github.com/mattes/migrate/blob/master/MIGRATIONS.md which
+illustrates some of the finer points.
+
+After creating the file you will need to run, in the same directory as this
+README:
+
+```sh
+$ go generate
+```
+
+NOTE: You may need to `go get github.com/jteeuwen/go-bindata` before running `go
+generate` in order for it to work.
+
+After running `go generate`, the `migrations.go` file should be updated. Check
+the updated version of this as well as the new `.sql` file into git.
+
+After adding the migration, be sure to update the fields in the sql tables in
+`sql.go` up one package. For example, if you added a column `foo` to `routes`,
+add this field to the routes `CREATE TABLE` query, as well as any queries
+where it should be returned.
+
+After doing this, run the test suite to make sure the sql queries work as
+intended and voila. The test suite will ensure that the up and down migrations
+work as well as a fresh db. The down migrations will not be tested against
+SQLite3 as it does not support `ALTER TABLE DROP COLUMN`, but will still be
+tested against postgres and MySQL.
--- a/api/datastore/sql/migrations/index.go
+++ b/api/datastore/sql/migrations/index.go
@@ -0,0 +1,12 @@
+package migrations
+
+//go:generate go-bindata -ignore migrations.go -ignore index.go -o migrations.go -pkg migrations .
+
+// migrations are generated from this cwd with go generate.
+// install https://github.com/jteeuwen/go-bindata for go generate
+// command to work properly.
+
+// this will generate a go file with go-bindata of all the migration
+// files in 1 go file, so that migrations can be run remotely without
+// having to carry the migration files around (i.e. since they are
+// compiled into the go binary)
--- a/api/datastore/sql/migrations/migrations.go
+++ b/api/datastore/sql/migrations/migrations.go
@@ -0,0 +1,258 @@
+// Code generated by go-bindata.
+// sources:
+// 1_add_route_created_at.down.sql
+// 1_add_route_created_at.up.sql
+// DO NOT EDIT!
+
+package migrations
+
+import (
+	"bytes"
+	"compress/gzip"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+func bindataRead(data []byte, name string) ([]byte, error) {
+	gz, err := gzip.NewReader(bytes.NewBuffer(data))
+	if err != nil {
+		return nil, fmt.Errorf("Read %q: %v", name, err)
+	}
+
+	var buf bytes.Buffer
+	_, err = io.Copy(&buf, gz)
+	clErr := gz.Close()
+
+	if err != nil {
+		return nil, fmt.Errorf("Read %q: %v", name, err)
+	}
+	if clErr != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+type asset struct {
+	bytes []byte
+	info  os.FileInfo
+}
+
+type bindataFileInfo struct {
+	name    string
+	size    int64
+	mode    os.FileMode
+	modTime time.Time
+}
+
+func (fi bindataFileInfo) Name() string {
+	return fi.name
+}
+func (fi bindataFileInfo) Size() int64 {
+	return fi.size
+}
+func (fi bindataFileInfo) Mode() os.FileMode {
+	return fi.mode
+}
+func (fi bindataFileInfo) ModTime() time.Time {
+	return fi.modTime
+}
+func (fi bindataFileInfo) IsDir() bool {
+	return false
+}
+func (fi bindataFileInfo) Sys() interface{} {
+	return nil
+}
+
+var __1_add_route_created_atDownSql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x72\xf4\x09\x71\x0d\x52\x08\x71\x74\xf2\x71\x55\x28\xca\x2f\x2d\x49\x2d\x56\x70\x09\xf2\x0f\x50\x70\xf6\xf7\x09\xf5\xf5\x53\x48\x2e\x4a\x4d\x2c\x49\x4d\x89\x4f\x2c\xb1\xe6\x02\x04\x00\x00\xff\xff\x47\xfd\x3b\xbe\x2b\x00\x00\x00")
+
+func _1_add_route_created_atDownSqlBytes() ([]byte, error) {
+	return bindataRead(
+		__1_add_route_created_atDownSql,
+		"1_add_route_created_at.down.sql",
+	)
+}
+
+func _1_add_route_created_atDownSql() (*asset, error) {
+	bytes, err := _1_add_route_created_atDownSqlBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "1_add_route_created_at.down.sql", size: 43, mode: os.FileMode(420), modTime: time.Unix(1508386173, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+var __1_add_route_created_atUpSql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x72\xf4\x09\x71\x0d\x52\x08\x71\x74\xf2\x71\x55\x28\xca\x2f\x2d\x49\x2d\x56\x70\x74\x71\x51\x48\x2e\x4a\x4d\x2c\x49\x4d\x89\x4f\x2c\x51\x28\x49\xad\x28\xb1\xe6\x02\x04\x00\x00\xff\xff\x3b\x59\x9c\x54\x28\x00\x00\x00")
+
+func _1_add_route_created_atUpSqlBytes() ([]byte, error) {
+	return bindataRead(
+		__1_add_route_created_atUpSql,
+		"1_add_route_created_at.up.sql",
+	)
+}
+
+func _1_add_route_created_atUpSql() (*asset, error) {
+	bytes, err := _1_add_route_created_atUpSqlBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "1_add_route_created_at.up.sql", size: 40, mode: os.FileMode(420), modTime: time.Unix(1508360377, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+// Asset loads and returns the asset for the given name.
+// It returns an error if the asset could not be found or
+// could not be loaded.
+func Asset(name string) ([]byte, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
+		}
+		return a.bytes, nil
+	}
+	return nil, fmt.Errorf("Asset %s not found", name)
+}
+
+// MustAsset is like Asset but panics when Asset would return an error.
+// It simplifies safe initialization of global variables.
+func MustAsset(name string) []byte {
+	a, err := Asset(name)
+	if err != nil {
+		panic("asset: Asset(" + name + "): " + err.Error())
+	}
+
+	return a
+}
+
+// AssetInfo loads and returns the asset info for the given name.
+// It returns an error if the asset could not be found or
+// could not be loaded.
+func AssetInfo(name string) (os.FileInfo, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
+		}
+		return a.info, nil
+	}
+	return nil, fmt.Errorf("AssetInfo %s not found", name)
+}
+
+// AssetNames returns the names of the assets.
+func AssetNames() []string {
+	names := make([]string, 0, len(_bindata))
+	for name := range _bindata {
+		names = append(names, name)
+	}
+	return names
+}
+
+// _bindata is a table, holding each asset generator, mapped to its name.
+var _bindata = map[string]func() (*asset, error){
+	"1_add_route_created_at.down.sql": _1_add_route_created_atDownSql,
+	"1_add_route_created_at.up.sql":   _1_add_route_created_atUpSql,
+}
+
+// AssetDir returns the file names below a certain
+// directory embedded in the file by go-bindata.
+// For example if you run go-bindata on data/... and data contains the
+// following hierarchy:
+//     data/
+//       foo.txt
+//       img/
+//         a.png
+//         b.png
+// then AssetDir("data") would return []string{"foo.txt", "img"}
+// AssetDir("data/img") would return []string{"a.png", "b.png"}
+// AssetDir("foo.txt") and AssetDir("notexist") would return an error
+// AssetDir("") will return []string{"data"}.
+func AssetDir(name string) ([]string, error) {
+	node := _bintree
+	if len(name) != 0 {
+		cannonicalName := strings.Replace(name, "\\", "/", -1)
+		pathList := strings.Split(cannonicalName, "/")
+		for _, p := range pathList {
+			node = node.Children[p]
+			if node == nil {
+				return nil, fmt.Errorf("Asset %s not found", name)
+			}
+		}
+	}
+	if node.Func != nil {
+		return nil, fmt.Errorf("Asset %s not found", name)
+	}
+	rv := make([]string, 0, len(node.Children))
+	for childName := range node.Children {
+		rv = append(rv, childName)
+	}
+	return rv, nil
+}
+
+type bintree struct {
+	Func     func() (*asset, error)
+	Children map[string]*bintree
+}
+
+var _bintree = &bintree{nil, map[string]*bintree{
+	"1_add_route_created_at.down.sql": &bintree{_1_add_route_created_atDownSql, map[string]*bintree{}},
+	"1_add_route_created_at.up.sql":   &bintree{_1_add_route_created_atUpSql, map[string]*bintree{}},
+}}
+
+// RestoreAsset restores an asset under the given directory
+func RestoreAsset(dir, name string) error {
+	data, err := Asset(name)
+	if err != nil {
+		return err
+	}
+	info, err := AssetInfo(name)
+	if err != nil {
+		return err
+	}
+	err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
+	if err != nil {
+		return err
+	}
+	err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
+	if err != nil {
+		return err
+	}
+	err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// RestoreAssets restores an asset under the given directory recursively
+func RestoreAssets(dir, name string) error {
+	children, err := AssetDir(name)
+	// File
+	if err != nil {
+		return RestoreAsset(dir, name)
+	}
+	// Dir
+	for _, child := range children {
+		err = RestoreAssets(dir, filepath.Join(name, child))
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func _filePath(dir, name string) string {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
+}
--- a/api/datastore/sql/sql.go
+++ b/api/datastore/sql/sql.go
@@ -13,6 +13,7 @@ import (
 	"strings"
 	"time"

+	"github.com/fnproject/fn/api/datastore/sql/migrations"
 	"github.com/fnproject/fn/api/models"
 	"github.com/go-sql-driver/mysql"
 	_ "github.com/go-sql-driver/mysql"
@@ -21,6 +22,12 @@ import (
 	_ "github.com/lib/pq"
 	"github.com/mattn/go-sqlite3"
 	_ "github.com/mattn/go-sqlite3"
+	"github.com/rdallman/migrate"
+	_ "github.com/rdallman/migrate/database/mysql"
+	_ "github.com/rdallman/migrate/database/postgres"
+	_ "github.com/rdallman/migrate/database/sqlite3"
+	"github.com/rdallman/migrate/source"
+	"github.com/rdallman/migrate/source/go-bindata"
 	"github.com/sirupsen/logrus"
 )

@@ -41,6 +48,7 @@ var tables = [...]string{`CREATE TABLE IF NOT EXISTS routes (
 	type varchar(16) NOT NULL,
 	headers text NOT NULL,
 	config text NOT NULL,
+	created_at text,
 	PRIMARY KEY (app_name, path)
 );`,

@@ -68,7 +76,7 @@ var tables = [...]string{`CREATE TABLE IF NOT EXISTS routes (
 }

 const (
-	routeSelector = `SELECT app_name, path, image, format, memory, type, timeout, idle_timeout, headers, config FROM routes`
+	routeSelector = `SELECT app_name, path, image, format, memory, type, timeout, idle_timeout, headers, config, created_at FROM routes`
 	callSelector  = `SELECT id, created_at, started_at, completed_at, status, app_name, path FROM calls`
 )

@@ -79,11 +87,16 @@ type sqlStore struct {
 // New will open the db specified by url, create any tables necessary
 // and return a models.Datastore safe for concurrent usage.
 func New(url *url.URL) (models.Datastore, error) {
+	return newDS(url)
+}
+
+// for test methods, return concrete type, but don't expose
+func newDS(url *url.URL) (*sqlStore, error) {
 	driver := url.Scheme

 	// driver must be one of these for sqlx to work, double check:
 	switch driver {
-	case "postgres", "pgx", "mysql", "sqlite3", "oci8", "ora", "goracle":
+	case "postgres", "pgx", "mysql", "sqlite3":
 	default:
 		return nil, errors.New("invalid db driver, refer to the code")
 	}
@@ -121,6 +134,12 @@ func New(url *url.URL) (models.Datastore, error) {
 	db.SetMaxIdleConns(maxIdleConns)
 	logrus.WithFields(logrus.Fields{"max_idle_connections": maxIdleConns, "datastore": driver}).Info("datastore dialed")

+	err = runMigrations(url.String(), checkExistence(db)) // original url string
+	if err != nil {
+		logrus.WithError(err).Error("error running migrations")
+		return nil, err
+	}
+
 	switch driver {
 	case "sqlite3":
 		db.SetMaxOpenConns(1)
@@ -135,6 +154,104 @@ func New(url *url.URL) (models.Datastore, error) {
 	return &sqlStore{db: db}, nil
 }

+// checkExistence checks if tables have been created yet, it is not concerned
+// about the existence of the schema migration version (since migrations were
+// added to existing dbs, we need to know whether the db exists without migrations
+// or if it's brand new).
+func checkExistence(db *sqlx.DB) bool {
+	query := db.Rebind(`SELECT name FROM apps LIMIT 1`)
+	row := db.QueryRow(query)
+
+	var dummy string
+	err := row.Scan(&dummy)
+	if err != nil && err != sql.ErrNoRows {
+		// TODO we should probably ensure this is a certain 'no such table' error
+		// and if it's not that or err no rows, we should probably block start up.
+		// if we return false here spuriously, then migrations could be skipped,
+		// which would be bad.
+		return false
+	}
+	return true
+}
+
+// check if the db already existed, if the db is brand new then we can skip
+// over all the migrations BUT we must be sure to set the right migration
+// number so that only current migrations are skipped, not any future ones.
+func runMigrations(url string, exists bool) error {
+	m, err := migrator(url)
+	if err != nil {
+		return err
+	}
+	defer m.Close()
+
+	if !exists {
+		// set to highest and bail
+		return m.Force(latestVersion(migrations.AssetNames()))
+	}
+
+	// run any migrations needed to get to latest, if any
+	err = m.Up()
+	if err == migrate.ErrNoChange { // we don't care, but want other errors
+		err = nil
+	}
+	return err
+}
+
+func migrator(url string) (*migrate.Migrate, error) {
+	s := bindata.Resource(migrations.AssetNames(),
+		func(name string) ([]byte, error) {
+			return migrations.Asset(name)
+		})
+
+	d, err := bindata.WithInstance(s)
+	if err != nil {
+		return nil, err
+	}
+
+	return migrate.NewWithSourceInstance("go-bindata", d, url)
+}
+
+// latest version will find the latest version from a list of migration
+// names (not from the db)
+func latestVersion(migs []string) int {
+	var highest uint
+	for _, m := range migs {
+		mig, _ := source.Parse(m)
+		if mig.Version > highest {
+			highest = mig.Version
+		}
+	}
+
+	return int(highest)
+}
+
+// clear is for tests only, be careful, it deletes all records.
+func (ds *sqlStore) clear() error {
+	return ds.Tx(func(tx *sqlx.Tx) error {
+		query := tx.Rebind(`DELETE FROM routes`)
+		_, err := tx.Exec(query)
+		if err != nil {
+			return err
+		}
+
+		query = tx.Rebind(`DELETE FROM calls`)
+		_, err = tx.Exec(query)
+		if err != nil {
+			return err
+		}
+
+		query = tx.Rebind(`DELETE FROM apps`)
+		_, err = tx.Exec(query)
+		if err != nil {
+			return err
+		}
+
+		query = tx.Rebind(`DELETE FROM logs`)
+		_, err = tx.Exec(query)
+		return err
+	})
+}
+
 func (ds *sqlStore) InsertApp(ctx context.Context, app *models.App) (*models.App, error) {
 	query := ds.db.Rebind("INSERT INTO apps (name, config) VALUES (:name, :config);")
 	_, err := ds.db.NamedExecContext(ctx, query, app)
@@ -298,7 +415,8 @@ func (ds *sqlStore) InsertRoute(ctx context.Context, route *models.Route) (*mode
 			timeout,
 			idle_timeout,
 			headers,
-			config
+			config,
+			created_at
 		)
 		VALUES (
 			:app_name,
@@ -310,7 +428,8 @@ func (ds *sqlStore) InsertRoute(ctx context.Context, route *models.Route) (*mode
 			:timeout,
 			:idle_timeout,
 			:headers,
-			:config
+			:config,
+			:created_at
 		);`)

 		_, err = tx.NamedExecContext(ctx, query, route)
@@ -348,7 +467,8 @@ func (ds *sqlStore) UpdateRoute(ctx context.Context, newroute *models.Route) (*m
 			timeout = :timeout,
 			idle_timeout = :idle_timeout,
 			headers = :headers,
-			config = :config
+			config = :config,
+			created_at = :created_at
 		WHERE app_name=:app_name AND path=:path;`)

 		res, err := tx.NamedExecContext(ctx, query, &route)
--- a/api/datastore/sql/sql_test.go
+++ b/api/datastore/sql/sql_test.go
@@ -10,15 +10,45 @@ import (
 	"github.com/fnproject/fn/api/models"
 )

+// since New with fresh dbs skips all migrations:
+// * open a fresh db on latest version
+// * run all down migrations
+// * run all up migrations
+// [ then run tests against that db ]
+func newWithMigrations(url *url.URL) (*sqlStore, error) {
+	ds, err := newDS(url)
+	if err != nil {
+		return nil, err
+	}
+
+	m, err := migrator(url.String())
+	if err != nil {
+		return nil, err
+	}
+
+	err = m.Down()
+	if err != nil {
+		return nil, err
+	}
+
+	// go through New, to ensure our Up logic works in there...
+	ds, err = newDS(url)
+	if err != nil {
+		return nil, err
+	}
+
+	return ds, nil
+}
+
 func TestDatastore(t *testing.T) {
 	defer os.RemoveAll("sqlite_test_dir")
 	u, err := url.Parse("sqlite3://sqlite_test_dir")
 	if err != nil {
 		t.Fatal(err)
 	}
-	f := func() models.Datastore {
+	f := func(t *testing.T) models.Datastore {
 		os.RemoveAll("sqlite_test_dir")
-		ds, err := New(u)
+		ds, err := newDS(u)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -26,4 +56,63 @@ func TestDatastore(t *testing.T) {
 		return datastoreutil.NewValidator(ds)
 	}
 	datastoretest.Test(t, f)
+
+	// NOTE: sqlite3 does not like ALTER TABLE DROP COLUMN so do not run
+	// migration tests against it, only pg and mysql -- should prove UP migrations
+	// will likely work for sqlite3, but may need separate testing by devs :(
+
+	// if being run from test script (CI) poke around for pg and mysql containers
+	// to run tests against them too. this runs with a fresh db first run, then
+	// will down migrate all migrations, up migrate, and run tests again.
+
+	both := func(u *url.URL) {
+		f := func(t *testing.T) models.Datastore {
+			ds, err := newDS(u)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ds.clear()
+			if err != nil {
+				t.Fatal(err)
+			}
+			return datastoreutil.NewValidator(ds)
+		}
+
+		// test fresh w/o migrations
+		datastoretest.Test(t, f)
+
+		f = func(t *testing.T) models.Datastore {
+			t.Log("with migrations now!")
+			ds, err := newWithMigrations(u)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ds.clear()
+			if err != nil {
+				t.Fatal(err)
+			}
+			return datastoreutil.NewValidator(ds)
+		}
+
+		// test that migrations work & things work with them
+		datastoretest.Test(t, f)
+	}
+
+	if pg := os.Getenv("POSTGRES_URL"); pg != "" {
+		u, err := url.Parse(pg)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		both(u)
+	}
+
+	if mysql := os.Getenv("MYSQL_URL"); mysql != "" {
+		u, err := url.Parse(mysql)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		both(u)
+	}
 }