234 lines
8.2 KiB
Go
234 lines
8.2 KiB
Go
// This file is part of MinIO Console Server
|
|
// Copyright (c) 2022 MinIO, Inc.
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package api
|
|
|
|
import (
|
|
"context"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"net/url"
|
|
"os"
|
|
"testing"
|
|
|
|
"github.com/minio/console/api/operations"
|
|
subnetApi "github.com/minio/console/api/operations/subnet"
|
|
"github.com/minio/console/models"
|
|
"github.com/minio/madmin-go/v3"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/suite"
|
|
)
|
|
|
|
type AdminSubnetTestSuite struct {
|
|
suite.Suite
|
|
assert *assert.Assertions
|
|
currentServer string
|
|
isServerSet bool
|
|
server *httptest.Server
|
|
adminClient AdminClientMock
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) SetupSuite() {
|
|
suite.assert = assert.New(suite.T())
|
|
suite.adminClient = AdminClientMock{}
|
|
minioGetConfigKVMock = func(_ string) ([]byte, error) {
|
|
return []byte("subnet license=mock api_key=mock proxy=http://mock.com"), nil
|
|
}
|
|
MinioServerInfoMock = func(_ context.Context) (madmin.InfoMessage, error) {
|
|
return madmin.InfoMessage{Servers: []madmin.ServerProperties{{}}}, nil
|
|
}
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) SetupTest() {
|
|
suite.server = httptest.NewServer(http.HandlerFunc(suite.serverHandler))
|
|
suite.currentServer, suite.isServerSet = os.LookupEnv(ConsoleMinIOServer)
|
|
os.Setenv(ConsoleMinIOServer, suite.server.URL)
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) serverHandler(w http.ResponseWriter, _ *http.Request) {
|
|
w.WriteHeader(400)
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) TearDownSuite() {
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) TearDownTest() {
|
|
if suite.isServerSet {
|
|
os.Setenv(ConsoleMinIOServer, suite.currentServer)
|
|
} else {
|
|
os.Unsetenv(ConsoleMinIOServer)
|
|
}
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) TestRegisterSubnetHandlers() {
|
|
api := &operations.ConsoleAPI{}
|
|
suite.assertHandlersAreNil(api)
|
|
registerSubnetHandlers(api)
|
|
suite.assertHandlersAreNotNil(api)
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) assertHandlersAreNil(api *operations.ConsoleAPI) {
|
|
suite.assert.Nil(api.SubnetSubnetLoginHandler)
|
|
suite.assert.Nil(api.SubnetSubnetLoginMFAHandler)
|
|
suite.assert.Nil(api.SubnetSubnetRegisterHandler)
|
|
suite.assert.Nil(api.SubnetSubnetInfoHandler)
|
|
suite.assert.Nil(api.SubnetSubnetRegTokenHandler)
|
|
suite.assert.Nil(api.SubnetSubnetAPIKeyHandler)
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) assertHandlersAreNotNil(api *operations.ConsoleAPI) {
|
|
suite.assert.NotNil(api.SubnetSubnetLoginHandler)
|
|
suite.assert.NotNil(api.SubnetSubnetLoginMFAHandler)
|
|
suite.assert.NotNil(api.SubnetSubnetRegisterHandler)
|
|
suite.assert.NotNil(api.SubnetSubnetInfoHandler)
|
|
suite.assert.NotNil(api.SubnetSubnetRegTokenHandler)
|
|
suite.assert.NotNil(api.SubnetSubnetAPIKeyHandler)
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) TestSubnetLoginWithSubnetClientError() {
|
|
params, api := suite.initSubnetLoginRequest("", "", "")
|
|
response := api.SubnetSubnetLoginHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*subnetApi.SubnetLoginDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) TestSubnetLoginResponseWithApiKeyError() {
|
|
params, _ := suite.initSubnetLoginRequest("mock", "", "")
|
|
res, err := subnetLoginResponse(context.TODO(), suite.adminClient, params)
|
|
suite.assert.NotNil(err)
|
|
suite.assert.Nil(res)
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) TestSubnetLoginResponseWithCredentialsError() {
|
|
params, _ := suite.initSubnetLoginRequest("", "mock", "mock")
|
|
res, err := subnetLoginResponse(context.TODO(), suite.adminClient, params)
|
|
suite.assert.NotNil(err)
|
|
suite.assert.Nil(res)
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) initSubnetLoginRequest(apiKey, username, password string) (params subnetApi.SubnetLoginParams, api operations.ConsoleAPI) {
|
|
registerSubnetHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
params.Body = &models.SubnetLoginRequest{}
|
|
params.Body.APIKey = apiKey
|
|
params.Body.Username = username
|
|
params.Body.Password = password
|
|
return params, api
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) TestSubnetLoginMFAWithSubnetClientError() {
|
|
params, api := suite.initSubnetLoginMFARequest("", "", "")
|
|
response := api.SubnetSubnetLoginMFAHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*subnetApi.SubnetLoginMFADefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) TestSubnetLoginWithMFAResponseError() {
|
|
params, _ := suite.initSubnetLoginMFARequest("mock", "mock", "mock")
|
|
res, err := subnetLoginWithMFAResponse(context.TODO(), suite.adminClient, params)
|
|
suite.assert.NotNil(err)
|
|
suite.assert.Nil(res)
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) initSubnetLoginMFARequest(username, mfaToken, otp string) (params subnetApi.SubnetLoginMFAParams, api operations.ConsoleAPI) {
|
|
registerSubnetHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
params.Body = &models.SubnetLoginMFARequest{}
|
|
params.Body.Username = &username
|
|
params.Body.MfaToken = &mfaToken
|
|
params.Body.Otp = &otp
|
|
return params, api
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) TestSubnetRegisterClientError() {
|
|
params, api := suite.initSubnetRegisterRequest("", "")
|
|
response := api.SubnetSubnetRegisterHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*subnetApi.SubnetRegisterDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) TestSubnetRegisterResponseError() {
|
|
params, _ := suite.initSubnetRegisterRequest("mock", "mock")
|
|
err := subnetRegisterResponse(context.TODO(), suite.adminClient, params)
|
|
suite.assert.NotNil(err)
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) initSubnetRegisterRequest(token, accountID string) (params subnetApi.SubnetRegisterParams, api operations.ConsoleAPI) {
|
|
registerSubnetHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
params.Body = &models.SubnetRegisterRequest{}
|
|
params.Body.Token = &token
|
|
params.Body.AccountID = &accountID
|
|
return params, api
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) TestSubnetInfoError() {
|
|
params, api := suite.initSubnetInfoRequest()
|
|
response := api.SubnetSubnetInfoHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*subnetApi.SubnetInfoDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) initSubnetInfoRequest() (params subnetApi.SubnetInfoParams, api operations.ConsoleAPI) {
|
|
registerSubnetHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
return params, api
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) TestSubnetRegTokenError() {
|
|
params, api := suite.initSubnetRegTokenRequest()
|
|
response := api.SubnetSubnetRegTokenHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*subnetApi.SubnetRegTokenDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) TestSubnetRegTokenResponse() {
|
|
res, err := subnetRegTokenResponse(context.TODO(), suite.adminClient)
|
|
suite.assert.Nil(err)
|
|
suite.assert.NotEqual("", res)
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) initSubnetRegTokenRequest() (params subnetApi.SubnetRegTokenParams, api operations.ConsoleAPI) {
|
|
registerSubnetHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
return params, api
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) TestSubnetAPIKeyWithClientError() {
|
|
params, api := suite.initSubnetAPIKeyRequest()
|
|
response := api.SubnetSubnetAPIKeyHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*subnetApi.SubnetAPIKeyDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) TestSubnetAPIKeyResponseError() {
|
|
params, _ := suite.initSubnetAPIKeyRequest()
|
|
res, err := subnetAPIKeyResponse(context.TODO(), suite.adminClient, params)
|
|
suite.assert.NotNil(err)
|
|
suite.assert.Nil(res)
|
|
}
|
|
|
|
func (suite *AdminSubnetTestSuite) initSubnetAPIKeyRequest() (params subnetApi.SubnetAPIKeyParams, api operations.ConsoleAPI) {
|
|
registerSubnetHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
params.HTTPRequest.URL = &url.URL{}
|
|
return params, api
|
|
}
|
|
|
|
func TestAdminSubnet(t *testing.T) {
|
|
suite.Run(t, new(AdminSubnetTestSuite))
|
|
}
|