github.com/cloud-green/juju@v0.0.0-20151002100041-a00291338d3d/apiserver/storage/volumelist_test.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package storage_test
     5  
     6  import (
     7  	"path/filepath"
     8  
     9  	"github.com/juju/errors"
    10  	"github.com/juju/names"
    11  	jc "github.com/juju/testing/checkers"
    12  	gc "gopkg.in/check.v1"
    13  
    14  	"github.com/juju/juju/apiserver/params"
    15  	"github.com/juju/juju/state"
    16  )
    17  
    18  type volumeSuite struct {
    19  	baseStorageSuite
    20  }
    21  
    22  var _ = gc.Suite(&volumeSuite{})
    23  
    24  func (s *volumeSuite) expectedVolumeDetailsResult() params.VolumeDetailsResult {
    25  	return params.VolumeDetailsResult{
    26  		Details: &params.VolumeDetails{
    27  			VolumeTag: s.volumeTag.String(),
    28  			Status: params.EntityStatus{
    29  				Status: "attached",
    30  			},
    31  			MachineAttachments: map[string]params.VolumeAttachmentInfo{
    32  				s.machineTag.String(): params.VolumeAttachmentInfo{},
    33  			},
    34  			Storage: &params.StorageDetails{
    35  				StorageTag: "storage-data-0",
    36  				OwnerTag:   "unit-mysql-0",
    37  				Kind:       params.StorageKindFilesystem,
    38  				Status: params.EntityStatus{
    39  					Status: "attached",
    40  				},
    41  				Attachments: map[string]params.StorageAttachmentDetails{
    42  					"unit-mysql-0": params.StorageAttachmentDetails{
    43  						StorageTag: "storage-data-0",
    44  						UnitTag:    "unit-mysql-0",
    45  						MachineTag: "machine-66",
    46  					},
    47  				},
    48  			},
    49  		},
    50  		LegacyVolume: &params.LegacyVolumeDetails{
    51  			VolumeTag:  s.volumeTag.String(),
    52  			StorageTag: "storage-data-0",
    53  			UnitTag:    "unit-mysql-0",
    54  			Status: params.EntityStatus{
    55  				Status: "attached",
    56  			},
    57  		},
    58  		LegacyAttachments: []params.VolumeAttachment{{
    59  			VolumeTag:  s.volumeTag.String(),
    60  			MachineTag: s.machineTag.String(),
    61  		}},
    62  	}
    63  }
    64  
    65  func (s *volumeSuite) TestListVolumesEmptyFilter(c *gc.C) {
    66  	found, err := s.api.ListVolumes(params.VolumeFilter{})
    67  	c.Assert(err, jc.ErrorIsNil)
    68  	c.Assert(found.Results, gc.HasLen, 1)
    69  	c.Assert(found.Results[0], gc.DeepEquals, s.expectedVolumeDetailsResult())
    70  }
    71  
    72  func (s *volumeSuite) TestListVolumesError(c *gc.C) {
    73  	msg := "inventing error"
    74  	s.state.allVolumes = func() ([]state.Volume, error) {
    75  		return nil, errors.New(msg)
    76  	}
    77  	_, err := s.api.ListVolumes(params.VolumeFilter{})
    78  	c.Assert(err, gc.ErrorMatches, msg)
    79  }
    80  
    81  func (s *volumeSuite) TestListVolumesNoVolumes(c *gc.C) {
    82  	s.state.allVolumes = func() ([]state.Volume, error) {
    83  		return nil, nil
    84  	}
    85  	results, err := s.api.ListVolumes(params.VolumeFilter{})
    86  	c.Assert(err, jc.ErrorIsNil)
    87  	c.Assert(results.Results, gc.HasLen, 0)
    88  }
    89  
    90  func (s *volumeSuite) TestListVolumesFilter(c *gc.C) {
    91  	filter := params.VolumeFilter{
    92  		Machines: []string{s.machineTag.String()},
    93  	}
    94  	found, err := s.api.ListVolumes(filter)
    95  	c.Assert(err, jc.ErrorIsNil)
    96  	c.Assert(found.Results, gc.HasLen, 1)
    97  	c.Assert(found.Results[0], jc.DeepEquals, s.expectedVolumeDetailsResult())
    98  }
    99  
   100  func (s *volumeSuite) TestListVolumesFilterNonMatching(c *gc.C) {
   101  	filter := params.VolumeFilter{
   102  		Machines: []string{"machine-42"},
   103  	}
   104  	found, err := s.api.ListVolumes(filter)
   105  	c.Assert(err, jc.ErrorIsNil)
   106  	c.Assert(found.Results, gc.HasLen, 0)
   107  }
   108  
   109  func (s *volumeSuite) TestListVolumesVolumeInfo(c *gc.C) {
   110  	s.volume.info = &state.VolumeInfo{
   111  		Size:       123,
   112  		HardwareId: "abc",
   113  		Persistent: true,
   114  	}
   115  	expected := s.expectedVolumeDetailsResult()
   116  	expected.Details.Info.Size = 123
   117  	expected.Details.Info.HardwareId = "abc"
   118  	expected.Details.Info.Persistent = true
   119  	expected.LegacyVolume.Size = 123
   120  	expected.LegacyVolume.HardwareId = "abc"
   121  	expected.LegacyVolume.Persistent = true
   122  	found, err := s.api.ListVolumes(params.VolumeFilter{})
   123  	c.Assert(err, jc.ErrorIsNil)
   124  	c.Assert(found.Results, gc.HasLen, 1)
   125  	c.Assert(found.Results[0], jc.DeepEquals, expected)
   126  }
   127  
   128  func (s *volumeSuite) TestListVolumesAttachmentInfo(c *gc.C) {
   129  	s.volumeAttachment.info = &state.VolumeAttachmentInfo{
   130  		DeviceName: "xvdf1",
   131  		ReadOnly:   true,
   132  	}
   133  	expected := s.expectedVolumeDetailsResult()
   134  	expected.Details.MachineAttachments[s.machineTag.String()] = params.VolumeAttachmentInfo{
   135  		DeviceName: "xvdf1",
   136  		ReadOnly:   true,
   137  	}
   138  	expected.LegacyAttachments[0].Info = params.VolumeAttachmentInfo{
   139  		DeviceName: "xvdf1",
   140  		ReadOnly:   true,
   141  	}
   142  	found, err := s.api.ListVolumes(params.VolumeFilter{})
   143  	c.Assert(err, jc.ErrorIsNil)
   144  	c.Assert(found.Results, gc.HasLen, 1)
   145  	c.Assert(found.Results[0], jc.DeepEquals, expected)
   146  }
   147  
   148  func (s *volumeSuite) TestListVolumesStorageLocationNoBlockDevice(c *gc.C) {
   149  	s.storageInstance.kind = state.StorageKindBlock
   150  	s.volume.info = &state.VolumeInfo{}
   151  	s.volumeAttachment.info = &state.VolumeAttachmentInfo{
   152  		ReadOnly: true,
   153  	}
   154  	expected := s.expectedVolumeDetailsResult()
   155  	expected.Details.Storage.Kind = params.StorageKindBlock
   156  	expected.Details.Storage.Status.Status = params.StatusAttached
   157  	expected.Details.MachineAttachments[s.machineTag.String()] = params.VolumeAttachmentInfo{
   158  		ReadOnly: true,
   159  	}
   160  	expected.LegacyAttachments[0].Info = params.VolumeAttachmentInfo{
   161  		ReadOnly: true,
   162  	}
   163  	found, err := s.api.ListVolumes(params.VolumeFilter{})
   164  	c.Assert(err, jc.ErrorIsNil)
   165  	c.Assert(found.Results, gc.HasLen, 1)
   166  	c.Assert(found.Results[0], jc.DeepEquals, expected)
   167  }
   168  
   169  func (s *volumeSuite) TestListVolumesStorageLocationBlockDevicePath(c *gc.C) {
   170  	s.state.blockDevices = func(names.MachineTag) ([]state.BlockDeviceInfo, error) {
   171  		return []state.BlockDeviceInfo{{
   172  			BusAddress: "bus-addr",
   173  			DeviceName: "sdd",
   174  		}}, nil
   175  	}
   176  	s.storageInstance.kind = state.StorageKindBlock
   177  	s.volume.info = &state.VolumeInfo{}
   178  	s.volumeAttachment.info = &state.VolumeAttachmentInfo{
   179  		BusAddress: "bus-addr",
   180  		ReadOnly:   true,
   181  	}
   182  	expected := s.expectedVolumeDetailsResult()
   183  	expected.Details.Storage.Kind = params.StorageKindBlock
   184  	expected.Details.Storage.Status.Status = params.StatusAttached
   185  	storageAttachmentDetails := expected.Details.Storage.Attachments["unit-mysql-0"]
   186  	storageAttachmentDetails.Location = filepath.FromSlash("/dev/sdd")
   187  	expected.Details.Storage.Attachments["unit-mysql-0"] = storageAttachmentDetails
   188  	expected.Details.MachineAttachments[s.machineTag.String()] = params.VolumeAttachmentInfo{
   189  		BusAddress: "bus-addr",
   190  		ReadOnly:   true,
   191  	}
   192  	expected.LegacyAttachments[0].Info = params.VolumeAttachmentInfo{
   193  		BusAddress: "bus-addr",
   194  		ReadOnly:   true,
   195  	}
   196  	found, err := s.api.ListVolumes(params.VolumeFilter{})
   197  	c.Assert(err, jc.ErrorIsNil)
   198  	c.Assert(found.Results, gc.HasLen, 1)
   199  	c.Assert(found.Results[0], jc.DeepEquals, expected)
   200  }