added ctx to datastore and improve mock (#329)

Added ctx to datastore and improved mock

api/server/apps_create.go

@@ -41,7 +41,7 @@ func (s *Server) handleAppCreate(c *gin.Context) {
 		return
 	}
 
-	_, err = Api.Datastore.InsertApp(wapp.App)
+	_, err = Api.Datastore.InsertApp(ctx, wapp.App)
 	if err != nil {
 		log.WithError(err).Errorln(models.ErrAppsCreate)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrAppsCreate))

api/server/apps_delete.go

@@ -15,7 +15,7 @@ func handleAppDelete(c *gin.Context) {
 
 	appName := c.Param("app")
 
-	routes, err := Api.Datastore.GetRoutesByApp(appName, &models.RouteFilter{})
+	routes, err := Api.Datastore.GetRoutesByApp(ctx, appName, &models.RouteFilter{})
 	if err != nil {
 		log.WithError(err).Debug(models.ErrAppsRemoving)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrAppsRemoving))
@@ -28,7 +28,7 @@ func handleAppDelete(c *gin.Context) {
 		return
 	}
 
-	if err := Api.Datastore.RemoveApp(appName); err != nil {
+	if err := Api.Datastore.RemoveApp(ctx, appName); err != nil {
 		log.WithError(err).Debug(models.ErrAppsRemoving)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrAppsRemoving))
 		return

api/server/apps_get.go

@@ -14,15 +14,13 @@ func handleAppGet(c *gin.Context) {
 	log := common.Logger(ctx)
 
 	appName := c.Param("app")
-	app, err := Api.Datastore.GetApp(appName)
+	app, err := Api.Datastore.GetApp(ctx, appName)
 
-	if err != nil {
+	if err != nil && err != models.ErrAppsNotFound {
 		log.WithError(err).Error(models.ErrAppsGet)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrAppsGet))
 		return
-	}
-
-	if app == nil {
+	} else if app == nil {
 		log.WithError(err).Error(models.ErrAppsNotFound)
 		c.JSON(http.StatusNotFound, simpleError(models.ErrAppsNotFound))
 		return

api/server/apps_list.go

@@ -15,7 +15,7 @@ func handleAppList(c *gin.Context) {
 
 	filter := &models.AppFilter{}
 
-	apps, err := Api.Datastore.GetApps(filter)
+	apps, err := Api.Datastore.GetApps(ctx, filter)
 	if err != nil {
 		log.WithError(err).Debug(models.ErrAppsList)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrAppsList))

api/server/apps_test.go

@@ -85,17 +85,22 @@ func TestAppDelete(t *testing.T) {
 	tasks := mockTasksConduit()
 	defer close(tasks)
 
-	router := testRouter(&datastore.Mock{}, &mqs.Mock{}, testRunner(t), tasks)
-
 	for i, test := range []struct {
+		ds            models.Datastore
 		path          string
 		body          string
 		expectedCode  int
 		expectedError error
 	}{
-		{"/v1/apps", "", http.StatusNotFound, nil},
-		{"/v1/apps/myapp", "", http.StatusOK, nil},
+		{&datastore.Mock{}, "/v1/apps", "", http.StatusNotFound, nil},
+		{&datastore.Mock{
+			Apps: []*models.App{{
+				Name: "myapp",
+			}},
+		}, "/v1/apps/myapp", "", http.StatusOK, nil},
 	} {
+		router := testRouter(test.ds, &mqs.Mock{}, testRunner(t), tasks)
+
 		_, rec := routerRequest(t, router, "DELETE", test.path, nil)
 
 		if rec.Code != test.expectedCode {
@@ -203,9 +208,9 @@ func TestAppUpdate(t *testing.T) {
 
 		// success
 		{&datastore.Mock{
-			FakeApp: &models.App{
+			Apps: []*models.App{{
 				Name: "myapp",
-			},
+			}},
 		}, "/v1/apps/myapp", `{ "app": { "config": { "test": "1" } } }`, http.StatusOK, nil},
 	} {
 		router := testRouter(test.mock, &mqs.Mock{}, testRunner(t), tasks)

api/server/apps_update.go

@@ -28,7 +28,8 @@ func handleAppUpdate(c *gin.Context) {
 		return
 	}
 
-	app, err := Api.Datastore.UpdateApp(wapp.App)
+	wapp.App.Name = c.Param("app")
+	app, err := Api.Datastore.UpdateApp(ctx, wapp.App)
 	if err != nil {
 		log.WithError(err).Debug(models.ErrAppsUpdate)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrAppsUpdate))

api/server/routes_create.go

@@ -49,14 +49,12 @@ func (s *Server) handleRouteCreate(c *gin.Context) {
 		return
 	}
 
-	app, err := Api.Datastore.GetApp(wroute.Route.AppName)
-	if err != nil {
+	app, err := Api.Datastore.GetApp(ctx, wroute.Route.AppName)
+	if err != nil && err != models.ErrAppsNotFound {
 		log.WithError(err).Error(models.ErrAppsGet)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrAppsGet))
 		return
-	}
-
-	if app == nil {
+	} else if app == nil {
 		// Create a new application and add the route to that new application
 		newapp := &models.App{Name: wroute.Route.AppName}
 		if err := newapp.Validate(); err != nil {
@@ -65,7 +63,7 @@ func (s *Server) handleRouteCreate(c *gin.Context) {
 			return
 		}
 
-		app, err = Api.Datastore.InsertApp(newapp)
+		app, err = Api.Datastore.InsertApp(ctx, newapp)
 		if err != nil {
 			log.WithError(err).Error(models.ErrAppsCreate)
 			c.JSON(http.StatusInternalServerError, simpleError(models.ErrAppsCreate))
@@ -73,7 +71,7 @@ func (s *Server) handleRouteCreate(c *gin.Context) {
 		}
 	}
 
-	_, err = Api.Datastore.InsertRoute(wroute.Route)
+	_, err = Api.Datastore.InsertRoute(ctx, wroute.Route)
 	if err != nil {
 		log.WithError(err).Error(models.ErrRoutesCreate)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrRoutesCreate))

api/server/routes_delete.go

@@ -17,14 +17,14 @@ func (s *Server) handleRouteDelete(c *gin.Context) {
 	appName := c.Param("app")
 	routePath := path.Clean(c.Param("route"))
 
-	route, err := Api.Datastore.GetRoute(appName, routePath)
+	route, err := Api.Datastore.GetRoute(ctx, appName, routePath)
 	if err != nil || route == nil {
 		log.Error(models.ErrRoutesNotFound)
 		c.JSON(http.StatusNotFound, simpleError(models.ErrRoutesNotFound))
 		return
 	}
 
-	if err := Api.Datastore.RemoveRoute(appName, routePath); err != nil {
+	if err := Api.Datastore.RemoveRoute(ctx, appName, routePath); err != nil {
 		log.WithError(err).Debug(models.ErrRoutesRemoving)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrRoutesRemoving))
 		return

api/server/routes_get.go

@@ -18,15 +18,13 @@ func handleRouteGet(c *gin.Context) {
 	appName := c.Param("app")
 	routePath := path.Clean(c.Param("route"))
 
-	route, err := Api.Datastore.GetRoute(appName, routePath)
-	if err != nil {
+	route, err := Api.Datastore.GetRoute(ctx, appName, routePath)
+	if err != nil && err != models.ErrRoutesNotFound {
+
 		log.WithError(err).Error(models.ErrRoutesGet)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrRoutesGet))
 		return
-	}
-
-	if route == nil {
-		log.Error(models.ErrRoutesNotFound)
+	} else if route == nil {
 		c.JSON(http.StatusNotFound, simpleError(models.ErrRoutesNotFound))
 		return
 	}

api/server/routes_list.go

@@ -23,9 +23,9 @@ func handleRouteList(c *gin.Context) {
 	var routes []*models.Route
 	var err error
 	if app := c.Param("app"); app != "" {
-		routes, err = Api.Datastore.GetRoutesByApp(app, filter)
+		routes, err = Api.Datastore.GetRoutesByApp(ctx, app, filter)
 	} else {
-		routes, err = Api.Datastore.GetRoutes(filter)
+		routes, err = Api.Datastore.GetRoutes(ctx, filter)
 	}
 
 	if err != nil {

api/server/routes_test.go

@@ -64,22 +64,22 @@ func TestRouteDelete(t *testing.T) {
 	tasks := mockTasksConduit()
 	defer close(tasks)
 
-	router := testRouter(&datastore.Mock{
-		FakeRoutes: []*models.Route{
-			&models.Route{AppName: "a", Path: "/myroute"},
-		},
-	}, &mqs.Mock{}, testRunner(t), tasks)
-
 	for i, test := range []struct {
+		ds            models.Datastore
 		path          string
 		body          string
 		expectedCode  int
 		expectedError error
 	}{
-		{"/v1/apps/a/routes", "", http.StatusTemporaryRedirect, nil},
-		{"/v1/apps/a/routes/myroute", "", http.StatusOK, nil},
-		{"/v1/apps/a/routes/missing", "", http.StatusNotFound, nil},
+		{&datastore.Mock{}, "/v1/apps/a/routes", "", http.StatusTemporaryRedirect, nil},
+		{&datastore.Mock{}, "/v1/apps/a/routes/missing", "", http.StatusNotFound, nil},
+		{&datastore.Mock{
+			Routes: []*models.Route{
+				{Path: "/myroute", AppName: "a"},
+			},
+		}, "/v1/apps/a/routes/myroute", "", http.StatusOK, nil},
 	} {
+		router := testRouter(test.ds, &mqs.Mock{}, testRunner(t), tasks)
 		_, rec := routerRequest(t, router, "DELETE", test.path, nil)
 
 		if rec.Code != test.expectedCode {
@@ -175,22 +175,31 @@ func TestRouteUpdate(t *testing.T) {
 	tasks := mockTasksConduit()
 	defer close(tasks)
 
-	router := testRouter(&datastore.Mock{}, &mqs.Mock{}, testRunner(t), tasks)
-
 	for i, test := range []struct {
+		ds            models.Datastore
 		path          string
 		body          string
 		expectedCode  int
 		expectedError error
 	}{
 		// errors
-		{"/v1/apps/a/routes/myroute/do", ``, http.StatusBadRequest, models.ErrInvalidJSON},
-		{"/v1/apps/a/routes/myroute/do", `{}`, http.StatusBadRequest, models.ErrRoutesMissingNew},
+		{&datastore.Mock{}, "/v1/apps/a/routes/myroute/do", ``, http.StatusBadRequest, models.ErrInvalidJSON},
+		{&datastore.Mock{}, "/v1/apps/a/routes/myroute/do", `{}`, http.StatusBadRequest, models.ErrRoutesMissingNew},
 
 		// success
-		{"/v1/apps/a/routes/myroute/do", `{ "route": { "image": "iron/hello", "path": "/myroute" } }`, http.StatusOK, nil},
+		{&datastore.Mock{
+			Routes: []*models.Route{
+				{
+					AppName: "a",
+					Path:    "/myroute/do",
+				},
+			},
+		}, "/v1/apps/a/routes/myroute/do", `{ "route": { "image": "iron/hello", "path": "/myroute" } }`, http.StatusOK, nil},
 	} {
+		router := testRouter(test.ds, &mqs.Mock{}, testRunner(t), tasks)
+
 		body := bytes.NewBuffer([]byte(test.body))
+
 		_, rec := routerRequest(t, router, "PUT", test.path, body)
 
 		if rec.Code != test.expectedCode {

api/server/routes_update.go

@@ -43,7 +43,7 @@ func handleRouteUpdate(c *gin.Context) {
 		}
 	}
 
-	_, err = Api.Datastore.UpdateRoute(wroute.Route)
+	_, err = Api.Datastore.UpdateRoute(ctx, wroute.Route)
 	if err != nil {
 		log.WithError(err).Debug(models.ErrRoutesUpdate)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrRoutesUpdate))

api/server/runner.go

@@ -81,7 +81,7 @@ func (s *Server) handleRequest(c *gin.Context, enqueue models.Enqueue) {
 		path = c.Request.URL.Path
 	}
 
-	app, err := Api.Datastore.GetApp(appName)
+	app, err := Api.Datastore.GetApp(ctx, appName)
 	if err != nil || app == nil {
 		log.WithError(err).Error(models.ErrAppsNotFound)
 		c.JSON(http.StatusNotFound, simpleError(models.ErrAppsNotFound))
@@ -96,7 +96,7 @@ func (s *Server) handleRequest(c *gin.Context, enqueue models.Enqueue) {
 	}
 
 	log.WithFields(logrus.Fields{"app": appName, "path": path}).Debug("Finding route on datastore")
-	routes, err := s.loadroutes(models.RouteFilter{AppName: appName, Path: path})
+	routes, err := s.loadroutes(ctx, models.RouteFilter{AppName: appName, Path: path})
 	if err != nil {
 		log.WithError(err).Error(models.ErrRoutesList)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrRoutesList))
@@ -122,11 +122,11 @@ func (s *Server) handleRequest(c *gin.Context, enqueue models.Enqueue) {
 	c.JSON(http.StatusNotFound, simpleError(models.ErrRunnerRouteNotFound))
 }
 
-func (s *Server) loadroutes(filter models.RouteFilter) ([]*models.Route, error) {
+func (s *Server) loadroutes(ctx context.Context, filter models.RouteFilter) ([]*models.Route, error) {
 	resp, err := s.singleflight.do(
 		filter,
 		func() (interface{}, error) {
-			return Api.Datastore.GetRoutesByApp(filter.AppName, &filter)
+			return Api.Datastore.GetRoutesByApp(ctx, filter.AppName, &filter)
 		},
 	)
 	return resp.([]*models.Route), err

api/server/runner_async_test.go

@@ -35,10 +35,10 @@ func TestRouteRunnerAsyncExecution(t *testing.T) {
 	t.Skip()
 	tasks := mockTasksConduit()
 	ds := &datastore.Mock{
-		FakeApps: []*models.App{
+		Apps: []*models.App{
 			{Name: "myapp", Config: map[string]string{"app": "true"}},
 		},
-		FakeRoutes: []*models.Route{
+		Routes: []*models.Route{
 			{Type: "async", Path: "/myroute", AppName: "myapp", Image: "iron/hello", Config: map[string]string{"test": "true"}},
 			{Type: "async", Path: "/myerror", AppName: "myapp", Image: "iron/error", Config: map[string]string{"test": "true"}},
 			{Type: "async", Path: "/myroute/:param", AppName: "myapp", Image: "iron/hello", Config: map[string]string{"test": "true"}},

api/server/runner_test.go

@@ -26,7 +26,7 @@ func TestRouteRunnerGet(t *testing.T) {
 	tasks := mockTasksConduit()
 
 	router := testRouter(&datastore.Mock{
-		FakeApps: []*models.App{
+		Apps: []*models.App{
 			{Name: "myapp", Config: models.Config{}},
 		},
 	}, &mqs.Mock{}, testRunner(t), tasks)
@@ -66,7 +66,7 @@ func TestRouteRunnerPost(t *testing.T) {
 	tasks := mockTasksConduit()
 
 	router := testRouter(&datastore.Mock{
-		FakeApps: []*models.App{
+		Apps: []*models.App{
 			{Name: "myapp", Config: models.Config{}},
 		},
 	}, &mqs.Mock{}, testRunner(t), tasks)
@@ -113,10 +113,10 @@ func TestRouteRunnerExecution(t *testing.T) {
 	go runner.StartWorkers(ctx, testRunner(t), tasks)
 
 	router := testRouter(&datastore.Mock{
-		FakeApps: []*models.App{
+		Apps: []*models.App{
 			{Name: "myapp", Config: models.Config{}},
 		},
-		FakeRoutes: []*models.Route{
+		Routes: []*models.Route{
 			{Path: "/myroute", AppName: "myapp", Image: "iron/hello", Headers: map[string][]string{"X-Function": {"Test"}}},
 			{Path: "/myerror", AppName: "myapp", Image: "iron/error", Headers: map[string][]string{"X-Function": {"Test"}}},
 		},

api/server/server.go

@@ -56,20 +56,20 @@ func New(ctx context.Context, ds models.Datastore, mq models.MessageQueue, r *ru
 		c.Set("ctx", ctx)
 		c.Next()
 	})
-	Api.primeCache()
+	Api.primeCache(ctx)
 
 	return Api
 }
 
-func (s *Server) primeCache() {
+func (s *Server) primeCache(ctx context.Context) {
 	logrus.Info("priming cache with known routes")
-	apps, err := s.Datastore.GetApps(nil)
+	apps, err := s.Datastore.GetApps(ctx, nil)
 	if err != nil {
 		logrus.WithError(err).Error("cannot prime cache - could not load application list")
 		return
 	}
 	for _, app := range apps {
-		routes, err := s.Datastore.GetRoutesByApp(app.Name, &models.RouteFilter{AppName: app.Name})
+		routes, err := s.Datastore.GetRoutesByApp(ctx, app.Name, &models.RouteFilter{AppName: app.Name})
 		if err != nil {
 			logrus.WithError(err).WithField("appName", app.Name).Error("cannot prime cache - could not load routes")
 			continue