/*

* Minio Cloud Storage, (C) 2016, 2017, 2018 Minio, Inc.

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

package cmd

import (

"bytes"

"context"

"encoding/json"

"fmt"

"io"

"io/ioutil"

"net/http"

"net/http/httptest"

"net/url"

"os"

"strings"

"testing"

"time"

router "github.com/gorilla/mux"

"github.com/minio/minio/pkg/auth"

"github.com/minio/minio/pkg/errors"

"github.com/minio/minio/pkg/madmin"

)

var (

configJSON = []byte(`{

"version": "13",

"credential": {

"accessKey": "minio",

"secretKey": "minio123"

},

"region": "us-west-1",

"logger": {

"console": {

"enable": true,

"level": "fatal"

},

"file": {

"enable": false,

"fileName": "",

"level": ""

}

},

"notify": {

"amqp": {

"1": {

"enable": false,

"url": "",

"exchange": "",

"routingKey": "",

"exchangeType": "",

"mandatory": false,

"immediate": false,

"durable": false,

"internal": false,

"noWait": false,

"autoDeleted": false

}

},

"nats": {

"1": {

"enable": false,

"address": "",

"subject": "",

"username": "",

"password": "",

"token": "",

"secure": false,

"pingInterval": 0,

"streaming": {

"enable": false,

"clusterID": "",

"clientID": "",

"async": false,

"maxPubAcksInflight": 0

}

}

},

"elasticsearch": {

"1": {

"enable": false,

"url": "",

"index": ""

}

},

"redis": {

"1": {

"enable": false,

"address": "",

"password": "",

"key": ""

}

},

"postgresql": {

"1": {

"enable": false,

"connectionString": "",

"table": "",

"host": "",

"port": "",

"user": "",

"password": "",

"database": ""

}

},

"kafka": {

"1": {

"enable": false,

"brokers": null,

"topic": ""

}

},

"webhook": {

"1": {

"enable": false,

"endpoint": ""

}

}

}

}`)

)

// adminXLTestBed - encapsulates subsystems that need to be setup for

// admin-handler unit tests.

type adminXLTestBed struct {

configPath string

xlDirs []string

objLayer ObjectLayer

mux *router.Router

}

// prepareAdminXLTestBed - helper function that setups a single-node

// XL backend for admin-handler tests.

func prepareAdminXLTestBed() (*adminXLTestBed, error) {

// reset global variables to start afresh.

resetTestGlobals()

// Initialize minio server config.

rootPath, err := newTestConfig(globalMinioDefaultRegion)

if err != nil {

return nil, err

}

// Initializing objectLayer for HealFormatHandler.

objLayer, xlDirs, xlErr := initTestXLObjLayer()

if xlErr != nil {

return nil, xlErr

}

// Initialize boot time

globalBootTime = UTCNow()

globalEndpoints = mustGetNewEndpointList(xlDirs...)

// Set globalIsXL to indicate that the setup uses an erasure

// code backend.

globalIsXL = true

// initialize NSLock.

isDistXL := false

initNSLock(isDistXL)

// Init global heal state

initAllHealState(globalIsXL)

globalNotificationSys, err = NewNotificationSys(globalServerConfig, globalEndpoints)

if err != nil {

return nil, err

}

// Setup admin mgmt REST API handlers.

adminRouter := router.NewRouter()

registerAdminRouter(adminRouter)

return &adminXLTestBed{

configPath: rootPath,

xlDirs: xlDirs,

objLayer: objLayer,

mux: adminRouter,

}, nil

}

// TearDown - method that resets the test bed for subsequent unit

// tests to start afresh.

func (atb *adminXLTestBed) TearDown() {

os.RemoveAll(atb.configPath)

removeRoots(atb.xlDirs)

resetTestGlobals()

}

func (atb *adminXLTestBed) GenerateHealTestData(t *testing.T) {

// Create an object myobject under bucket mybucket.

bucketName := "mybucket"

err := atb.objLayer.MakeBucketWithLocation(context.Background(), bucketName, "")

if err != nil {

t.Fatalf("Failed to make bucket %s - %v", bucketName,

err)

}

// create some objects

{

objName := "myobject"

for i := 0; i < 10; i++ {

objectName := fmt.Sprintf("%s-%d", objName, i)

_, err = atb.objLayer.PutObject(context.Background(), bucketName, objectName,

mustGetHashReader(t, bytes.NewReader([]byte("hello")),

int64(len("hello")), "", ""), nil)

if err != nil {

t.Fatalf("Failed to create %s - %v", objectName,

err)

}

}

}

// create a multipart upload (incomplete)

{

objName := "mpObject"

uploadID, err := atb.objLayer.NewMultipartUpload(context.Background(), bucketName,

objName, nil)

if err != nil {

t.Fatalf("mp new error: %v", err)

}

_, err = atb.objLayer.PutObjectPart(context.Background(), bucketName, objName,

uploadID, 3, mustGetHashReader(t, bytes.NewReader(

[]byte("hello")), int64(len("hello")), "", ""))

if err != nil {

t.Fatalf("mp put error: %v", err)

}

}

}

func (atb *adminXLTestBed) CleanupHealTestData(t *testing.T) {

bucketName := "mybucket"

objName := "myobject"

for i := 0; i < 10; i++ {

atb.objLayer.DeleteObject(context.Background(), bucketName,

fmt.Sprintf("%s-%d", objName, i))

}

atb.objLayer.DeleteBucket(context.Background(), bucketName)

}

// initTestObjLayer - Helper function to initialize an XL-based object

// layer and set globalObjectAPI.

func initTestXLObjLayer() (ObjectLayer, []string, error) {

xlDirs, err := getRandomDisks(16)

if err != nil {

return nil, nil, err

}

endpoints := mustGetNewEndpointList(xlDirs...)

format, err := waitForFormatXL(true, endpoints, 1, 16)

if err != nil {

removeRoots(xlDirs)

return nil, nil, err

}

objLayer, err := newXLSets(endpoints, format, 1, 16)

if err != nil {

return nil, nil, err

}

// Make objLayer available to all internal services via globalObjectAPI.

globalObjLayerMutex.Lock()

globalObjectAPI = objLayer

globalObjLayerMutex.Unlock()

return objLayer, xlDirs, nil

}

func TestAdminVersionHandler(t *testing.T) {

adminTestBed, err := prepareAdminXLTestBed()

if err != nil {

t.Fatal("Failed to initialize a single node XL backend for admin handler tests.")

}

defer adminTestBed.TearDown()

req, err := newTestRequest("GET", "/minio/admin/version", 0, nil)

if err != nil {

t.Fatalf("Failed to construct request - %v", err)

}

cred := globalServerConfig.GetCredential()

err = signRequestV4(req, cred.AccessKey, cred.SecretKey)

if err != nil {

t.Fatalf("Failed to sign request - %v", err)

}

rec := httptest.NewRecorder()

adminTestBed.mux.ServeHTTP(rec, req)

if http.StatusOK != rec.Code {

t.Errorf("Unexpected status code - got %d but expected %d",

rec.Code, http.StatusOK)

}

var result madmin.AdminAPIVersionInfo

err = json.NewDecoder(rec.Body).Decode(&result)

if err != nil {

t.Errorf("json parse err: %v", err)

}

if result != adminAPIVersionInfo {

t.Errorf("unexpected version: %v", result)

}

}

// cmdType - Represents different service subcomands like status, stop

// and restart.

type cmdType int

const (

statusCmd cmdType = iota

restartCmd

stopCmd

setCreds

)

// String - String representation for cmdType

func (c cmdType) String() string {

switch c {

case statusCmd:

return "status"

case restartCmd:

return "restart"

case stopCmd:

return "stop"

case setCreds:

return "set-credentials"

}

return ""

}

// apiMethod - Returns the HTTP method corresponding to the admin REST

// API for a given cmdType value.

func (c cmdType) apiMethod() string {

switch c {

case statusCmd:

return "GET"

case restartCmd:

return "POST"

case stopCmd:

return "POST"

case setCreds:

return "PUT"

}

return "GET"

}

// apiEndpoint - Return endpoint for each admin REST API mapped to a

// command here.

func (c cmdType) apiEndpoint() string {

switch c {

case statusCmd, restartCmd, stopCmd:

return "/minio/admin/v1/service"

case setCreds:

return "/minio/admin/v1/config/credential"

}

return ""

}

// toServiceSignal - Helper function that translates a given cmdType

// value to its corresponding serviceSignal value.

func (c cmdType) toServiceSignal() serviceSignal {

switch c {

case statusCmd:

return serviceStatus

case restartCmd:

return serviceRestart

case stopCmd:

return serviceStop

}

return serviceStatus

}

func (c cmdType) toServiceActionValue() madmin.ServiceActionValue {

switch c {

case restartCmd:

return madmin.ServiceActionValueRestart

case stopCmd:

return madmin.ServiceActionValueStop

}

return madmin.ServiceActionValueStop

}

// testServiceSignalReceiver - Helper function that simulates a

// go-routine waiting on service signal.

func testServiceSignalReceiver(cmd cmdType, t *testing.T) {

expectedCmd := cmd.toServiceSignal()

serviceCmd := <-globalServiceSignalCh

if serviceCmd != expectedCmd {

t.Errorf("Expected service command %v but received %v", expectedCmd, serviceCmd)

}

}

// getServiceCmdRequest - Constructs a management REST API request for service

// subcommands for a given cmdType value.

func getServiceCmdRequest(cmd cmdType, cred auth.Credentials, body []byte) (*http.Request, error) {

req, err := newTestRequest(cmd.apiMethod(), cmd.apiEndpoint(), 0, nil)

if err != nil {

return nil, err

}

// Set body

req.Body = ioutil.NopCloser(bytes.NewReader(body))

// Set sha-sum header

req.Header.Set("X-Amz-Content-Sha256", getSHA256Hash(body))

// management REST API uses signature V4 for authentication.

err = signRequestV4(req, cred.AccessKey, cred.SecretKey)

if err != nil {

return nil, err

}

return req, nil

}

// testServicesCmdHandler - parametrizes service subcommand tests on

// cmdType value.

func testServicesCmdHandler(cmd cmdType, t *testing.T) {

adminTestBed, err := prepareAdminXLTestBed()

if err != nil {

t.Fatal("Failed to initialize a single node XL backend for admin handler tests.")

}

defer adminTestBed.TearDown()

// Initialize admin peers to make admin RPC calls. Note: In a

// single node setup, this degenerates to a simple function

// call under the hood.

globalMinioAddr = "127.0.0.1:9000"

initGlobalAdminPeers(mustGetNewEndpointList("http://127.0.0.1:9000/d1"))

// Setting up a go routine to simulate ServerMux's

// handleServiceSignals for stop and restart commands.

if cmd == restartCmd {

go testServiceSignalReceiver(cmd, t)

}

credentials := globalServerConfig.GetCredential()

body, err := json.Marshal(madmin.ServiceAction{

cmd.toServiceActionValue()})

if err != nil {

t.Fatalf("JSONify error: %v", err)

}

req, err := getServiceCmdRequest(cmd, credentials, body)

if err != nil {

t.Fatalf("Failed to build service status request %v", err)

}

rec := httptest.NewRecorder()

adminTestBed.mux.ServeHTTP(rec, req)

if cmd == statusCmd {

expectedInfo := madmin.ServiceStatus{

ServerVersion: madmin.ServerVersion{Version: Version, CommitID: CommitID},

}

receivedInfo := madmin.ServiceStatus{}

if jsonErr := json.Unmarshal(rec.Body.Bytes(), &receivedInfo); jsonErr != nil {

t.Errorf("Failed to unmarshal StorageInfo - %v", jsonErr)

}

if expectedInfo.ServerVersion != receivedInfo.ServerVersion {

t.Errorf("Expected storage info and received storage info differ, %v %v", expectedInfo, receivedInfo)

}

}

if rec.Code != http.StatusOK {

resp, _ := ioutil.ReadAll(rec.Body)

t.Errorf("Expected to receive %d status code but received %d. Body (%s)",

http.StatusOK, rec.Code, string(resp))

}

}

// Test for service status management REST API.

func TestServiceStatusHandler(t *testing.T) {

testServicesCmdHandler(statusCmd, t)

}

// Test for service restart management REST API.

func TestServiceRestartHandler(t *testing.T) {

testServicesCmdHandler(restartCmd, t)

}

// Test for service set creds management REST API.

func TestServiceSetCreds(t *testing.T) {

adminTestBed, err := prepareAdminXLTestBed()

if err != nil {

t.Fatal("Failed to initialize a single node XL backend for admin handler tests.")

}

defer adminTestBed.TearDown()

// Initialize admin peers to make admin RPC calls. Note: In a

// single node setup, this degenerates to a simple function

// call under the hood.

globalMinioAddr = "127.0.0.1:9000"

initGlobalAdminPeers(mustGetNewEndpointList("http://127.0.0.1:9000/d1"))

credentials := globalServerConfig.GetCredential()

testCases := []struct {

AccessKey string

SecretKey string

EnvKeysSet bool

ExpectedStatusCode int

}{

// Bad secret key

{"minio", "minio", false, http.StatusBadRequest},

// Bad secret key set from the env

{"minio", "minio", true, http.StatusMethodNotAllowed},

// Good keys set from the env

{"minio", "minio123", true, http.StatusMethodNotAllowed},

// Successful operation should be the last one to

// not change server credentials during tests.

{"minio", "minio123", false, http.StatusOK},

}

for i, testCase := range testCases {

// Set or unset environement keys

globalIsEnvCreds = testCase.EnvKeysSet

// Construct setCreds request body

body, err := json.Marshal(madmin.SetCredsReq{

AccessKey: testCase.AccessKey,

SecretKey: testCase.SecretKey})

if err != nil {

t.Fatalf("JSONify err: %v", err)

}

// Construct setCreds request

req, err := getServiceCmdRequest(setCreds, credentials, body)

if err != nil {

t.Fatalf("Failed to build service status request %v", err)

}

rec := httptest.NewRecorder()

// Execute request

adminTestBed.mux.ServeHTTP(rec, req)

// Check if the http code response is expected

if rec.Code != testCase.ExpectedStatusCode {

t.Errorf("Test %d: Wrong status code, expected = %d, found = %d", i+1, testCase.ExpectedStatusCode, rec.Code)

resp, _ := ioutil.ReadAll(rec.Body)

t.Errorf("Expected to receive %d status code but received %d. Body (%s)",

http.StatusOK, rec.Code, string(resp))

}

// If we got 200 OK, check if new credentials are really set

if rec.Code == http.StatusOK {

cred := globalServerConfig.GetCredential()

if cred.AccessKey != testCase.AccessKey {

t.Errorf("Test %d: Wrong access key, expected = %s, found = %s", i+1, testCase.AccessKey, cred.AccessKey)

}

if cred.SecretKey != testCase.SecretKey {

t.Errorf("Test %d: Wrong secret key, expected = %s, found = %s", i+1, testCase.SecretKey, cred.SecretKey)

}

}

}

}

// mkLockQueryVal - helper function to build lock query param.

func mkLockQueryVal(bucket, prefix, durationStr string) url.Values {

qVal := url.Values{}

qVal.Set(string(mgmtBucket), bucket)

qVal.Set(string(mgmtPrefix), prefix)

qVal.Set(string(mgmtLockOlderThan), durationStr)

return qVal

}

// Test for locks list management REST API.

func TestListLocksHandler(t *testing.T) {

adminTestBed, err := prepareAdminXLTestBed()

if err != nil {

t.Fatal("Failed to initialize a single node XL backend for admin handler tests.")

}

defer adminTestBed.TearDown()

// Initialize admin peers to make admin RPC calls.

globalMinioAddr = "127.0.0.1:9000"

initGlobalAdminPeers(mustGetNewEndpointList("http://127.0.0.1:9000/d1"))

testCases := []struct {

bucket string

prefix string

duration string

expectedStatus int

}{

// Test 1 - valid testcase

{

bucket: "mybucket",

prefix: "myobject",

duration: "1s",

expectedStatus: http.StatusOK,

},

// Test 2 - invalid duration

{

bucket: "mybucket",

prefix: "myprefix",

duration: "invalidDuration",

expectedStatus: http.StatusBadRequest,

},

// Test 3 - invalid bucket name

{

bucket: `invalid\\Bucket`,

prefix: "myprefix",

duration: "1h",

expectedStatus: http.StatusBadRequest,

},

// Test 4 - invalid prefix

{

bucket: "mybucket",

prefix: `invalid\\Prefix`,

duration: "1h",

expectedStatus: http.StatusBadRequest,

},

}

for i, test := range testCases {

queryVal := mkLockQueryVal(test.bucket, test.prefix, test.duration)

req, err := newTestRequest("GET", "/minio/admin/v1/locks?"+queryVal.Encode(), 0, nil)

if err != nil {

t.Fatalf("Test %d - Failed to construct list locks request - %v", i+1, err)

}

cred := globalServerConfig.GetCredential()

err = signRequestV4(req, cred.AccessKey, cred.SecretKey)

if err != nil {

t.Fatalf("Test %d - Failed to sign list locks request - %v", i+1, err)

}

rec := httptest.NewRecorder()

adminTestBed.mux.ServeHTTP(rec, req)

if test.expectedStatus != rec.Code {

t.Errorf("Test %d - Expected HTTP status code %d but received %d", i+1, test.expectedStatus, rec.Code)

}

}

}

// Test for locks clear management REST API.

func TestClearLocksHandler(t *testing.T) {

adminTestBed, err := prepareAdminXLTestBed()

if err != nil {

t.Fatal("Failed to initialize a single node XL backend for admin handler tests.")

}

defer adminTestBed.TearDown()

// Initialize admin peers to make admin RPC calls.

initGlobalAdminPeers(mustGetNewEndpointList("http://127.0.0.1:9000/d1"))

testCases := []struct {

bucket string

prefix string

duration string

expectedStatus int

}{

// Test 1 - valid testcase

{

bucket: "mybucket",

prefix: "myobject",

duration: "1s",

expectedStatus: http.StatusOK,

},

// Test 2 - invalid duration

{

bucket: "mybucket",

prefix: "myprefix",

duration: "invalidDuration",

expectedStatus: http.StatusBadRequest,

},

// Test 3 - invalid bucket name

{

bucket: `invalid\\Bucket`,

prefix: "myprefix",

duration: "1h",

expectedStatus: http.StatusBadRequest,

},

// Test 4 - invalid prefix

{

bucket: "mybucket",

prefix: `invalid\\Prefix`,

duration: "1h",

expectedStatus: http.StatusBadRequest,

},

}

for i, test := range testCases {

queryVal := mkLockQueryVal(test.bucket, test.prefix, test.duration)

req, err := newTestRequest("DELETE", "/minio/admin/v1/locks?"+queryVal.Encode(), 0, nil)

if err != nil {

t.Fatalf("Test %d - Failed to construct clear locks request - %v", i+1, err)

}

cred := globalServerConfig.GetCredential()

err = signRequestV4(req, cred.AccessKey, cred.SecretKey)

if err != nil {

t.Fatalf("Test %d - Failed to sign clear locks request - %v", i+1, err)

}

rec := httptest.NewRecorder()

adminTestBed.mux.ServeHTTP(rec, req)

if test.expectedStatus != rec.Code {

t.Errorf("Test %d - Expected HTTP status code %d but received %d", i+1, test.expectedStatus, rec.Code)

}

}

}

// Test for lock query param validation helper function.

func TestValidateLockQueryParams(t *testing.T) {

// reset globals.

// this is to make sure that the tests are not affected by modified globals.

resetTestGlobals()

// initialize NSLock.

initNSLock(false)

// Sample query values for test cases.

allValidVal := mkLockQueryVal("bucket", "prefix", "1s")

invalidBucketVal := mkLockQueryVal(`invalid\\Bucket`, "prefix", "1s")

invalidPrefixVal := mkLockQueryVal("bucket", `invalid\\Prefix`, "1s")

invalidOlderThanVal := mkLockQueryVal("bucket", "prefix", "invalidDuration")

testCases := []struct {

qVals url.Values

apiErr APIErrorCode

}{

{

qVals: invalidBucketVal,

apiErr: ErrInvalidBucketName,

},

{

qVals: invalidPrefixVal,

apiErr: ErrInvalidObjectName,

},

{

qVals: invalidOlderThanVal,

apiErr: ErrInvalidDuration,

},

{

qVals: allValidVal,

apiErr: ErrNone,

},

}

for i, test := range testCases {

_, _, _, apiErr := validateLockQueryParams(test.qVals)

if apiErr != test.apiErr {

t.Errorf("Test %d - Expected error %v but received %v", i+1, test.apiErr, apiErr)

}

}

}

// buildAdminRequest - helper function to build an admin API request.

func buildAdminRequest(queryVal url.Values, method, path string,

contentLength int64, bodySeeker io.ReadSeeker) (*http.Request, error) {

req, err := newTestRequest(method,

"/minio/admin/v1"+path+"?"+queryVal.Encode(),

contentLength, bodySeeker)

if err != nil {

return nil, errors.Trace(err)

}

cred := globalServerConfig.GetCredential()

err = signRequestV4(req, cred.AccessKey, cred.SecretKey)

if err != nil {

return nil, errors.Trace(err)

}

return req, nil

}

// TestGetConfigHandler - test for GetConfigHandler.

func TestGetConfigHandler(t *testing.T) {

adminTestBed, err := prepareAdminXLTestBed()

if err != nil {

t.Fatal("Failed to initialize a single node XL backend for admin handler tests.")

}

defer adminTestBed.TearDown()

// Initialize admin peers to make admin RPC calls.

globalMinioAddr = "127.0.0.1:9000"

initGlobalAdminPeers(mustGetNewEndpointList("http://127.0.0.1:9000/d1"))

// Prepare query params for get-config mgmt REST API.

queryVal := url.Values{}

queryVal.Set("config", "")

req, err := buildAdminRequest(queryVal, http.MethodGet, "/config", 0, nil)

if err != nil {

t.Fatalf("Failed to construct get-config object request - %v", err)

}

rec := httptest.NewRecorder()

adminTestBed.mux.ServeHTTP(rec, req)

if rec.Code != http.StatusOK {

t.Errorf("Expected to succeed but failed with %d", rec.Code)

}

}

// TestSetConfigHandler - test for SetConfigHandler.

func TestSetConfigHandler(t *testing.T) {

adminTestBed, err := prepareAdminXLTestBed()

if err != nil {

t.Fatal("Failed to initialize a single node XL backend for admin handler tests.")

}

defer adminTestBed.TearDown()

// Initialize admin peers to make admin RPC calls.

globalMinioAddr = "127.0.0.1:9000"

initGlobalAdminPeers(mustGetNewEndpointList("http://127.0.0.1:9000/d1"))

// SetConfigHandler restarts minio setup - need to start a

// signal receiver to receive on globalServiceSignalCh.

go testServiceSignalReceiver(restartCmd, t)

// Prepare query params for set-config mgmt REST API.

queryVal := url.Values{}

queryVal.Set("config", "")

req, err := buildAdminRequest(queryVal, http.MethodPut, "/config",

int64(len(configJSON)), bytes.NewReader(configJSON))

if err != nil {

t.Fatalf("Failed to construct set-config object request - %v", err)

}

rec := httptest.NewRecorder()

adminTestBed.mux.ServeHTTP(rec, req)

if rec.Code != http.StatusOK {

t.Errorf("Expected to succeed but failed with %d", rec.Code)

}

result := setConfigResult{}

err = json.NewDecoder(rec.Body).Decode(&result)

if err != nil {

t.Fatalf("Failed to decode set config result json %v", err)

}

if !result.Status {

t.Error("Expected set-config to succeed, but failed")

}

// Check that a very large config file returns an error.

{

// Make a large enough config string

invalidCfg := []byte(strings.Repeat("A", maxConfigJSONSize+1))

req, err := buildAdminRequest(queryVal, http.MethodPut, "/config",

int64(len(invalidCfg)), bytes.NewReader(invalidCfg))

if err != nil {

t.Fatalf("Failed to construct set-config object request - %v", err)

}

rec := httptest.NewRecorder()

adminTestBed.mux.ServeHTTP(rec, req)

respBody := string(rec.Body.Bytes())

if rec.Code != http.StatusBadRequest ||

!strings.Contains(respBody, "Configuration data provided exceeds the allowed maximum of") {

t.Errorf("Got unexpected response code or body %d - %s", rec.Code, respBody)

}

}

// Check that a config with duplicate keys in an object return

// error.

{

invalidCfg := append(configJSON[:len(configJSON)-1], []byte(`, "version": "15"}`)...)

req, err := buildAdminRequest(queryVal, http.MethodPut, "/config",

int64(len(invalidCfg)), bytes.NewReader(invalidCfg))

if err != nil {

t.Fatalf("Failed to construct set-config object request - %v", err)

}

rec := httptest.NewRecorder()

adminTestBed.mux.ServeHTTP(rec, req)

respBody := string(rec.Body.Bytes())

if rec.Code != http.StatusBadRequest ||

!strings.Contains(respBody, "JSON configuration provided has objects with duplicate keys") {

t.Errorf("Got unexpected response code or body %d - %s", rec.Code, respBody)

}

}

}

func TestAdminServerInfo(t *testing.T) {

adminTestBed, err := prepareAdminXLTestBed()

if err != nil {

t.Fatal("Failed to initialize a single node XL backend for admin handler tests.")

}

defer adminTestBed.TearDown()

// Initialize admin peers to make admin RPC calls.

globalMinioAddr = "127.0.0.1:9000"

initGlobalAdminPeers(mustGetNewEndpointList("http://127.0.0.1:9000/d1"))

// Prepare query params for set-config mgmt REST API.

queryVal := url.Values{}

queryVal.Set("info", "")

req, err := buildAdminRequest(queryVal, http.MethodGet, "/info", 0, nil)

if err != nil {

t.Fatalf("Failed to construct get-config object request - %v", err)

}

rec := httptest.NewRecorder()

adminTestBed.mux.ServeHTTP(rec, req)

if rec.Code != http.StatusOK {

t.Errorf("Expected to succeed but failed with %d", rec.Code)

}

results := []ServerInfo{}

err = json.NewDecoder(rec.Body).Decode(&results)

if err != nil {

t.Fatalf("Failed to decode set config result json %v", err)

}

if len(results) == 0 {

t.Error("Expected at least one server info result")

}

for _, serverInfo := range results {

if len(serverInfo.Addr) == 0 {

t.Error("Expected server address to be non empty")

}

if serverInfo.Error != "" {

t.Errorf("Unexpected error = %v\n", serverInfo.Error)

}

if serverInfo.Data.StorageInfo.Free == 0 {

t.Error("Expected StorageInfo.Free to be non empty")

}

if serverInfo.Data.Properties.Region != globalMinioDefaultRegion {

t.Errorf("Expected %s, got %s", globalMinioDefaultRegion, serverInfo.Data.Properties.Region)

}

}

}

// TestToAdminAPIErr - test for toAdminAPIErr helper function.

func TestToAdminAPIErr(t *testing.T) {

testCases := []struct {

err error

expectedAPIErr APIErrorCode

}{

// 1. Server not in quorum.

{

err: errXLWriteQuorum,

expectedAPIErr: ErrAdminConfigNoQuorum,

},

// 2. No error.

{

err: nil,

expectedAPIErr: ErrNone,

},

// 3. Non-admin API specific error.

{

err: errDiskNotFound,

expectedAPIErr: toAPIErrorCode(errDiskNotFound),

},

}

for i, test := range testCases {

actualErr := toAdminAPIErrCode(test.err)

if actualErr != test.expectedAPIErr {

t.Errorf("Test %d: Expected %v but received %v",

i+1, test.expectedAPIErr, actualErr)

}

}

}

func TestWriteSetConfigResponse(t *testing.T) {

rootPath, err := newTestConfig(globalMinioDefaultRegion)

if err != nil {

t.Fatal(err)

}

defer os.RemoveAll(rootPath)

testCases := []struct {

status bool

errs []error

}{

// 1. all nodes returned success.

{

status: true,

errs: []error{nil, nil, nil, nil},

},

// 2. some nodes returned errors.

{

status: false,

errs: []error{errDiskNotFound, nil, errDiskAccessDenied, errFaultyDisk},

},

}

testPeers := []adminPeer{

{

addr: "localhost:9001",

},

{

addr: "localhost:9002",

},

{