github.com/mhilton/juju-juju@v0.0.0-20150901100907-a94dd2c73455/cmd/juju/storage/list_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/cmd"
     8  	jc "github.com/juju/testing/checkers"
     9  	gc "gopkg.in/check.v1"
    10  
    11  	"github.com/juju/juju/apiserver/params"
    12  	"github.com/juju/juju/cmd/envcmd"
    13  	"github.com/juju/juju/cmd/juju/storage"
    14  	_ "github.com/juju/juju/provider/dummy"
    15  	"github.com/juju/juju/testing"
    16  )
    17  
    18  type ListSuite struct {
    19  	SubStorageSuite
    20  	mockAPI *mockListAPI
    21  }
    22  
    23  var _ = gc.Suite(&ListSuite{})
    24  
    25  func (s *ListSuite) SetUpTest(c *gc.C) {
    26  	s.SubStorageSuite.SetUpTest(c)
    27  
    28  	s.mockAPI = &mockListAPI{}
    29  	s.PatchValue(storage.GetStorageListAPI, func(c *storage.ListCommand) (storage.StorageListAPI, error) {
    30  		return s.mockAPI, nil
    31  	})
    32  
    33  }
    34  
    35  func runList(c *gc.C, args []string) (*cmd.Context, error) {
    36  	return testing.RunCommand(c, envcmd.Wrap(&storage.ListCommand{}), args...)
    37  }
    38  
    39  func (s *ListSuite) TestList(c *gc.C) {
    40  	s.assertValidList(
    41  		c,
    42  		nil,
    43  		// Default format is tabular
    44  		`
    45  [Storage]    
    46  UNIT         ID          LOCATION STATUS  PERSISTENT 
    47  postgresql/0 db-dir/1100          pending false      
    48  transcode/0  db-dir/1000          pending true       
    49  transcode/0  db-dir/1100          pending false      
    50  transcode/0  shared-fs/0          pending false      
    51  transcode/1  shared-fs/0          pending false      
    52  
    53  `[1:],
    54  		"",
    55  	)
    56  }
    57  
    58  func (s *ListSuite) TestListYAML(c *gc.C) {
    59  	s.assertValidList(
    60  		c,
    61  		[]string{"--format", "yaml"},
    62  		`
    63  postgresql/0:
    64    db-dir/1100:
    65      storage: db-dir
    66      kind: filesystem
    67      status: pending
    68      persistent: false
    69  transcode/0:
    70    db-dir/1000:
    71      storage: db-dir
    72      kind: block
    73      status: pending
    74      persistent: true
    75    db-dir/1100:
    76      storage: db-dir
    77      kind: filesystem
    78      status: pending
    79      persistent: false
    80    shared-fs/0:
    81      storage: shared-fs
    82      kind: unknown
    83      status: pending
    84      persistent: false
    85  transcode/1:
    86    shared-fs/0:
    87      storage: shared-fs
    88      kind: unknown
    89      status: pending
    90      persistent: false
    91  `[1:],
    92  		"",
    93  	)
    94  }
    95  
    96  func (s *ListSuite) TestListOwnerStorageIdSort(c *gc.C) {
    97  	s.mockAPI.lexicalChaos = true
    98  	s.assertValidList(
    99  		c,
   100  		nil,
   101  		// Default format is tabular
   102  		`
   103  [Storage]    
   104  UNIT         ID          LOCATION STATUS  PERSISTENT 
   105  postgresql/0 db-dir/1100          pending false      
   106  transcode/0  db-dir/1000          pending true       
   107  transcode/0  db-dir/1100          pending false      
   108  transcode/0  shared-fs/0          pending false      
   109  transcode/0  shared-fs/5          pending false      
   110  transcode/1  db-dir/1000          pending true       
   111  transcode/1  shared-fs/0          pending false      
   112  
   113  `[1:],
   114  		`
   115  error for storage-db-dir-1010
   116  error for test storage-db-dir-1010
   117  `[1:],
   118  	)
   119  }
   120  
   121  func (s *ListSuite) assertValidList(c *gc.C, args []string, expectedValid, expectedErr string) {
   122  	context, err := runList(c, args)
   123  	c.Assert(err, jc.ErrorIsNil)
   124  
   125  	obtainedErr := testing.Stderr(context)
   126  	c.Assert(obtainedErr, gc.Equals, expectedErr)
   127  
   128  	obtainedValid := testing.Stdout(context)
   129  	c.Assert(obtainedValid, gc.Equals, expectedValid)
   130  }
   131  
   132  type mockListAPI struct {
   133  	lexicalChaos bool
   134  }
   135  
   136  func (s mockListAPI) Close() error {
   137  	return nil
   138  }
   139  
   140  func (s mockListAPI) List() ([]params.StorageInfo, error) {
   141  	result := []params.StorageInfo{}
   142  	result = append(result, getTestAttachments(s.lexicalChaos)...)
   143  	result = append(result, getTestInstances(s.lexicalChaos)...)
   144  	return result, nil
   145  }
   146  
   147  func getTestAttachments(chaos bool) []params.StorageInfo {
   148  	results := []params.StorageInfo{{
   149  		params.StorageDetails{
   150  			StorageTag: "storage-shared-fs-0",
   151  			OwnerTag:   "service-transcode",
   152  			UnitTag:    "unit-transcode-0",
   153  			Kind:       params.StorageKindBlock,
   154  			Location:   "here",
   155  			Status:     "attached",
   156  		}, nil}, {
   157  		params.StorageDetails{
   158  			StorageTag: "storage-db-dir-1000",
   159  			OwnerTag:   "unit-transcode-0",
   160  			UnitTag:    "unit-transcode-0",
   161  			Kind:       params.StorageKindUnknown,
   162  			Location:   "there",
   163  			Status:     "provisioned",
   164  			Persistent: true,
   165  		}, nil}}
   166  
   167  	if chaos {
   168  		last := params.StorageInfo{
   169  			params.StorageDetails{
   170  				StorageTag: "storage-shared-fs-5",
   171  				OwnerTag:   "service-transcode",
   172  				UnitTag:    "unit-transcode-0",
   173  				Kind:       params.StorageKindUnknown,
   174  				Location:   "nowhere",
   175  				Status:     "pending",
   176  			}, nil}
   177  		second := params.StorageInfo{
   178  			params.StorageDetails{
   179  				StorageTag: "storage-db-dir-1010",
   180  				OwnerTag:   "unit-transcode-1",
   181  				UnitTag:    "unit-transcode-1",
   182  				Kind:       params.StorageKindBlock,
   183  				Location:   "",
   184  				Status:     "pending",
   185  			}, &params.Error{Message: "error for storage-db-dir-1010"}}
   186  		first := params.StorageInfo{
   187  			params.StorageDetails{
   188  				StorageTag: "storage-db-dir-1000",
   189  				OwnerTag:   "unit-transcode-1",
   190  				UnitTag:    "unit-transcode-1",
   191  				Kind:       params.StorageKindFilesystem,
   192  				Status:     "attached",
   193  				Persistent: true,
   194  			}, nil}
   195  		results = append(results, last)
   196  		results = append(results, second)
   197  		results = append(results, first)
   198  	}
   199  	return results
   200  }
   201  
   202  func getTestInstances(chaos bool) []params.StorageInfo {
   203  
   204  	results := []params.StorageInfo{
   205  		{
   206  			params.StorageDetails{
   207  				StorageTag: "storage-shared-fs-0",
   208  				OwnerTag:   "service-transcode",
   209  				UnitTag:    "unit-transcode-0",
   210  				Kind:       params.StorageKindUnknown,
   211  				Status:     "pending",
   212  			}, nil},
   213  		{
   214  			params.StorageDetails{
   215  				StorageTag: "storage-shared-fs-0",
   216  				OwnerTag:   "service-transcode",
   217  				UnitTag:    "unit-transcode-1",
   218  				Kind:       params.StorageKindUnknown,
   219  				Status:     "pending",
   220  			}, nil},
   221  		{
   222  			params.StorageDetails{
   223  				StorageTag: "storage-db-dir-1100",
   224  				UnitTag:    "unit-postgresql-0",
   225  				Kind:       params.StorageKindFilesystem,
   226  				Status:     "pending",
   227  			}, nil},
   228  		{
   229  			params.StorageDetails{
   230  				StorageTag: "storage-db-dir-1100",
   231  				UnitTag:    "unit-transcode-0",
   232  				Kind:       params.StorageKindFilesystem,
   233  				Status:     "pending",
   234  			}, nil},
   235  		{
   236  			params.StorageDetails{
   237  				StorageTag: "storage-db-dir-1000",
   238  				OwnerTag:   "unit-transcode-0",
   239  				UnitTag:    "unit-transcode-0",
   240  				Kind:       params.StorageKindBlock,
   241  				Status:     "pending",
   242  				Persistent: true,
   243  			}, nil}}
   244  
   245  	if chaos {
   246  		last := params.StorageInfo{
   247  			params.StorageDetails{
   248  				StorageTag: "storage-shared-fs-5",
   249  				OwnerTag:   "service-transcode",
   250  				UnitTag:    "unit-transcode-0",
   251  				Kind:       params.StorageKindUnknown,
   252  				Status:     "pending",
   253  			}, nil}
   254  		second := params.StorageInfo{
   255  			params.StorageDetails{
   256  				StorageTag: "storage-db-dir-1010",
   257  				UnitTag:    "unit-transcode-1",
   258  				Kind:       params.StorageKindBlock,
   259  				Status:     "pending",
   260  			}, &params.Error{Message: "error for test storage-db-dir-1010"}}
   261  		first := params.StorageInfo{
   262  			params.StorageDetails{
   263  				StorageTag: "storage-db-dir-1000",
   264  				UnitTag:    "unit-transcode-1",
   265  				Kind:       params.StorageKindFilesystem,
   266  				Status:     "pending",
   267  				Persistent: true,
   268  			}, nil}
   269  		zero := params.StorageInfo{
   270  			params.StorageDetails{
   271  				StorageTag: "storage-db-dir-1100",
   272  				UnitTag:    "unit-postgresql-0",
   273  				Kind:       params.StorageKindFilesystem,
   274  				Status:     "pending",
   275  			}, nil}
   276  		results = append(results, last)
   277  		results = append(results, second)
   278  		results = append(results, zero)
   279  		results = append(results, first)
   280  	}
   281  	return results
   282  }