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