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