| /* |
| Copyright 2017 The Kubernetes Authors. |
| |
| 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 scaleio |
| |
| import ( |
| "errors" |
| "testing" |
| "time" |
| |
| "k8s.io/kubernetes/pkg/util/mount" |
| |
| siotypes "github.com/codedellemc/goscaleio/types/v1" |
| ) |
| |
| var ( |
| fakeSdcID = "test-sdc-123456789" |
| fakeVolumeName = "test-vol-0001" |
| fakeVolumeID = "1234567890" |
| fakeDev = "/dev/testABC" |
| |
| fakeConfig = map[string]string{ |
| confKey.gateway: "http://sio.gateway:1234", |
| confKey.sslEnabled: "false", |
| confKey.system: "scaleio", |
| confKey.volumeName: "sio-0001", |
| confKey.secretName: "sio-secret", |
| confKey.username: "c2lvdXNlcgo=", // siouser |
| confKey.password: "c2lvcGFzc3dvcmQK", // siopassword |
| } |
| ) |
| |
| func newTestMgr(t *testing.T) *sioMgr { |
| mgr, err := newSioMgr(fakeConfig, mount.NewFakeExec(nil)) |
| if err != nil { |
| t.Error(err) |
| } |
| mgr.client = newFakeSio() |
| return mgr |
| } |
| |
| func TestMgrNew(t *testing.T) { |
| mgr, err := newSioMgr(fakeConfig, mount.NewFakeExec(nil)) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if mgr.configData == nil { |
| t.Fatal("configuration data not set") |
| } |
| if mgr.configData[confKey.volumeName] != "sio-0001" { |
| t.Errorf("expecting %s, got %s", "sio-0001", mgr.configData[confKey.volumeName]) |
| } |
| |
| // check defaults |
| if mgr.configData[confKey.protectionDomain] != "default" { |
| t.Errorf("unexpected value for confData[protectionDomain] %s", mgr.configData[confKey.protectionDomain]) |
| } |
| if mgr.configData[confKey.storagePool] != "default" { |
| t.Errorf("unexpected value for confData[storagePool] %s", mgr.configData[confKey.storagePool]) |
| } |
| if mgr.configData[confKey.storageMode] != "ThinProvisioned" { |
| t.Errorf("unexpected value for confData[storageMode] %s", mgr.configData[confKey.storageMode]) |
| } |
| } |
| |
| func TestMgrGetClient(t *testing.T) { |
| mgr := newTestMgr(t) |
| _, err := mgr.getClient() |
| if err != nil { |
| t.Fatal(err) |
| } |
| if mgr.client == nil { |
| t.Fatal("mgr.client not set") |
| } |
| } |
| |
| func TestMgrCreateVolume(t *testing.T) { |
| mgr := newTestMgr(t) |
| vol, err := mgr.CreateVolume("test-vol-0001", 8*1024*1024) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if vol.Name != "test-vol-0001" { |
| t.Errorf("unexpected vol.Name %s", vol.Name) |
| } |
| } |
| |
| func TestMgrAttachVolume(t *testing.T) { |
| mgr := newTestMgr(t) |
| mgr.CreateVolume("test-vol-0001", 8*1024*1024) |
| device, err := mgr.AttachVolume("test-vol-0001", false) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if device != "/dev/testABC" { |
| t.Errorf("unexpected value for mapped device %s", device) |
| } |
| } |
| |
| func TestMgrAttachVolume_AlreadyAttached(t *testing.T) { |
| mgr := newTestMgr(t) |
| mgr.CreateVolume("test-vol-0001", 8*1024*1024) |
| mgr.AttachVolume("test-vol-0001", false) |
| dev, err := mgr.AttachVolume("test-vol-0001", false) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if dev != "/dev/testABC" { |
| t.Errorf("unexpected value for mapped device %s", dev) |
| } |
| } |
| |
| func TestMgrAttachVolume_VolumeNotFoundError(t *testing.T) { |
| mgr := newTestMgr(t) |
| mgr.CreateVolume("test-vol-0001", 8*1024*1024) |
| _, err := mgr.AttachVolume("test-vol-0002", false) |
| |
| if err == nil { |
| t.Error("attachVolume should fail with volume not found error") |
| } |
| } |
| |
| func TestMgrAttachVolume_WaitForAttachError(t *testing.T) { |
| mgr := newTestMgr(t) |
| mgr.CreateVolume("test-vol-0001", 8*1024*1024) |
| go func() { |
| c := mgr.client.(*fakeSio) |
| close(c.waitAttachCtrl) |
| }() |
| _, err := mgr.AttachVolume("test-vol-0001", false) |
| if err == nil { |
| t.Error("attachVolume should fail with attach timeout error") |
| } |
| } |
| |
| func TestMgrDetachVolume(t *testing.T) { |
| mgr := newTestMgr(t) |
| mgr.CreateVolume("test-vol-0001", 8*1024*1024) |
| mgr.AttachVolume("test-vol-0001", false) |
| if err := mgr.DetachVolume("test-vol-0001"); err != nil { |
| t.Fatal(err) |
| } |
| fakeSio := mgr.client.(*fakeSio) |
| if len(fakeSio.volume.MappedSdcInfo) != 0 { |
| t.Errorf("expecting attached sdc to 0, got %d", len(fakeSio.volume.MappedSdcInfo)) |
| } |
| if len(fakeSio.devs) != 0 { |
| t.Errorf("expecting local devs to be 0, got %d", len(fakeSio.devs)) |
| } |
| |
| } |
| func TestMgrDetachVolume_VolumeNotFound(t *testing.T) { |
| mgr := newTestMgr(t) |
| mgr.CreateVolume("test-vol-0001", 8*1024*1024) |
| mgr.AttachVolume("test-vol-0001", false) |
| err := mgr.DetachVolume("test-vol-0002") |
| if err == nil { |
| t.Fatal("expected a volume not found failure") |
| } |
| } |
| |
| func TestMgrDetachVolume_VolumeNotAttached(t *testing.T) { |
| mgr := newTestMgr(t) |
| mgr.CreateVolume("test-vol-0001", 8*1024*1024) |
| err := mgr.DetachVolume("test-vol-0001") |
| if err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| func TestMgrDetachVolume_VolumeAlreadyDetached(t *testing.T) { |
| mgr := newTestMgr(t) |
| mgr.CreateVolume("test-vol-0001", 8*1024*1024) |
| mgr.AttachVolume("test-vol-0001", false) |
| mgr.DetachVolume("test-vol-0001") |
| err := mgr.DetachVolume("test-vol-0001") |
| if err != nil { |
| t.Fatal("failed detaching a volume already detached") |
| } |
| } |
| |
| func TestMgrDetachVolume_WaitForDetachError(t *testing.T) { |
| mgr := newTestMgr(t) |
| mgr.CreateVolume("test-vol-0001", 8*1024*1024) |
| mgr.AttachVolume("test-vol-0001", false) |
| err := mgr.DetachVolume("test-vol-0001") |
| if err != nil { |
| t.Error("detachVolume failed") |
| } |
| } |
| func TestMgrDeleteVolume(t *testing.T) { |
| mgr := newTestMgr(t) |
| mgr.CreateVolume("test-vol-0001", 8*1024*1024) |
| err := mgr.DeleteVolume("test-vol-0001") |
| if err != nil { |
| t.Fatal(err) |
| } |
| sio := mgr.client.(*fakeSio) |
| if sio.volume != nil { |
| t.Errorf("volume not nil after delete operation") |
| } |
| } |
| func TestMgrDeleteVolume_VolumeNotFound(t *testing.T) { |
| mgr := newTestMgr(t) |
| mgr.CreateVolume("test-vol-0001", 8*1024*1024) |
| err := mgr.DeleteVolume("test-vol-0002") |
| if err == nil { |
| t.Fatal("expected volume not found error") |
| } |
| } |
| |
| // ************************************************************ |
| // Helper Test Types |
| // ************************************************************ |
| type fakeSio struct { |
| volume *siotypes.Volume |
| waitAttachCtrl chan struct{} |
| waitDetachCtrl chan struct{} |
| devs map[string]string |
| isMultiMap bool |
| } |
| |
| func newFakeSio() *fakeSio { |
| return &fakeSio{ |
| waitAttachCtrl: make(chan struct{}), |
| waitDetachCtrl: make(chan struct{}), |
| } |
| } |
| |
| func (f *fakeSio) FindVolume(volumeName string) (*siotypes.Volume, error) { |
| if f.volume == nil || f.volume.Name != volumeName { |
| return nil, errors.New("volume not found") |
| } |
| return f.volume, nil |
| } |
| |
| func (f *fakeSio) Volume(id sioVolumeID) (*siotypes.Volume, error) { |
| if f.volume == nil || f.volume.ID != string(id) { |
| return nil, errors.New("volume not found") |
| } |
| return f.volume, nil |
| } |
| |
| func (f *fakeSio) CreateVolume(volName string, sizeGB int64) (*siotypes.Volume, error) { |
| f.volume = &siotypes.Volume{ |
| ID: fakeVolumeID, |
| Name: volName, |
| SizeInKb: int(sizeGB), |
| VolumeType: "test", |
| } |
| |
| return f.volume, nil |
| } |
| |
| func (f *fakeSio) AttachVolume(id sioVolumeID, multiMaps bool) error { |
| f.isMultiMap = multiMaps |
| _, err := f.Volume(id) |
| if err != nil { |
| return err |
| } |
| f.volume.MappedSdcInfo = []*siotypes.MappedSdcInfo{ |
| {SdcID: fakeSdcID}, |
| } |
| |
| return nil |
| } |
| |
| func (f *fakeSio) DetachVolume(id sioVolumeID) error { |
| if _, err := f.Volume(id); err != nil { |
| return err |
| } |
| f.volume.MappedSdcInfo = nil |
| delete(f.devs, f.volume.ID) |
| |
| return nil |
| } |
| |
| func (f *fakeSio) DeleteVolume(id sioVolumeID) error { |
| if _, err := f.Volume(id); err != nil { |
| return err |
| } |
| f.volume = nil |
| return nil |
| } |
| |
| func (f *fakeSio) IID() (string, error) { |
| return fakeSdcID, nil |
| } |
| |
| func (f *fakeSio) Devs() (map[string]string, error) { |
| if f.volume == nil { |
| return nil, errors.New("volume not found") |
| } |
| f.devs = map[string]string{ |
| f.volume.ID: fakeDev, |
| } |
| |
| return f.devs, nil |
| } |
| |
| func (f *fakeSio) GetVolumeRefs(volID sioVolumeID) (int, error) { |
| if f.volume == nil { |
| return 0, nil |
| } |
| return 1, nil |
| } |
| |
| func (f *fakeSio) WaitForAttachedDevice(token string) (string, error) { |
| select { |
| case <-time.After(500 * time.Millisecond): |
| return fakeDev, nil |
| case <-f.waitAttachCtrl: |
| return "", errors.New("attached device timeout") |
| } |
| } |
| |
| func (f *fakeSio) WaitForDetachedDevice(token string) error { |
| select { |
| case <-time.After(500 * time.Millisecond): |
| delete(f.devs, f.volume.ID) |
| return nil |
| case <-f.waitDetachCtrl: |
| return errors.New("detach device timeout") |
| } |
| } |
