oyd
/
minio
6
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Add unit tests for server-main.go (#2802)

Browse Source
master
Krishnan Parthasarathi 8 years ago committed by Harshavardhana
parent 1edd74dda2
commit 428629f577
2 changed files with 303 additions and 68 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 303
      cmd/server-main_test.go
  2. 68
      cmd/xl-v1_test.go

303
cmd/server-main_test.go
Unescape View File

@ -0,0 +1,303 @@
/*
* Minio Cloud Storage, (C) 2016 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 (
"flag"
"net"
"net/http"
"os"
"path/filepath"
"runtime"
"strconv"
"testing"
"github.com/minio/cli"
)
func TestGetListenIPs(t *testing.T) {
testCases := []struct {
addr string
port string
}{
{"localhost", ":80"},
{"", ":80"},
}
for _, test := range testCases {
ts := &http.Server{Addr: test.addr + test.port}
getListenIPs(ts)
}
}
func TestFinalizeEndpoints(t *testing.T) {
testCases := []struct {
tls bool
addr string
}{
{false, ":80"},
{true, ":80"},
{false, "localhost:80"},
{true, "localhost:80"},
}
for i, test := range testCases {
endPoints := finalizeEndpoints(test.tls, &http.Server{Addr: test.addr})
if len(endPoints) <= 0 {
t.Errorf("Test case %d returned with no API end points for %s",
i+1, test.addr)
}
}
}
// Tests all the expected input disks for function checkSufficientDisks.
func TestCheckSufficientDisks(t *testing.T) {
xlDisks := []string{
"/mnt/backend1",
"/mnt/backend2",
"/mnt/backend3",
"/mnt/backend4",
"/mnt/backend5",
"/mnt/backend6",
"/mnt/backend7",
"/mnt/backend8",
"/mnt/backend9",
"/mnt/backend10",
"/mnt/backend11",
"/mnt/backend12",
"/mnt/backend13",
"/mnt/backend14",
"/mnt/backend15",
"/mnt/backend16",
}
// List of test cases fo sufficient disk verification.
testCases := []struct {
disks []string
expectedErr error
}{
// Even number of disks '6'.
{
xlDisks[0:6],
nil,
},
// Even number of disks '12'.
{
xlDisks[0:12],
nil,
},
// Even number of disks '16'.
{
xlDisks[0:16],
nil,
},
// Larger than maximum number of disks > 16.
{
append(xlDisks[0:16], "/mnt/unsupported"),
errXLMaxDisks,
},
// Lesser than minimum number of disks < 6.
{
xlDisks[0:3],
errXLMinDisks,
},
// Odd number of disks, not divisible by '2'.
{
append(xlDisks[0:10], xlDisks[11]),
errXLNumDisks,
},
}
// Validates different variations of input disks.
for i, testCase := range testCases {
if checkSufficientDisks(testCase.disks) != testCase.expectedErr {
t.Errorf("Test %d expected to pass for disks %s", i+1, testCase.disks)
}
}
}
func TestCheckNamingDisks(t *testing.T) {
var testCases []struct {
disks []string
err error
}
if runtime.GOOS == "windows" {
testCases = []struct {
disks []string
err error
}{
{[]string{`:C:\\a\\b\\c`}, &net.AddrError{Err: "Missing address in network path", Addr: `:C:\\a\\b\\c`}},
{[]string{`localhost:C:\\mnt\\disk1`, `localhost:C:\\mnt\\disk2`}, nil},
}
} else {
testCases = []struct {
disks []string
err error
}{
{[]string{"localhost:/mnt/disk1", ":/a/b/c"}, &net.AddrError{Err: "Missing address in network path", Addr: ":/a/b/c"}},
{[]string{"localhost:/mnt/disk1", "localhost:/mnt/disk2"}, nil},
}
}
for i, test := range testCases {
err := checkNamingDisks(test.disks)
if test.err != nil {
if err == nil || err.Error() != test.err.Error() {
t.Errorf("Test %d failed with %v but expected error %v", i+1, err, test.err)
}
} else if err != test.err {
t.Errorf("Test %d failed with %v but expected error %v", i+1, err, test.err)
}
}
}
func TestCheckServerSyntax(t *testing.T) {
app := cli.NewApp()
app.Commands = []cli.Command{serverCmd}
serverFlagSet := flag.NewFlagSet("server", 0)
ctx := cli.NewContext(app, serverFlagSet, nil)
disksGen := func(n int) []string {
var disks []string
for i := 0; i < n; i++ {
disks = append(disks, "disk"+strconv.Itoa(i))
}
return disks
}
testCases := [][]string{
disksGen(1),
disksGen(4),
disksGen(8),
disksGen(16),
}
for i, test := range testCases {
err := serverFlagSet.Parse(test)
if err != nil {
t.Errorf("Test %d failed to parse arguments %s", i+1, test)
}
checkServerSyntax(ctx)
}
}
func TestGetPort(t *testing.T) {
root, err := newTestConfig("us-east-1")
if err != nil {
t.Fatal("failed to create test config")
}
defer removeAll(root)
testCases := []struct {
addr string
ssl bool
expectedPort int
}{
{"localhost:1234", true, 1234},
{"localhost:1234", false, 1234},
{"localhost", true, 443},
{"localhost", false, 80},
}
certFile := filepath.Join(mustGetCertsPath(), globalMinioCertFile)
keyFile := filepath.Join(mustGetCertsPath(), globalMinioKeyFile)
err = os.MkdirAll(filepath.Dir(certFile), 0755)
if err != nil {
t.Fatalf("Couldn't create certs directory.")
}
for i, test := range testCases {
if test.ssl {
cFile, cErr := os.Create(certFile)
if cErr != nil {
t.Fatalf("Failed to create cert file %s", certFile)
}
cFile.Close()
tFile, tErr := os.Create(keyFile)
if tErr != nil {
t.Fatalf("Failed to create key file %s", keyFile)
}
tFile.Close()
}
port := getPort(test.addr)
if port != test.expectedPort {
t.Errorf("Test %d expected port %d but received %d", i+1, test.expectedPort, port)
}
if test.ssl {
os.Remove(certFile)
os.Remove(keyFile)
}
}
}
func TestIsDistributedSetup(t *testing.T) {
var testCases []struct {
disks []string
result bool
}
if runtime.GOOS == "windows" {
testCases = []struct {
disks []string
result bool
}{
{[]string{`4.4.4.4:c:\mnt\disk1`, `4.4.4.4:c:\mnt\disk2`}, true},
{[]string{`4.4.4.4:c:\mnt\disk1`, `localhost:c:\mnt\disk2`}, true},
{[]string{`localhost:c:\mnt\disk1`, `localhost:c:\mnt\disk2`}, false},
{[]string{`c:\mnt\disk1`, `c:\mnt\disk2`}, false},
}
} else {
testCases = []struct {
disks []string
result bool
}{
{[]string{"4.4.4.4:/mnt/disk1", "4.4.4.4:/mnt/disk2"}, true},
{[]string{"4.4.4.4:/mnt/disk1", "localhost:/mnt/disk2"}, true},
{[]string{"localhost:/mnt/disk1", "localhost:/mnt/disk2"}, false},
{[]string{"/mnt/disk1", "/mnt/disk2"}, false},
}
}
for i, test := range testCases {
res := isDistributedSetup(test.disks)
if res != test.result {
t.Errorf("Test %d: expected result %t but received %t", i+1, test.result, res)
}
}
}
func TestInitServerConfig(t *testing.T) {
ctx := &cli.Context{}
root, err := newTestConfig("us-east-1")
if err != nil {
t.Fatal("Failed to set up test config")
}
defer removeAll(root)
testCases := []struct {
envVar string
val string
}{
{"MINIO_MAXCONN", "10"},
{"MINIO_CACHE_SIZE", "42MB"},
{"MINIO_CACHE_EXPIRY", "2h45m"},
{"MINIO_ACCESS_KEY", "abcd1"},
{"MINIO_SECRET_KEY", "abcd12345"},
}
for i, test := range testCases {
tErr := os.Setenv(test.envVar, test.val)
if tErr != nil {
t.Fatalf("Test %d failed with %v", i+1, tErr)
}
initServerConfig(ctx)
}
}

68
cmd/xl-v1_test.go
Unescape View File

@ -22,74 +22,6 @@ import (
"testing"
)
// Collection of disks verbatim used for tests.
var disks = []string{
"/mnt/backend1",
"/mnt/backend2",
"/mnt/backend3",
"/mnt/backend4",
"/mnt/backend5",
"/mnt/backend6",
"/mnt/backend7",
"/mnt/backend8",
"/mnt/backend9",
"/mnt/backend10",
"/mnt/backend11",
"/mnt/backend12",
"/mnt/backend13",
"/mnt/backend14",
"/mnt/backend15",
"/mnt/backend16",
}
// Tests all the expected input disks for function checkSufficientDisks.
func TestCheckSufficientDisks(t *testing.T) {
// List of test cases fo sufficient disk verification.
testCases := []struct {
disks []string
expectedErr error
}{
// Even number of disks '6'.
{
disks[0:6],
nil,
},
// Even number of disks '12'.
{
disks[0:12],
nil,
},
// Even number of disks '16'.
{
disks[0:16],
nil,
},
// Larger than maximum number of disks > 16.
{
append(disks[0:16], "/mnt/unsupported"),
errXLMaxDisks,
},
// Lesser than minimum number of disks < 6.
{
disks[0:3],
errXLMinDisks,
},
// Odd number of disks, not divisible by '2'.
{
append(disks[0:10], disks[11]),
errXLNumDisks,
},
}
// Validates different variations of input disks.
for i, testCase := range testCases {
if checkSufficientDisks(testCase.disks) != testCase.expectedErr {
t.Errorf("Test %d expected to pass for disks %s", i+1, testCase.disks)
}
}
}
// TestStorageInfo - tests storage info.
func TestStorageInfo(t *testing.T) {
objLayer, fsDirs, err := prepareXL()

Write Preview
Loading…
Cancel
Save