github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/state/status_filesystem_test.go (about)

     1  // Copyright 2012-2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package state_test
     5  
     6  import (
     7  	jc "github.com/juju/testing/checkers"
     8  	gc "gopkg.in/check.v1"
     9  
    10  	"github.com/juju/juju/state"
    11  	"github.com/juju/juju/status"
    12  )
    13  
    14  type FilesystemStatusSuite struct {
    15  	StorageStateSuiteBase
    16  	machine    *state.Machine
    17  	filesystem state.Filesystem
    18  }
    19  
    20  var _ = gc.Suite(&FilesystemStatusSuite{})
    21  
    22  func (s *FilesystemStatusSuite) SetUpTest(c *gc.C) {
    23  	s.StorageStateSuiteBase.SetUpTest(c)
    24  
    25  	machine, err := s.State.AddOneMachine(state.MachineTemplate{
    26  		Series: "quantal",
    27  		Jobs:   []state.MachineJob{state.JobHostUnits},
    28  		Filesystems: []state.MachineFilesystemParams{{
    29  			Filesystem: state.FilesystemParams{
    30  				Pool: "environscoped", Size: 1024,
    31  			},
    32  		}},
    33  	})
    34  	c.Assert(err, jc.ErrorIsNil)
    35  
    36  	filesystemAttachments, err := s.State.MachineFilesystemAttachments(machine.MachineTag())
    37  	c.Assert(err, jc.ErrorIsNil)
    38  	c.Assert(filesystemAttachments, gc.HasLen, 1)
    39  
    40  	filesystem, err := s.State.Filesystem(filesystemAttachments[0].Filesystem())
    41  	c.Assert(err, jc.ErrorIsNil)
    42  
    43  	s.machine = machine
    44  	s.filesystem = filesystem
    45  }
    46  
    47  func (s *FilesystemStatusSuite) TestInitialStatus(c *gc.C) {
    48  	s.checkInitialStatus(c)
    49  }
    50  
    51  func (s *FilesystemStatusSuite) checkInitialStatus(c *gc.C) {
    52  	statusInfo, err := s.filesystem.Status()
    53  	c.Check(err, jc.ErrorIsNil)
    54  	c.Check(statusInfo.Status, gc.Equals, status.StatusPending)
    55  	c.Check(statusInfo.Message, gc.Equals, "")
    56  	c.Check(statusInfo.Data, gc.HasLen, 0)
    57  	c.Check(statusInfo.Since, gc.NotNil)
    58  }
    59  
    60  func (s *FilesystemStatusSuite) TestSetErrorStatusWithoutInfo(c *gc.C) {
    61  	err := s.filesystem.SetStatus(status.StatusError, "", nil)
    62  	c.Check(err, gc.ErrorMatches, `cannot set status "error" without info`)
    63  
    64  	s.checkInitialStatus(c)
    65  }
    66  
    67  func (s *FilesystemStatusSuite) TestSetUnknownStatus(c *gc.C) {
    68  	err := s.filesystem.SetStatus(status.Status("vliegkat"), "orville", nil)
    69  	c.Assert(err, gc.ErrorMatches, `cannot set invalid status "vliegkat"`)
    70  
    71  	s.checkInitialStatus(c)
    72  }
    73  
    74  func (s *FilesystemStatusSuite) TestSetOverwritesData(c *gc.C) {
    75  	err := s.filesystem.SetStatus(status.StatusAttaching, "blah", map[string]interface{}{
    76  		"pew.pew": "zap",
    77  	})
    78  	c.Check(err, jc.ErrorIsNil)
    79  
    80  	s.checkGetSetStatus(c)
    81  }
    82  
    83  func (s *FilesystemStatusSuite) TestGetSetStatusAlive(c *gc.C) {
    84  	s.checkGetSetStatus(c)
    85  }
    86  
    87  func (s *FilesystemStatusSuite) checkGetSetStatus(c *gc.C) {
    88  	err := s.filesystem.SetStatus(status.StatusAttaching, "blah", map[string]interface{}{
    89  		"$foo.bar.baz": map[string]interface{}{
    90  			"pew.pew": "zap",
    91  		},
    92  	})
    93  	c.Check(err, jc.ErrorIsNil)
    94  
    95  	filesystem, err := s.State.Filesystem(s.filesystem.FilesystemTag())
    96  	c.Assert(err, jc.ErrorIsNil)
    97  
    98  	statusInfo, err := filesystem.Status()
    99  	c.Check(err, jc.ErrorIsNil)
   100  	c.Check(statusInfo.Status, gc.Equals, status.StatusAttaching)
   101  	c.Check(statusInfo.Message, gc.Equals, "blah")
   102  	c.Check(statusInfo.Data, jc.DeepEquals, map[string]interface{}{
   103  		"$foo.bar.baz": map[string]interface{}{
   104  			"pew.pew": "zap",
   105  		},
   106  	})
   107  	c.Check(statusInfo.Since, gc.NotNil)
   108  }
   109  
   110  func (s *FilesystemStatusSuite) TestGetSetStatusDying(c *gc.C) {
   111  	err := s.State.DestroyFilesystem(s.filesystem.FilesystemTag())
   112  	c.Assert(err, jc.ErrorIsNil)
   113  
   114  	s.checkGetSetStatus(c)
   115  }
   116  
   117  func (s *FilesystemStatusSuite) TestGetSetStatusDead(c *gc.C) {
   118  	err := s.State.DestroyFilesystem(s.filesystem.FilesystemTag())
   119  	c.Assert(err, jc.ErrorIsNil)
   120  	err = s.State.DetachFilesystem(s.machine.MachineTag(), s.filesystem.FilesystemTag())
   121  	c.Assert(err, jc.ErrorIsNil)
   122  	err = s.State.RemoveFilesystemAttachment(s.machine.MachineTag(), s.filesystem.FilesystemTag())
   123  	c.Assert(err, jc.ErrorIsNil)
   124  
   125  	filesystem, err := s.State.Filesystem(s.filesystem.FilesystemTag())
   126  	c.Assert(err, jc.ErrorIsNil)
   127  	c.Assert(filesystem.Life(), gc.Equals, state.Dead)
   128  
   129  	// NOTE: it would be more technically correct to reject status updates
   130  	// while Dead, but it's easier and clearer, not to mention more efficient,
   131  	// to just depend on status doc existence.
   132  	s.checkGetSetStatus(c)
   133  }
   134  
   135  func (s *FilesystemStatusSuite) TestGetSetStatusGone(c *gc.C) {
   136  	s.obliterateFilesystem(c, s.filesystem.FilesystemTag())
   137  
   138  	err := s.filesystem.SetStatus(status.StatusAttaching, "not really", nil)
   139  	c.Check(err, gc.ErrorMatches, `cannot set status: filesystem not found`)
   140  
   141  	statusInfo, err := s.filesystem.Status()
   142  	c.Check(err, gc.ErrorMatches, `cannot get status: filesystem not found`)
   143  	c.Check(statusInfo, gc.DeepEquals, status.StatusInfo{})
   144  }
   145  
   146  func (s *FilesystemStatusSuite) TestSetStatusPendingUnprovisioned(c *gc.C) {
   147  	err := s.filesystem.SetStatus(status.StatusPending, "still", nil)
   148  	c.Check(err, jc.ErrorIsNil)
   149  }
   150  
   151  func (s *FilesystemStatusSuite) TestSetStatusPendingProvisioned(c *gc.C) {
   152  	err := s.State.SetFilesystemInfo(s.filesystem.FilesystemTag(), state.FilesystemInfo{
   153  		FilesystemId: "fs-id",
   154  	})
   155  	c.Assert(err, jc.ErrorIsNil)
   156  	err = s.filesystem.SetStatus(status.StatusPending, "", nil)
   157  	c.Check(err, gc.ErrorMatches, `cannot set status "pending"`)
   158  }