cmd/transfer_test: add postgres to transfer tests

Also converted function commandLookup in cmd/transfer to method

cmd/transfer.go

@@ -153,7 +153,7 @@ func run() {
 				atomic.AddUint64(&dstCounter, 1)
 				go func(cmd cList) {
 					defer wgDst.Done()
-					commandLookup(cmd, pipe, queue)
+					cmd.commandLookup(pipe, queue)
 				}(item)
 				if atomic.CompareAndSwapUint64(&dstCounter, uint64(workers), 0) {
 					wgDst.Wait()
@@ -352,7 +352,7 @@ func getCommandList() commandsList {
 	return result
 }
 
-func commandLookup(item cList, pipe chan []byte, queue chan cList) {
+func (item cList) commandLookup(pipe chan []byte, queue chan cList) {
 	defer func() {
 		if r := recover(); r != nil {
 			mem := strings.Contains(fmt.Sprintf("%v", r), "runtime error: invalid memory address")

cmd/transfer_test.go

@@ -44,12 +44,25 @@ import (
 var (
 	testWork         bool
 	testDir          string
-	src              *exec.Cmd
+	srcCmd           *exec.Cmd
-	dst              *exec.Cmd
+	dstCmd           *exec.Cmd
 	sessionStartTime int64
 	commandsN        int
+	srcPostgres      string
+	dstPostgres      string
+	dst              user
+	src              user
 )
 
+type user struct {
+	url       string
+	username  string
+	pass      string
+	db        string
+	httpLog   string
+	stderrLog io.Writer
+}
+
 func init() {
 	flag.StringVar(&srcURL, "src-url", "http://localhost:55555", "source url ")
 	flag.StringVar(&srcUser, "src-user", "tester", "source username")
@@ -60,15 +73,19 @@ func init() {
 	flag.IntVar(&workers, "workers", 10, "max number of concurrent requests")
 	flag.IntVar(&commandsN, "number", 200, "number of commmands to use for test")
 	flag.BoolVar(&testWork, "testwork", false, "don't remove sqlite db and server log when done and print location")
+	flag.StringVar(&srcPostgres, "src-postgres-uri", "", "postgres uri to use for postgres tests")
+	flag.StringVar(&dstPostgres, "dst-postgres-uri", "", "postgres uri to use for postgres tests")
+
 }
 
-func startServer(cmd string, args []string, writer io.Writer) (p *exec.Cmd, err error) {
+func (u user) startServer() (p *exec.Cmd, err error) {
 	cwd, err := os.Getwd()
 	if err != nil {
 		check(err)
 	}
 	parent := filepath.Dir(cwd)
-
+	cmd := "go"
+	args := []string{"run", ".", "-a", u.url, "--db", u.db, "--log", u.httpLog}
 	if cmd, err = exec.LookPath(cmd); err == nil {
 		var procAttr os.ProcAttr
 		procAttr.Dir = parent
@@ -77,59 +94,52 @@ func startServer(cmd string, args []string, writer io.Writer) (p *exec.Cmd, err
 		p := exec.Command(cmd, args...)
 		p.Dir = parent
 		p.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
-		p.Stderr = writer
+		p.Stderr = u.stderrLog
 		return p, nil
 	}
 	return nil, err
 }
 
-func startSrc() (*exec.Cmd, error) {
+func setup(srcDB string, dstDB string) {
-	srcDB := filepath.Join(testDir, "src.db")
-	srcLog := filepath.Join(testDir, "src-server.log")
 	srcErr := filepath.Join(testDir, "src-stderr.log")
-	srcArgs := []string{"run", ".", "-a", srcURL, "--db", srcDB, "--log", srcLog}
+	srcStderrLog, err := os.Create(srcErr)
-	f, err := os.Create(srcErr)
 	check(err)
-	return startServer("go", srcArgs, f)
-}
 
-func startDst() (*exec.Cmd, error) {
+	src = user{
-	dstDB := filepath.Join(testDir, "dst.db")
+		url:       srcURL,
-	dstLog := filepath.Join(testDir, "dst-server.log")
+		username:  srcUser,
-	srcErr := filepath.Join(testDir, "dst-stderr.log")
+		pass:      srcPass,
-	dstArgs := []string{"run", ".", "-a", dstURL, "--db", dstDB, "--log", dstLog}
+		db:        srcDB,
-	f, err := os.Create(srcErr)
+		httpLog:   filepath.Join(testDir, "src-server.log"),
-	check(err)
+		stderrLog: srcStderrLog,
-	return startServer("go", dstArgs, f)
-
-}
-
-func TestMain(m *testing.M) {
-	flag.Parse()
-
-	defer cleanup()
-
-	var err error
-	testDir, err = ioutil.TempDir("", "bashhub-server-test-")
-	check(err)
-	if testWork {
-		log.Println("TESTWORK=", testDir)
 	}
 
-	src, err = startSrc()
+	dstErr := filepath.Join(testDir, "dst-stderr.log")
-	check(err)
+	dstStderrLog, err := os.Create(dstErr)
-	err = src.Start()
 	check(err)
 
-	dst, err = startDst()
+	dst = user{
+		url:       dstURL,
+		username:  dstUser,
+		pass:      dstPass,
+		db:        dstDB,
+		httpLog:   filepath.Join(testDir, "dst-server.log"),
+		stderrLog: dstStderrLog,
+	}
+
+	srcCmd, err = src.startServer()
 	check(err)
-	err = dst.Start()
+	err = srcCmd.Start()
 	check(err)
 
+	dstCmd, err = dst.startServer()
+	check(err)
+	err = dstCmd.Start()
+	check(err)
 	tries := 0
 
 	for {
-		if ping(srcURL) == nil && ping(dstURL) == nil {
+		if src.ping() == nil && dst.ping() == nil {
 			break
 		}
 		tries++
@@ -139,25 +149,49 @@ func TestMain(m *testing.M) {
 		time.Sleep(2 * time.Second)
 	}
 
-	createUser(srcURL, srcUser, srcPass)
+	src.createUser()
-	createUser(dstURL, dstUser, dstPass)
+	dst.createUser()
-
-	m.Run()
 }
 
-func ping(u string) error {
+func TestMain(m *testing.M) {
-	_, err := http.Get(fmt.Sprintf("%v/ping", u))
+	flag.Parse()
+	var err error
+	testDir, err = ioutil.TempDir("", "bashhub-server-test-")
+	check(err)
+	if testWork {
+		log.Println("TESTWORK=", testDir)
+	}
+	defer cleanup()
+	setup(filepath.Join(testDir, "src.db"), filepath.Join(testDir, "dst.db"))
+	m.Run()
+
+	if srcPostgres != "" && dstPostgres != "" {
+		log.SetOutput(os.Stderr)
+		log.Print("postgres tests")
+		cleanup()
+		testDir, err = ioutil.TempDir("", "bashhub-server-test-")
+		check(err)
+		if testWork {
+			log.Println("TESTWORK=", testDir)
+		}
+		setup(srcPostgres, dstPostgres)
+		m.Run()
+	}
+}
+
+func (u user) ping() error {
+	_, err := http.Get(fmt.Sprintf("%v/ping", u.url))
 	if err != nil {
 		return err
 	}
 	return nil
 }
 
-func createUser(u string, user string, pass string) {
+func (u user) createUser() {
 	auth := map[string]interface{}{
 		"email":    "foo@gmail.com",
-		"Username": user,
+		"Username": u.username,
-		"password": pass,
+		"password": u.pass,
 	}
 
 	payloadBytes, err := json.Marshal(auth)
@@ -165,8 +199,8 @@ func createUser(u string, user string, pass string) {
 		log.Fatal(err)
 	}
 	body := bytes.NewReader(payloadBytes)
-	u = fmt.Sprintf("%v/api/v1/user", u)
+	uri := fmt.Sprintf("%v/api/v1/user", u.url)
-	req, err := http.NewRequest("POST", u, body)
+	req, err := http.NewRequest("POST", uri, body)
 
 	req.Header.Set("Content-Type", "application/json")
 	resp, err := http.DefaultClient.Do(req)
@@ -207,7 +241,7 @@ func commandInsert() {
 			tc.Uuid = uid.String()
 			tc.ExitStatus = 0
 			tc.SystemName = "system"
-			tc.SessionID = "1000"
+			tc.ProcessId = 1000
 			tc.User.Username = srcUser
 			tc.ProcessStartTime = sessionStartTime
 
@@ -275,10 +309,10 @@ func getStatus(t *testing.T, u string, token string) internal.Status {
 
 func cleanup() {
 	defer func() {
-		if err := syscall.Kill(-dst.Process.Pid, syscall.SIGKILL); err != nil {
+		if err := syscall.Kill(-srcCmd.Process.Pid, syscall.SIGKILL); err != nil {
 			log.Println("failed to kill: ", err)
 		}
-		if err := syscall.Kill(-src.Process.Pid, syscall.SIGKILL); err != nil {
+		if err := syscall.Kill(-dstCmd.Process.Pid, syscall.SIGKILL); err != nil {
 			log.Println("failed to kill: ", err)
 		}
 	}()

scripts/test_postgres.sh

@@ -18,12 +18,12 @@
 
 set -eou pipefail
 
-CONTAINER="bashhub-postgres-test"
+CONTAINER_1="bashhub-postgres-test"
 
-docker run -d --rm --name ${CONTAINER} -p 5444:5432 postgres
+docker run -d --rm --name ${CONTAINER_1} -p 5444:5432 postgres
 
 
-until [ "$(docker exec bashhub-postgres-test pg_isready \
+until [ "$(docker exec ${CONTAINER_1} pg_isready \
           -p 5432 -h localhost -U postgres -d postgres)" == "localhost:5432 - accepting connections" ]; do
     sleep 0.1;
 done;
@@ -31,4 +31,31 @@ done;
 go test github.com/nicksherron/bashhub-server/internal \
   -postgres-uri "postgres://postgres:@localhost:5444?sslmode=disable"
 
-docker stop -t 0 ${CONTAINER} & docker wait ${CONTAINER}
+docker stop -t 0 ${CONTAINER_1} & docker wait ${CONTAINER_1}
+
+
+CONTAINER_2="bashhub-postgres-test-1"
+CONTAINER_3="bashhub-postgres-test-2"
+
+
+docker run -d --rm --name ${CONTAINER_2} -p 5445:5432 postgres
+docker run -d --rm --name ${CONTAINER_3} -p 5446:5432 postgres
+
+until [ "$(docker exec ${CONTAINER_2} pg_isready \
+          -p 5432 -h localhost -U postgres -d postgres)" == "localhost:5432 - accepting connections" ]; do
+    sleep 0.1;
+done;
+
+
+until [ "$(docker exec ${CONTAINER_3} pg_isready \
+          -p 5432 -h localhost -U postgres -d postgres)" == "localhost:5432 - accepting connections" ]; do
+    sleep 0.1;
+done;
+
+
+go test github.com/nicksherron/bashhub-server/cmd \
+ -src-postgres-uri "postgres://postgres:@localhost:5445?sslmode=disable" \
+ -dst-postgres-uri "postgres://postgres:@localhost:5446?sslmode=disable"
+
+docker stop -t 0 ${CONTAINER_2} & docker wait ${CONTAINER_2}
+docker stop -t 0 ${CONTAINER_3} & docker wait ${CONTAINER_3}