Add full test for all APIs.

.github/workflows/test.yml

@@ -64,9 +64,9 @@ jobs:
         uses: actions/checkout@v3
       - name: Build image for platform
         run: |
-          docker build -t platform:latest -f Dockerfile . &&
-          docker tag platform:latest ossrs/srs-cloud:$SRS_TAG &&
-          docker tag platform:latest registry.cn-hangzhou.aliyuncs.com/ossrs/srs-cloud:$SRS_TAG &&
+          docker build -t platform:latest -f Dockerfile .
+          docker tag platform:latest ossrs/srs-cloud:$SRS_TAG
+          docker tag platform:latest registry.cn-hangzhou.aliyuncs.com/ossrs/srs-cloud:$SRS_TAG
           docker images
       - name: Build package
         run: |
@@ -75,30 +75,35 @@ jobs:
           du -sh build/*
       - name: Install package
         run: |
-          sudo bash build/srs-cloud/scripts/setup-ubuntu/install.sh --verbose &&
-          du -sh /usr/local/srs-cloud/*
+          sudo bash build/srs-cloud/scripts/setup-ubuntu/install.sh --verbose
+          echo "" && echo "/usr/local/srs-cloud/" && du -sh /usr/local/srs-cloud/*
+          echo "" && ls -lha /data /data/config
       - name: Check service
         run: |
-          # Wait for service ready.
+          echo "Wait for service ready."
           make -j -C test
-          ./test/srs-cloud.test -test.v -srs-log -endpoint http://localhost:2022 \
-              -wait-ready -check-api-secret=false \
-              -test.run TestApi_Empty
+          ./test/srs-cloud.test -test.v -endpoint http://localhost:2022 \
+              -srs-log=true -wait-ready=true -init-password=true \
+              -check-api-secret=false -test.run TestApi_Empty
           
-          echo "Record log of services."
-          docker ps -a
+          echo "Show service status."
           systemctl status srs-cloud
-          journalctl -u srs-cloud -f >journalctl.log 2>&1 & pid_journalctl=$!
-          docker logs -f srs-cloud >docker.log 2>&1 & pid_docker=$!
+          docker ps -a
+          
+          echo "Record log of services."
+          journalctl -u srs-cloud > journalctl.log
+          journalctl -u srs-cloud -f >>journalctl.log 2>&1 & pid_journalctl=$!
+          docker logs srs-cloud >docker.log
+          docker logs -f srs-cloud >>docker.log 2>&1 & pid_docker=$!
       - name: Test service
         run: |
           # We will handle the error by ourselves.
           set +e
           
           SRS_PLATFORM_SECRET=$(docker exec srs-cloud redis-cli hget SRS_PLATFORM_SECRET token)
-          ./test/srs-cloud.test -test.v -wait-ready -srs-log -endpoint http://localhost:2022 \
-              -wait-ready -check-api-secret=true -api-secret=$SRS_PLATFORM_SECRET \
-              -init-password
+          ./test/srs-cloud.test -test.v -wait-ready -endpoint http://localhost:2022 \
+              -srs-log=true -wait-ready=true -init-password=false \
+              -check-api-secret=true -api-secret=$SRS_PLATFORM_SECRET \
           ret=$?; echo "Test with ${SRS_PLATFORM_SECRET} result: $ret"
           
           echo "Stop service"

DEVELOPER.md

@@ -5,22 +5,19 @@ resources, and ports, as well as development on Mac or using Docker.
 
 ## Develop All in macOS
 
-Start redis by docker:
-
-```bash
-docker run --name redis --rm -it -v $HOME/db/redis:/data -p 6379:6379 -d redis
-```
-
-Start SRS in macOS:
+Start redis and SRS by docker:
 
 ```bash
+docker run --name redis --rm -it -v $HOME/db/redis:/data -p 6379:6379 -d redis &&
 docker run --name srs --rm -it \
     -v $(pwd)/platform/containers/conf/srs.release-mac.conf:/usr/local/srs/conf/srs.conf \
     -v $(pwd)/platform/containers/objs/nginx:/usr/local/srs/objs/nginx \
     -p 1935:1935/tcp -p 1985:1985/tcp -p 8080:8080/tcp -p 8000:8000/udp -p 10080:10080/udp \
     -d ossrs/srs:5
 ```
 
+> Note: Stop service by `docker rm -f redis srs`
+
 > Note: Also, you can run SRS by `(cd platform && ~/git/srs/trunk/objs/srs -c containers/conf/srs.release-local.conf)`
 
 Run the platform backend, or run in GoLand:

platform/service.go

@@ -277,11 +277,11 @@ func handleDockerHTTPService(ctx context.Context, handler *http.ServeMux) error
 		if err := func() error {
 			ohttp.WriteData(ctx, w, r, &struct {
 				Secret     bool   `json:"secret"`
-				HTTPS      string `json:"https"`
+				HTTPS      bool `json:"https"`
 				MgmtDocker bool   `json:"mgmtDocker"`
 			}{
 				Secret:     os.Getenv("SRS_PLATFORM_SECRET") != "",
-				HTTPS:      os.Getenv("SRS_HTTPS"),
+				HTTPS:      os.Getenv("SRS_HTTPS") != "off",
 				MgmtDocker: true,
 			})
 			return nil

scripts/setup-ubuntu/install.sh

@@ -118,12 +118,9 @@ fi
 
 echo "Start to install files"
 mkdir -p ${SRS_HOME} ${DATA_HOME} && rm -rf ${SRS_HOME}/* &&
-files=$(find . -type f |grep -vE '(.git|.idea|.run|node_modules|nginx/html/live)') &&
-files="${files} $(find . -name .gitkeep)"
-for file in $files; do
-    mkdir -p ${SRS_HOME}/$(dirname ${file}) &&
-    cp $file ${SRS_HOME}/${file}
-done
+cp -r ${WORK_DIR}/usr ${SRS_HOME}/usr &&
+cp -r ${WORK_DIR}/mgmt ${SRS_HOME}/mgmt &&
+cp -r ${WORK_DIR}/LICENSE ${SRS_HOME}/LICENSE
 ret=$?; if [[ $ret -ne 0 ]]; then echo "Copy files failed, ret=$ret"; exit $ret; fi
 echo "Install files at ${SRS_HOME} ok"
 

test/api_test.go

@@ -2,10 +2,10 @@ package main
 
 import (
 	"context"
-	"errors"
 	"testing"
 	"time"
 
+	"github.com/ossrs/go-oryx-lib/errors"
 	"github.com/ossrs/go-oryx-lib/logger"
 )
 
@@ -14,19 +14,29 @@ func TestApi_Empty(t *testing.T) {
 	logger.Tf(ctx, "test done")
 }
 
+func TestApi_Ready(t *testing.T) {
+	ctx, cancel := context.WithTimeout(logger.WithContext(context.Background()), time.Duration(*srsTimeout)*time.Millisecond)
+	defer cancel()
+
+	if err := waitForServiceReady(ctx); err != nil {
+		t.Errorf("Fail for err %+v", err)
+	} else {
+		logger.Tf(ctx, "test done")
+	}
+}
+
 func TestApi_QuerySecret(t *testing.T) {
 	ctx, cancel := context.WithTimeout(logger.WithContext(context.Background()), time.Duration(*srsTimeout)*time.Millisecond)
-	logger.Tf(ctx, "TestApi_QuerySecret with %v", options())
+	defer cancel()
 
 	var r0 error
 	defer func(ctx context.Context) {
 		if err := filterTestError(ctx.Err(), r0); err != nil {
 			t.Errorf("Fail for err %+v", err)
 		} else {
-			logger.Tf(ctx, "test done with err %+v", err)
+			logger.Tf(ctx, "test done")
 		}
 	}(ctx)
-	defer cancel()
 
 	var publishSecret string
 	if err := apiRequest(ctx, "/terraform/v1/hooks/srs/secret/query", nil, &struct {
@@ -39,3 +49,126 @@ func TestApi_QuerySecret(t *testing.T) {
 		r0 = errors.New("empty publish secret")
 	}
 }
+
+func TestApi_LoginByPassword(t *testing.T) {
+	ctx, cancel := context.WithTimeout(logger.WithContext(context.Background()), time.Duration(*srsTimeout)*time.Millisecond)
+	defer cancel()
+
+	var r0 error
+	defer func(ctx context.Context) {
+		if err := filterTestError(ctx.Err(), r0); err != nil {
+			t.Errorf("Fail for err %+v", err)
+		} else {
+			logger.Tf(ctx, "test done")
+		}
+	}(ctx)
+
+	var token string
+	if err := apiRequest(ctx, "/terraform/v1/mgmt/login", &struct {
+		Password string `json:"password"`
+	}{
+		Password: *systemPassword,
+	}, &struct {
+		Token *string `json:"token"`
+	}{
+		Token: &token,
+	}); err != nil {
+		r0 = err
+	} else if token == "" {
+		r0 = errors.New("empty token")
+	}
+}
+
+func TestApi_BootstrapQueryEnvs(t *testing.T) {
+	ctx, cancel := context.WithTimeout(logger.WithContext(context.Background()), time.Duration(*srsTimeout)*time.Millisecond)
+	defer cancel()
+
+	var r0 error
+	defer func(ctx context.Context) {
+		if err := filterTestError(ctx.Err(), r0); err != nil {
+			t.Errorf("Fail for err %+v", err)
+		} else {
+			logger.Tf(ctx, "test done")
+		}
+	}(ctx)
+
+	res := struct {
+		Secret     bool `json:"secret"`
+		HTTPS      bool `json:"https"`
+		MgmtDocker bool `json:"mgmtDocker"`
+	}{}
+	if err := apiRequest(ctx, "/terraform/v1/mgmt/envs", nil, &res); err != nil {
+		r0 = err
+	} else if !res.Secret || !res.HTTPS || !res.MgmtDocker {
+		r0 = errors.Errorf("invalid res %v", res)
+	}
+}
+
+func TestApi_BootstrapQueryInit(t *testing.T) {
+	ctx, cancel := context.WithTimeout(logger.WithContext(context.Background()), time.Duration(*srsTimeout)*time.Millisecond)
+	defer cancel()
+
+	var r0 error
+	defer func(ctx context.Context) {
+		if err := filterTestError(ctx.Err(), r0); err != nil {
+			t.Errorf("Fail for err %+v", err)
+		} else {
+			logger.Tf(ctx, "test done")
+		}
+	}(ctx)
+
+	res := struct {
+		Init bool `json:"init"`
+	}{}
+	if err := apiRequest(ctx, "/terraform/v1/mgmt/init", nil, &res); err != nil {
+		r0 = err
+	} else if !res.Init {
+		r0 = errors.Errorf("invalid init %v", res)
+	}
+}
+
+func TestApi_BootstrapQueryCheck(t *testing.T) {
+	ctx, cancel := context.WithTimeout(logger.WithContext(context.Background()), time.Duration(*srsTimeout)*time.Millisecond)
+	defer cancel()
+
+	var r0 error
+	defer func(ctx context.Context) {
+		if err := filterTestError(ctx.Err(), r0); err != nil {
+			t.Errorf("Fail for err %+v", err)
+		} else {
+			logger.Tf(ctx, "test done")
+		}
+	}(ctx)
+
+	res := struct {
+		Upgrading bool `json:"upgrading"`
+	}{}
+	if err := apiRequest(ctx, "/terraform/v1/mgmt/check", nil, &res); err != nil {
+		r0 = err
+	} else if res.Upgrading {
+		r0 = errors.Errorf("invalid check %v", res)
+	}
+}
+
+func TestApi_BootstrapQueryVersions(t *testing.T) {
+	ctx, cancel := context.WithTimeout(logger.WithContext(context.Background()), time.Duration(*srsTimeout)*time.Millisecond)
+	defer cancel()
+
+	var r0 error
+	defer func(ctx context.Context) {
+		if err := filterTestError(ctx.Err(), r0); err != nil {
+			t.Errorf("Fail for err %+v", err)
+		} else {
+			logger.Tf(ctx, "test done")
+		}
+	}(ctx)
+
+	res := struct {
+		Version string `json:"version"`
+	}{}
+	if err := apiRequest(ctx, "/terraform/v1/mgmt/versions", nil, &res); err != nil {
+		r0 = err
+	} else if res.Version == "" {
+		r0 = errors.Errorf("invalid version %v", res)
+	}
+}