Merge pull request #155 from akutz/feature/mock-drivers

Mock Drivers Refactor

drivers/drivers.go

@@ -2,6 +2,7 @@ package drivers
 
 import (
 	// loads the drivers
+	_ "github.com/emccode/rexray/drivers/mock"
 	_ "github.com/emccode/rexray/drivers/os"
 	_ "github.com/emccode/rexray/drivers/storage"
 	_ "github.com/emccode/rexray/drivers/volume"

drivers/mock/mock.go

@@ -0,0 +1,67 @@
+package mock
+
+import (
+	"os"
+	"strconv"
+
+	log "github.com/Sirupsen/logrus"
+	"github.com/emccode/rexray/core"
+)
+
+const (
+	// MockOSDriverName is the name of a mock OS driver used primarily for
+	// testing.
+	MockOSDriverName = "mockOSDriver"
+
+	// MockVolDriverName is the name of a mock volume driver used primarily for
+	// testing.
+	MockVolDriverName = "mockVolumeDriver"
+
+	// MockStorDriverName is the name of a mock storage driver used primarily
+	// for testing.
+	MockStorDriverName = "mockStorageDriver"
+
+	// BadMockOSDriverName is the name of a mock OS driver used primarily for
+	// testing.
+	BadMockOSDriverName = "badMockOSDriver"
+
+	// BadMockVolDriverName is the name of a mock volume driver used primarily
+	// for testing.
+	BadMockVolDriverName = "badMockVolumeDriver"
+
+	// BadMockStorDriverName is the name of a mock storage driver used primarily
+	// for testing.
+	BadMockStorDriverName = "badMockStorageDriver"
+)
+
+func init() {
+	v := os.Getenv("REXRAY_MOCKDRIVERS")
+	log.WithField("REXRAY_MOCKDRIVERS", v).Debug("got REXRAY_MOCKDRIVERS")
+
+	if b, err := strconv.ParseBool(v); !b || err != nil {
+		if err != nil {
+			log.WithError(err).WithField("REXRAY_MOCKDRIVERS", v).Error(
+				"error parsing REXRAY_MOCKDRIVERS")
+		}
+		log.Debug("not registering mock drivers")
+		return
+	}
+
+	RegisterMockDrivers()
+}
+
+// RegisterMockDrivers registers the mock drivers.
+func RegisterMockDrivers() {
+	log.Debug("registering mock drivers")
+	core.RegisterDriver(MockOSDriverName, newOSDriver)
+	core.RegisterDriver(MockVolDriverName, newVolDriver)
+	core.RegisterDriver(MockStorDriverName, newStorDriver)
+}
+
+// RegisterBadMockDrivers registers the bad mock drivers.
+func RegisterBadMockDrivers() {
+	log.Debug("registering bad mock drivers")
+	core.RegisterDriver(BadMockOSDriverName, newBadOSDriver)
+	core.RegisterDriver(BadMockVolDriverName, newBadVolDriver)
+	core.RegisterDriver(BadMockStorDriverName, newBadStorDriver)
+}

drivers/mock/mock_os_driver.go

@@ -0,0 +1,56 @@
+package mock
+
+import (
+	"github.com/emccode/rexray/core"
+	"github.com/emccode/rexray/core/errors"
+)
+
+type mockOSDriver struct {
+	name string
+}
+
+type badMockOSDriver struct {
+	mockOSDriver
+}
+
+func newOSDriver() core.Driver {
+	var d core.OSDriver = &mockOSDriver{MockOSDriverName}
+	return d
+}
+
+func newBadOSDriver() core.Driver {
+	var d core.OSDriver = &badMockOSDriver{mockOSDriver{BadMockOSDriverName}}
+	return d
+}
+
+func (m *mockOSDriver) Init(r *core.RexRay) error {
+	return nil
+}
+
+func (m *badMockOSDriver) Init(r *core.RexRay) error {
+	return errors.New("init error")
+}
+
+func (m *mockOSDriver) Name() string {
+	return m.name
+}
+
+func (m *mockOSDriver) GetMounts(string, string) (core.MountInfoArray, error) {
+	return nil, nil
+}
+
+func (m *mockOSDriver) Mounted(string) (bool, error) {
+	return false, nil
+}
+
+func (m *mockOSDriver) Unmount(string) error {
+	return nil
+}
+
+func (m *mockOSDriver) Mount(string, string, string, string) error {
+	return nil
+}
+
+func (m *mockOSDriver) Format(string, string, bool) error {
+	return nil
+}

drivers/mock/mock_storage_driver.go

@@ -0,0 +1,115 @@
+package mock
+
+import (
+	"github.com/emccode/rexray/core"
+	"github.com/emccode/rexray/core/errors"
+)
+
+type mockStorDriver struct {
+	name string
+}
+
+type badMockStorDriver struct {
+	mockStorDriver
+}
+
+func newStorDriver() core.Driver {
+	var d core.StorageDriver = &mockStorDriver{MockStorDriverName}
+	return d
+}
+
+func newBadStorDriver() core.Driver {
+	var d core.StorageDriver = &badMockStorDriver{
+		mockStorDriver{BadMockStorDriverName}}
+	return d
+}
+
+func (m *mockStorDriver) Init(r *core.RexRay) error {
+	return nil
+}
+
+func (m *badMockStorDriver) Init(r *core.RexRay) error {
+	return errors.New("init error")
+}
+
+func (m *mockStorDriver) Name() string {
+	return m.name
+}
+
+func (m *mockStorDriver) GetVolumeMapping() ([]*core.BlockDevice, error) {
+	return []*core.BlockDevice{&core.BlockDevice{
+		DeviceName:   "test",
+		ProviderName: m.name,
+		InstanceID:   "test",
+		Region:       "test",
+	}}, nil
+}
+
+func (m *mockStorDriver) GetInstance() (*core.Instance, error) {
+	return &core.Instance{
+		Name:         "test",
+		InstanceID:   "test",
+		ProviderName: m.name,
+		Region:       "test"}, nil
+}
+
+func (m *mockStorDriver) GetVolume(
+	volumeID, volumeName string) ([]*core.Volume, error) {
+	return []*core.Volume{&core.Volume{
+		Name:             "test",
+		VolumeID:         "test",
+		AvailabilityZone: "test",
+	}}, nil
+}
+
+func (m *mockStorDriver) GetVolumeAttach(
+	volumeID, instanceID string) ([]*core.VolumeAttachment, error) {
+	return nil, nil
+}
+
+func (m *mockStorDriver) CreateSnapshot(
+	runAsync bool,
+	snapshotName, volumeID, description string) ([]*core.Snapshot, error) {
+	return nil, nil
+}
+
+func (m *mockStorDriver) GetSnapshot(
+	volumeID, snapshotID, snapshotName string) ([]*core.Snapshot, error) {
+	return nil, nil
+}
+
+func (m *mockStorDriver) RemoveSnapshot(snapshotID string) error {
+	return nil
+}
+
+func (m *mockStorDriver) CreateVolume(
+	runAsync bool,
+	volumeName, volumeID, snapshotID, volumeType string,
+	IOPS, size int64,
+	availabilityZone string) (*core.Volume, error) {
+	return nil, nil
+}
+
+func (m *mockStorDriver) RemoveVolume(volumeID string) error {
+	return nil
+}
+
+func (m *mockStorDriver) GetDeviceNextAvailable() (string, error) {
+	return "", nil
+}
+
+func (m *mockStorDriver) AttachVolume(
+	runAsync bool, volumeID, instanceID string) ([]*core.VolumeAttachment, error) {
+	return nil, nil
+}
+
+func (m *mockStorDriver) DetachVolume(
+	runAsync bool, volumeID string, instanceID string) error {
+	return nil
+}
+
+func (m *mockStorDriver) CopySnapshot(
+	runAsync bool, volumeID, snapshotID, snapshotName,
+	destinationSnapshotName, destinationRegion string) (*core.Snapshot, error) {
+	return nil, nil
+}

drivers/mock/mock_volume_driver.go

@@ -0,0 +1,74 @@
+package mock
+
+import (
+	"github.com/emccode/rexray/core"
+	"github.com/emccode/rexray/core/errors"
+)
+
+const mockVolDriverName = "mockVolumeDriver"
+
+type mockVolDriver struct {
+	name string
+}
+
+type badMockVolDriver struct {
+	mockVolDriver
+}
+
+func newVolDriver() core.Driver {
+	var d core.VolumeDriver = &mockVolDriver{mockVolDriverName}
+	return d
+}
+
+func newBadVolDriver() core.Driver {
+	var d core.VolumeDriver = &badMockVolDriver{
+		mockVolDriver{BadMockVolDriverName}}
+	return d
+}
+
+func (m *mockVolDriver) Init(r *core.RexRay) error {
+	return nil
+}
+
+func (m *badMockVolDriver) Init(r *core.RexRay) error {
+	return errors.New("init error")
+}
+
+func (m *mockVolDriver) Name() string {
+	return m.name
+}
+
+func (m *mockVolDriver) Mount(
+	volumeName, volumeID string,
+	overwriteFs bool, newFsType string) (string, error) {
+	return "", nil
+}
+
+func (m *mockVolDriver) Unmount(volumeName, volumeID string) error {
+	return nil
+}
+
+func (m *mockVolDriver) Path(volumeName, volumeID string) (string, error) {
+	return "", nil
+}
+
+func (m *mockVolDriver) Create(volumeName string, opts core.VolumeOpts) error {
+	return nil
+}
+
+func (m *mockVolDriver) Remove(volumeName string) error {
+	return nil
+}
+
+func (m *mockVolDriver) Attach(volumeName, instanceID string) (string, error) {
+	return "", nil
+}
+
+func (m *mockVolDriver) Detach(volumeName, instanceID string) error {
+	return nil
+}
+
+func (m *mockVolDriver) NetworkName(
+	volumeName, instanceID string) (string, error) {
+	return "", nil
+}