github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/apiserver/storage/storageadd_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  	"fmt"
     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 storageAddSuite struct {
    19  	baseStorageSuite
    20  }
    21  
    22  var _ = gc.Suite(&storageAddSuite{})
    23  
    24  func (s *storageAddSuite) assertStorageAddedNoErrors(c *gc.C, args params.StorageAddParams) {
    25  	s.assertStoragesAddedNoErrors(c,
    26  		params.StoragesAddParams{[]params.StorageAddParams{args}},
    27  	)
    28  }
    29  
    30  func (s *storageAddSuite) assertStoragesAddedNoErrors(c *gc.C, args params.StoragesAddParams) {
    31  	failures, err := s.api.AddToUnit(args)
    32  	c.Assert(err, jc.ErrorIsNil)
    33  	c.Assert(failures.Results, gc.HasLen, len(args.Storages))
    34  	for _, one := range failures.Results {
    35  		c.Assert(one.Error, gc.IsNil)
    36  	}
    37  }
    38  
    39  func (s *storageAddSuite) TestStorageAddEmpty(c *gc.C) {
    40  	s.assertStoragesAddedNoErrors(c, params.StoragesAddParams{Storages: nil})
    41  	s.assertStoragesAddedNoErrors(c, params.StoragesAddParams{Storages: []params.StorageAddParams{}})
    42  }
    43  
    44  func (s *storageAddSuite) TestStorageAddUnit(c *gc.C) {
    45  	args := params.StorageAddParams{
    46  		UnitTag:     s.unitTag.String(),
    47  		StorageName: "data",
    48  	}
    49  	s.assertStorageAddedNoErrors(c, args)
    50  	s.assertCalls(c, []string{getBlockForTypeCall, addStorageForUnitCall})
    51  }
    52  
    53  func (s *storageAddSuite) TestStorageAddUnitBlocked(c *gc.C) {
    54  	s.blockAllChanges(c, "TestStorageAddUnitBlocked")
    55  
    56  	args := params.StorageAddParams{
    57  		UnitTag:     s.unitTag.String(),
    58  		StorageName: "data",
    59  	}
    60  	_, err := s.api.AddToUnit(params.StoragesAddParams{[]params.StorageAddParams{args}})
    61  	s.assertBlocked(c, err, "TestStorageAddUnitBlocked")
    62  }
    63  
    64  func (s *storageAddSuite) TestStorageAddUnitDestroyIgnored(c *gc.C) {
    65  	s.blockDestroyEnvironment(c, "TestStorageAddUnitDestroyIgnored")
    66  	s.blockRemoveObject(c, "TestStorageAddUnitDestroyIgnored")
    67  
    68  	args := params.StorageAddParams{
    69  		UnitTag:     s.unitTag.String(),
    70  		StorageName: "data",
    71  	}
    72  	s.assertStorageAddedNoErrors(c, args)
    73  	s.assertCalls(c, []string{getBlockForTypeCall, addStorageForUnitCall})
    74  }
    75  
    76  func (s *storageAddSuite) TestStorageAddUnitError(c *gc.C) {
    77  	args := params.StorageAddParams{
    78  		StorageName: "data",
    79  	}
    80  	failures, err := s.api.AddToUnit(params.StoragesAddParams{[]params.StorageAddParams{args}})
    81  	c.Assert(err, jc.ErrorIsNil)
    82  	c.Assert(failures.Results, gc.HasLen, 1)
    83  	c.Assert(failures.Results[0].Error.Error(), gc.Matches, ".*is not a valid tag.*")
    84  
    85  	expectedCalls := []string{getBlockForTypeCall}
    86  	s.assertCalls(c, expectedCalls)
    87  }
    88  
    89  func (s *storageAddSuite) TestStorageAddUnitStateError(c *gc.C) {
    90  	msg := "add test directive error"
    91  	s.state.addStorageForUnit = func(u names.UnitTag, name string, cons state.StorageConstraints) error {
    92  		s.calls = append(s.calls, addStorageForUnitCall)
    93  		return errors.Errorf(msg)
    94  	}
    95  
    96  	args := params.StorageAddParams{
    97  		UnitTag:     s.unitTag.String(),
    98  		StorageName: "data",
    99  	}
   100  	failures, err := s.api.AddToUnit(params.StoragesAddParams{[]params.StorageAddParams{args}})
   101  	c.Assert(err, jc.ErrorIsNil)
   102  	c.Assert(failures.Results, gc.HasLen, 1)
   103  	c.Assert(failures.Results[0].Error.Error(), gc.Matches, fmt.Sprintf(".*%v.*", msg))
   104  
   105  	s.assertCalls(c, []string{getBlockForTypeCall, addStorageForUnitCall})
   106  }
   107  
   108  func (s *storageAddSuite) TestStorageAddUnitPermError(c *gc.C) {
   109  	msg := "add test directive error"
   110  	s.state.addStorageForUnit = func(u names.UnitTag, name string, cons state.StorageConstraints) error {
   111  		s.calls = append(s.calls, addStorageForUnitCall)
   112  		return errors.NotFoundf(msg)
   113  	}
   114  
   115  	args := params.StorageAddParams{
   116  		UnitTag:     s.unitTag.String(),
   117  		StorageName: "data",
   118  	}
   119  	failures, err := s.api.AddToUnit(params.StoragesAddParams{[]params.StorageAddParams{args}})
   120  	c.Assert(err, jc.ErrorIsNil)
   121  	c.Assert(failures.Results, gc.HasLen, 1)
   122  	c.Assert(failures.Results[0].Error.Error(), gc.Matches, ".*permission denied.*")
   123  
   124  	s.assertCalls(c, []string{getBlockForTypeCall, addStorageForUnitCall})
   125  }
   126  
   127  func (s *storageAddSuite) TestStorageAddUnitResultOrder(c *gc.C) {
   128  	wrong0 := params.StorageAddParams{
   129  		StorageName: "data",
   130  	}
   131  	right := params.StorageAddParams{
   132  		UnitTag:     s.unitTag.String(),
   133  		StorageName: "data",
   134  	}
   135  	wrong1 := params.StorageAddParams{
   136  		UnitTag: s.unitTag.String(),
   137  	}
   138  	msg := "storage name missing error"
   139  	s.state.addStorageForUnit = func(u names.UnitTag, name string, cons state.StorageConstraints) error {
   140  		s.calls = append(s.calls, addStorageForUnitCall)
   141  		if name == "" {
   142  			return errors.Errorf(msg)
   143  		}
   144  		return nil
   145  	}
   146  	failures, err := s.api.AddToUnit(params.StoragesAddParams{
   147  		[]params.StorageAddParams{
   148  			wrong0,
   149  			right,
   150  			wrong1}})
   151  	c.Assert(err, jc.ErrorIsNil)
   152  	c.Assert(failures.Results, gc.HasLen, 3)
   153  	c.Assert(failures.Results[0].Error.Error(), gc.Matches, ".*is not a valid tag.*")
   154  	c.Assert(failures.Results[1].Error, gc.IsNil)
   155  	c.Assert(failures.Results[2].Error.Error(), gc.Matches, fmt.Sprintf(".*%v.*", msg))
   156  
   157  	s.assertCalls(c, []string{getBlockForTypeCall, addStorageForUnitCall, addStorageForUnitCall})
   158  }