func Test_GET_LastWatchedList_OK(t *testing.T) { db, mock, err := sqlmock.New() if err != nil { t.Fatal(err) } userID := int64(1) expect := LastWatchedList{ {userID, int64(1), 2, 3}, {userID, int64(2), 4, 5}, } s := "SELECT Series_ID, Session, Episode FROM %v" q := fmt.Sprintf(s, LastWatchedTable) rows := sqlmock.NewRows([]string{ "Series_ID", "Session", "Episode", }) for _, s := range expect { rows.AddRow(s.SeriesID, s.Session, s.Episode) } mock.ExpectQuery(q).WillReturnRows(rows) sessionStore := smem.NewStore() expires := time.Now().Add(1 * time.Hour) tmp := strconv.FormatInt(userID, 10) session, err := sessionStore.NewSession(tmp, expires) if err != nil { t.Fatal(err) } app := AppCtx{ DB: db, } srv := gin.New() signedIn := kauth.SignedIn(&sessionStore) h := NewAppHandler(app, LastWatchedListHandler) srv.GET("/", signedIn(h)) req := TestRequest{ Body: "", Handler: srv, Header: http.Header{}, } resp := req.SendWithToken("GET", "/", session.Token()) if 200 != resp.Code { t.Fatal("Expect 200 was", resp.Code) } expectResp := NewSuccessResponse(expect) err = EqualResponse(expectResp, resp.Body) if err != nil { t.Fatal(err) } }
func Test_PATCH_SeriesList_OK(t *testing.T) { db, mock, err := sqlmock.New() if err != nil { t.Fatal(err) } userID := int64(1) seriesID := int64(2) q := fmt.Sprintf("INSERT INTO %v", SeriesListTable) mock.ExpectExec(q). WithArgs(userID, seriesID). WillReturnResult(sqlmock.NewResult(0, 1)) app := AppCtx{ DB: db, } sessionStore := smem.NewStore() expires := time.Now().Add(1 * time.Hour) tmp := strconv.FormatInt(userID, 10) session, err := sessionStore.NewSession(tmp, expires) if err != nil { t.Fatal(err) } srv := gin.New() signedIn := kauth.SignedIn(&sessionStore) h := NewAppHandler(app, AppendSeriesListHandler) srv.POST("/", signedIn(h)) body := ` { "Data": { "UserID": 1, "SeriesID": 2 } } ` req := TestRequest{ Body: body, Handler: srv, Header: http.Header{}, } resp := req.SendWithToken("POST", "/", session.Token()) if 200 != resp.Code { t.Fatal("Expect 200 was", resp.Code) } expect := NewSuccessResponse("") err = EqualResponse(expect, resp.Body) if err != nil { t.Fatal(err) } }
func main() { app, err := sj.NewApp("sj") handleErr(err) store := smem.NewStore() userStore := sj.NewUserStore(app.DB) signedIn := kauth.SignedIn(&store) signIn := kauth.SignIn(&store, userStore) newSeries := sj.NewAppHandler(app, sj.NewSeriesHandler) readSeries := sj.NewAppHandler(app, sj.ReadSeriesHandler) removeSeries := sj.NewAppHandler(app, sj.RemoveSeriesHandler) appendSeries := sj.NewAppHandler(app, sj.AppendSeriesListHandler) readSeriesList := sj.NewAppHandler(app, sj.ReadSeriesListHandler) lastWatchedList := sj.NewAppHandler(app, sj.LastWatchedListHandler) updatedLastWatched := sj.NewAppHandler(app, sj.UpdateLastWatchedHandler) newUser := sj.NewAppHandler(app, sj.NewUserHandler) publicDir := app.Specs.PublicDir htmlDir := path.Join(publicDir, "html") srv := gin.New() srv.POST("/Series", signedIn(newSeries)) srv.GET("/Series/:id", signedIn(readSeries)) srv.DELETE("/Series/:id", signedIn(removeSeries)) srv.GET("/SignIn/:name/:password", signIn) srv.POST("/User", newUser) srv.PATCH("/AppendSeries", signedIn(appendSeries)) srv.GET("/ReadSeriesList", signedIn(readSeriesList)) srv.POST("/LastWatched", signedIn(updatedLastWatched)) srv.GET("/LastWatchedList", signedIn(lastWatchedList)) srv.Use(ginstatic.Serve("/", ginstatic.LocalFile(htmlDir, false))) srv.Static("/public", publicDir) srv.Static("/images", app.Specs.ImageDir) addr := fmt.Sprintf("%v:%v", app.Specs.Host, app.Specs.Port) err = srv.Run(addr) handleErr(err) os.Exit(0) }
func main() { gumspecs.AppName = "tasks" srv := gumspecs.ReadHTTPServer() mysql := gumspecs.ReadMySQL() sqlDB, err := mysql.DB() if err != nil { log.Fatal(err) } db := &gorp.DbMap{ Db: sqlDB, Dialect: gorp.MySQLDialect{ "InnonDB", "UTF8", }, } router := gin.New() s2tore := smem.NewStore() signedIn := gumauth.SignedIn(&s2tore) tasksAPI := router.Group("/v1/tasks") { g := gumwrap.Gorp tasksAPI.GET("/", signedIn(g(tasks.ReadAll, db))) tasksAPI.GET("/:id", signedIn(g(tasks.ReadOne, db))) tasksAPI.POST("/", signedIn(g(tasks.Create, db))) tasksAPI.PUT("/:id", signedIn(g(tasks.Update, db))) tasksAPI.DELETE("/:id", signedIn(g(tasks.Delete, db))) } uStore := gumauth.SQLUserStore{db.Db} router.POST("/signin/:name/:password", gumauth.SignIn(&s2tore, uStore)) router.POST("/signup", gumauth.CreateUserSQL(db.Db)) router.Run(srv.String()) }
func Test_POST_UpdateLastWatched_OK(t *testing.T) { db, mock, err := sqlmock.New() if err != nil { t.Fatal(err) } userID := int64(1) seriesID := int64(2) lastSession := 3 lastEpisode := 4 q := fmt.Sprintf("REPLACE INTO %v", LastWatchedTable) mock.ExpectExec(q). WithArgs(userID, seriesID, lastSession, lastEpisode). WillReturnResult(sqlmock.NewResult(0, 1)) sessionStore := smem.NewStore() expires := time.Now().Add(1 * time.Hour) tmp := strconv.FormatInt(userID, 10) session, err := sessionStore.NewSession(tmp, expires) if err != nil { t.Fatal(err) } app := AppCtx{ DB: db, } srv := gin.New() signedIn := kauth.SignedIn(&sessionStore) lastWatchedHandler := NewAppHandler(app, UpdateLastWatchedHandler) srv.POST("/", signedIn(lastWatchedHandler)) body := ` { "Data": { "SeriesID": 2, "Session": 3, "Episode": 4 } } ` req := TestRequest{ Body: body, Handler: srv, Header: http.Header{}, } resp := req.SendWithToken("POST", "/", session.Token()) if 200 != resp.Code { t.Fatal("Expect 200 was", resp.Code) } expect := NewSuccessResponse(LastWatched{ UserID: userID, SeriesID: seriesID, Session: lastSession, Episode: lastEpisode, }) err = EqualResponse(expect, resp.Body) if err != nil { t.Fatal(err) } }
func Test_ReadSeriesListHandler_OK(t *testing.T) { db, mock, err := sqlmock.New() if err != nil { t.Fatal(err) } userID := int64(1) expect := SeriesList{ {0, "Mr. Robot", "robot.png"}, {1, "Narcos", "narcos.png"}, } m := `SELECT series.ID as ID, series.Title as Title, series.Image as Image FROM %v as series, %v as list` q := fmt.Sprintf(m, SeriesTable, SeriesListTable) rows := sqlmock.NewRows([]string{"ID", "Title", "Image"}) for _, s := range expect { rows.AddRow(s.ID, s.Title, s.Image) } mock.ExpectQuery(q).WillReturnRows(rows) app := AppCtx{ DB: db, } sessionStore := smem.NewStore() expires := time.Now().Add(1 * time.Hour) tmp := strconv.FormatInt(userID, 10) session, err := sessionStore.NewSession(tmp, expires) if err != nil { t.Fatal(err) } srv := gin.New() readSeriesHandler := NewAppHandler(app, ReadSeriesListHandler) signedIn := kauth.SignedIn(&sessionStore) h := signedIn(readSeriesHandler) srv.GET("/", h) body := ` { "Data": [ { "ID": 0, "Title": "Mr. Robot", "Image": "robot.png" }, { "ID": 1, "Title": "Narcos", "Image": "narcos.png" } ] } ` req := TestRequest{ Body: body, Handler: srv, Header: http.Header{}, } resp := req.SendWithToken("GET", "/", session.Token()) if 200 != resp.Code { t.Fatal("Expect 200 was", resp.Code) } expectResp := NewSuccessResponse(expect) err = EqualResponse(expectResp, resp.Body) if err != nil { t.Fatal(err) } }