ziggi/mstore
1
0
Fork 0
Code Pull Requests Actions Packages Projects Releases Wiki Activity

working commit

Browse Source
This commit is contained in:
Олег Бородин
2026-01-30 18:37:35 +02:00
parent c4172ac1f8
commit 57f9775280
2 changed files with 196 additions and 229 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/server/server.go
+21 -4
View File
@@ -1,16 +1,12 @@
package server package server
import ( import (
//"io/ioutil"
"os" "os"
"os/signal" "os/signal"
"os/user" "os/user"
//"os/user"
"path/filepath" "path/filepath"
"strconv" "strconv"
//"sync"
"syscall" "syscall"
//"time"
"mstore/app/config" "mstore/app/config"
"mstore/app/handler" "mstore/app/handler"
@@ -42,6 +38,27 @@ func (srv *Server) Handler() *handler.Handler {
return srv.hand return srv.hand
} }
func (srv *Server) Service() *service.Service {
return srv.svc
}
func (srv *Server) SetLogdir(dir string) {
srv.conf.Logpath = dir
}
func (srv *Server) SetRundir(dir string) {
srv.conf.Runpath = dir
}
func (srv *Server) SetDatadir(dir string) {
srv.conf.Database.Basepath = dir
srv.conf.Storage.Basepath = dir
}
func (srv *Server) SetPort(port int64) {
srv.conf.Service.Port = port
}
func (srv *Server) Configure() error { func (srv *Server) Configure() error {
var err error var err error
srv.logg.Infof("Configuration server") srv.logg.Infof("Configuration server")
test/file_test.go
+175 -225
View File
@@ -16,236 +16,186 @@ import (
"mstore/app/server" "mstore/app/server"
) )
func TestFileLife(t *testing.T) { func TestFileOperations(t *testing.T) {
var tester FileTester
tester.MakeServer(t)
tester.TestServiceHello(t)
tester.TestPutFile(t)
tester.TestFileExists(t)
tester.TestGetFile(t)
tester.TestDeleteFile(t)
tester.TestFileNotExists(t)
}
type FileTester struct {
srv *server.Server
}
func (tester *FileTester) MakeServer(t *testing.T) {
var err error var err error
fmt.Printf("=== MakeServer ===\n") fmt.Printf("=== MakeServer ===\n")
srv, err := server.NewServer() srv, err := server.NewServer()
require.NoError(t, err) require.NoError(t, err)
err = srv.Configure() {
require.NoError(t, err) err = srv.Configure()
require.NoError(t, err)
err = srv.Build() tmpdir := t.TempDir()
require.NoError(t, err) srv.SetDatadir(tmpdir)
srv.SetLogdir(tmpdir)
srv.SetRundir(tmpdir)
tester.srv = srv err = srv.Build()
} require.NoError(t, err)
}
func (tester *FileTester) TestPutFile(t *testing.T) {
var err error {
fmt.Printf("=== PutFile ===\n")
fmt.Printf("=== PutFile ===\n") reqPath := `/v3/api/file/foo/bare`
routePath := `/v3/api/file/{filepath}`
srv := tester.srv
require.NotNil(t, srv) rout := router.NewRouter()
hand := srv.Handler()
reqPath := `/v3/api/file/foo/bare` require.NotNil(t, hand)
routePath := `/v3/api/file/{filepath}`
rout.Put(routePath, hand.PutFile)
rout := router.NewRouter()
hand := srv.Handler() datasize := 16
require.NotNil(t, hand) filedata := make([]byte, datasize)
_, err = rand.Read(filedata)
rout.Put(routePath, hand.PutFile) require.NoError(t, err)
datasize := 16 filedata = []byte(hex.EncodeToString(filedata))
filedata := make([]byte, datasize)
_, err = rand.Read(filedata) source := bytes.NewReader(filedata)
require.NoError(t, err)
request, err := http.NewRequest("PUT", reqPath, source)
filedata = []byte(hex.EncodeToString(filedata)) require.NoError(t, err)
source := bytes.NewReader(filedata) request.Header.Set("Content-Length", fmt.Sprintf("%d", datasize))
request.Header.Set("Content-Type", "application/octet-stream")
request, err := http.NewRequest("PUT", reqPath, source)
require.NoError(t, err) recorder := httptest.NewRecorder()
rout.ServeHTTP(recorder, request)
request.Header.Set("Content-Length", fmt.Sprintf("%d", datasize)) require.Equal(t, http.StatusOK, recorder.Code)
request.Header.Set("Content-Type", "application/octet-stream")
fmt.Printf("Response code: %d\n", recorder.Code)
recorder := httptest.NewRecorder()
rout.ServeHTTP(recorder, request) bodyReader := recorder.Body
require.Equal(t, http.StatusOK, recorder.Code) bodyBytes, err := io.ReadAll(bodyReader)
fmt.Printf("Response code: %d\n", recorder.Code) fmt.Printf("Response body: %s\n", string(bodyBytes))
}
bodyReader := recorder.Body {
bodyBytes, err := io.ReadAll(bodyReader) fmt.Printf("=== FileExists ===\n")
fmt.Printf("Response body: %s\n", string(bodyBytes)) reqPath := `/v3/api/file/foo/bare`
} routePath := `/v3/api/file/{filepath}`
func (tester *FileTester) TestFileExists(t *testing.T) { rout := router.NewRouter()
var err error hand := srv.Handler()
fmt.Printf("=== FileExists ===\n") require.NotNil(t, hand)
srv := tester.srv rout.Head(routePath, hand.FileExists)
require.NotNil(t, srv) request, err := http.NewRequest("HEAD", reqPath, nil)
require.NoError(t, err)
reqPath := `/v3/api/file/foo/bare`
routePath := `/v3/api/file/{filepath}` recorder := httptest.NewRecorder()
rout.ServeHTTP(recorder, request)
rout := router.NewRouter() require.Equal(t, http.StatusOK, recorder.Code)
hand := srv.Handler()
require.NotNil(t, hand) fmt.Printf("Response code: %d\n", recorder.Code)
rout.Head(routePath, hand.FileExists) bodyReader := recorder.Body
bodyBytes, err := io.ReadAll(bodyReader)
request, err := http.NewRequest("HEAD", reqPath, nil)
require.NoError(t, err) fmt.Printf("Response body: %s\n", string(bodyBytes))
}
recorder := httptest.NewRecorder() {
rout.ServeHTTP(recorder, request) fmt.Printf("=== GetFile ===\n")
require.Equal(t, http.StatusOK, recorder.Code) reqPath := `/v3/api/file/foo/bare`
routePath := `/v3/api/file/{filepath}`
fmt.Printf("Response code: %d\n", recorder.Code)
rout := router.NewRouter()
bodyReader := recorder.Body hand := srv.Handler()
bodyBytes, err := io.ReadAll(bodyReader) require.NotNil(t, hand)
fmt.Printf("Response body: %s\n", string(bodyBytes)) rout.Get(routePath, hand.GetFile)
}
request, err := http.NewRequest("GET", reqPath, nil)
func (tester *FileTester) TestGetFile(t *testing.T) { require.NoError(t, err)
var err error
recorder := httptest.NewRecorder()
fmt.Printf("=== GetFile ===\n") rout.ServeHTTP(recorder, request)
require.Equal(t, http.StatusOK, recorder.Code)
srv := tester.srv
require.NotNil(t, srv) fmt.Printf("Response code: %d\n", recorder.Code)
reqPath := `/v3/api/file/foo/bare` bodyReader := recorder.Body
routePath := `/v3/api/file/{filepath}` bodyBytes, err := io.ReadAll(bodyReader)
rout := router.NewRouter() fmt.Printf("Response body: %s\n", string(bodyBytes))
hand := srv.Handler() }
require.NotNil(t, hand) {
fmt.Printf("=== DeleteFile ===\n")
rout.Get(routePath, hand.GetFile) reqPath := `/v3/api/file/foo/bare`
routePath := `/v3/api/file/{filepath}`
request, err := http.NewRequest("GET", reqPath, nil)
require.NoError(t, err) rout := router.NewRouter()
hand := srv.Handler()
recorder := httptest.NewRecorder() require.NotNil(t, hand)
rout.ServeHTTP(recorder, request)
require.Equal(t, http.StatusOK, recorder.Code) rout.Delete(routePath, hand.DeleteFile)
fmt.Printf("Response code: %d\n", recorder.Code) request, err := http.NewRequest("DELETE", reqPath, nil)
require.NoError(t, err)
bodyReader := recorder.Body
bodyBytes, err := io.ReadAll(bodyReader) recorder := httptest.NewRecorder()
rout.ServeHTTP(recorder, request)
fmt.Printf("Response body: %s\n", string(bodyBytes)) require.Equal(t, http.StatusOK, recorder.Code)
}
fmt.Printf("Response code: %d\n", recorder.Code)
func (tester *FileTester) TestDeleteFile(t *testing.T) {
var err error bodyReader := recorder.Body
bodyBytes, err := io.ReadAll(bodyReader)
fmt.Printf("=== DeleteFile ===\n")
fmt.Printf("Response body: %s\n", string(bodyBytes))
srv := tester.srv }
require.NotNil(t, srv)
{
reqPath := `/v3/api/file/foo/bare` fmt.Printf("=== FileNotExists ===\n")
routePath := `/v3/api/file/{filepath}`
reqPath := `/v3/api/file/foo/bare`
rout := router.NewRouter() routePath := `/v3/api/file/{filepath}`
hand := srv.Handler()
require.NotNil(t, hand) rout := router.NewRouter()
hand := srv.Handler()
rout.Delete(routePath, hand.DeleteFile) require.NotNil(t, hand)
request, err := http.NewRequest("DELETE", reqPath, nil) rout.Head(routePath, hand.FileExists)
require.NoError(t, err)
request, err := http.NewRequest("HEAD", reqPath, nil)
recorder := httptest.NewRecorder() require.NoError(t, err)
rout.ServeHTTP(recorder, request)
require.Equal(t, http.StatusOK, recorder.Code) recorder := httptest.NewRecorder()
rout.ServeHTTP(recorder, request)
fmt.Printf("Response code: %d\n", recorder.Code) require.Equal(t, http.StatusNotFound, recorder.Code)
bodyReader := recorder.Body fmt.Printf("Response code: %d\n", recorder.Code)
bodyBytes, err := io.ReadAll(bodyReader)
bodyReader := recorder.Body
fmt.Printf("Response body: %s\n", string(bodyBytes)) bodyBytes, err := io.ReadAll(bodyReader)
}
fmt.Printf("Response body: %s\n", string(bodyBytes))
func (tester *FileTester) TestFileNotExists(t *testing.T) { }
var err error {
fmt.Printf("=== FileNotExists ===\n") fmt.Printf("=== ServiceHello ===\n")
reqPath := "/service/hello"
srv := tester.srv routePath := "/service/hello"
require.NotNil(t, srv) rout := router.NewRouter()
hand := srv.Handler()
reqPath := `/v3/api/file/foo/bare` rout.Get(routePath, hand.SendHello)
routePath := `/v3/api/file/{filepath}`
request, err := http.NewRequest("GET", reqPath, nil)
rout := router.NewRouter() require.NoError(t, err)
hand := srv.Handler()
require.NotNil(t, hand) recorder := httptest.NewRecorder()
rout.ServeHTTP(recorder, request)
rout.Head(routePath, hand.FileExists) require.Equal(t, http.StatusOK, recorder.Code)
request, err := http.NewRequest("HEAD", reqPath, nil) fmt.Printf("Response code: %d\n", recorder.Code)
require.NoError(t, err)
bodyReader := recorder.Body
recorder := httptest.NewRecorder() bodyBytes, err := io.ReadAll(bodyReader)
rout.ServeHTTP(recorder, request)
require.Equal(t, http.StatusNotFound, recorder.Code) fmt.Printf("Response body: %s\n", string(bodyBytes))
}
fmt.Printf("Response code: %d\n", recorder.Code)
bodyReader := recorder.Body
bodyBytes, err := io.ReadAll(bodyReader)
fmt.Printf("Response body: %s\n", string(bodyBytes))
}
func (tester *FileTester) TestServiceHello(t *testing.T) {
var err error
fmt.Printf("=== ServiceHello ===\n")
srv := tester.srv
require.NotNil(t, srv)
reqPath := "/service/hello"
routePath := "/service/hello"
rout := router.NewRouter()
hand := srv.Handler()
rout.Get(routePath, hand.SendHello)
request, err := http.NewRequest("GET", reqPath, nil)
require.NoError(t, err)
recorder := httptest.NewRecorder()
rout.ServeHTTP(recorder, request)
require.Equal(t, http.StatusOK, recorder.Code)
fmt.Printf("Response code: %d\n", recorder.Code)
bodyReader := recorder.Body
bodyBytes, err := io.ReadAll(bodyReader)
fmt.Printf("Response body: %s\n", string(bodyBytes))
} }