github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/cmd/juju/backups/remove_test.go (about)

     1  // Copyright 2014 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package backups_test
     5  
     6  import (
     7  	"bytes"
     8  	"io"
     9  	"time"
    10  
    11  	"github.com/juju/cmd"
    12  	"github.com/juju/cmd/cmdtesting"
    13  	"github.com/juju/errors"
    14  	jc "github.com/juju/testing/checkers"
    15  	gc "gopkg.in/check.v1"
    16  
    17  	"github.com/golang/mock/gomock"
    18  	"github.com/juju/juju/apiserver/params"
    19  	"github.com/juju/juju/cmd/juju/backups"
    20  	"github.com/juju/juju/jujuclient/jujuclienttesting"
    21  	"github.com/juju/juju/testing"
    22  )
    23  
    24  type removeSuite struct {
    25  	testing.FakeJujuXDGDataHomeSuite
    26  
    27  	command cmd.Command
    28  }
    29  
    30  var _ = gc.Suite(&removeSuite{})
    31  
    32  func (s *removeSuite) SetUpTest(c *gc.C) {
    33  	s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
    34  
    35  	s.command = backups.NewRemoveCommandForTest(jujuclienttesting.MinimalStore())
    36  }
    37  
    38  func (s *removeSuite) patch(c *gc.C) (*gomock.Controller, *MockAPIClient) {
    39  	ctrl := gomock.NewController(c)
    40  	client := NewMockAPIClient(ctrl)
    41  	s.PatchValue(backups.NewGetAPI,
    42  		func(c *backups.CommandBase) (backups.APIClient, int, error) {
    43  			return client, 2, nil
    44  		},
    45  	)
    46  	return ctrl, client
    47  }
    48  
    49  func (s *removeSuite) TestRemovePassWithId(c *gc.C) {
    50  	ctrl, client := s.patch(c)
    51  	defer ctrl.Finish()
    52  
    53  	gomock.InOrder(
    54  		client.EXPECT().Remove([]string{"one"}).Return(
    55  			[]params.ErrorResult{
    56  				{},
    57  			}, nil,
    58  		),
    59  		client.EXPECT().Close(),
    60  	)
    61  	ctx, err := cmdtesting.RunCommand(c, s.command, "one")
    62  	c.Check(err, jc.ErrorIsNil)
    63  	c.Assert(bufferString(ctx.Stderr), gc.Equals, "successfully removed: one\n")
    64  	c.Assert(bufferString(ctx.Stdout), gc.Equals, "")
    65  }
    66  
    67  var passWithKeepLatest = `
    68  successfully removed: four
    69  successfully removed: one
    70  successfully removed: three
    71  kept: two
    72  `[1:]
    73  
    74  func (s *removeSuite) TestRemovePassWithKeepLatest(c *gc.C) {
    75  	ctrl, client := s.patch(c)
    76  	defer ctrl.Finish()
    77  	one := time.Now().Add(time.Minute * 20)
    78  	two := time.Now().Add(time.Hour * 1)
    79  	three := time.Now().Add(time.Minute * 40)
    80  	four := time.Now()
    81  
    82  	gomock.InOrder(
    83  		client.EXPECT().List().Return(
    84  			&params.BackupsListResult{
    85  				List: []params.BackupsMetadataResult{
    86  					{ID: "one", Started: one},
    87  					{ID: "three", Started: three},
    88  					{ID: "two", Started: two},
    89  					{ID: "four", Started: four},
    90  				},
    91  			}, nil,
    92  		),
    93  		client.EXPECT().Remove([]string{"four", "one", "three"}).Return(
    94  			[]params.ErrorResult{{}, {}, {}}, nil,
    95  		),
    96  		client.EXPECT().Close(),
    97  	)
    98  	ctx, err := cmdtesting.RunCommand(c, s.command, "--keep-latest")
    99  	c.Check(err, jc.ErrorIsNil)
   100  	c.Assert(bufferString(ctx.Stderr), gc.Equals, passWithKeepLatest)
   101  	c.Assert(bufferString(ctx.Stdout), gc.Equals, "")
   102  }
   103  
   104  var failWithKeepLatest = `
   105  successfully removed: three
   106  successfully removed: two
   107  kept: four
   108  `[1:]
   109  
   110  func (s *removeSuite) TestRemoveFailWithKeepLatest(c *gc.C) {
   111  	ctrl, client := s.patch(c)
   112  	defer ctrl.Finish()
   113  	one := time.Now().Add(time.Minute * 20)
   114  	two := time.Now()
   115  	three := time.Now().Add(time.Minute * 40)
   116  	four := time.Now().Add(time.Hour * 1)
   117  
   118  	gomock.InOrder(
   119  		client.EXPECT().List().Return(
   120  			&params.BackupsListResult{
   121  				List: []params.BackupsMetadataResult{
   122  					{ID: "one", Started: one},
   123  					{ID: "three", Started: three},
   124  					{ID: "two", Started: two},
   125  					{ID: "four", Started: four},
   126  				},
   127  			}, nil,
   128  		),
   129  		client.EXPECT().Remove([]string{"one", "three", "two"}).Return(
   130  			[]params.ErrorResult{{Error: &params.Error{Message: "failme"}}, {}, {}},
   131  			nil,
   132  		),
   133  		client.EXPECT().Close(),
   134  	)
   135  	ctx, err := cmdtesting.RunCommand(c, s.command, "--keep-latest")
   136  	c.Check(errors.Cause(err), gc.ErrorMatches, "failed to remove one: failme")
   137  	c.Assert(bufferString(ctx.Stderr), gc.Equals, failWithKeepLatest)
   138  	c.Assert(bufferString(ctx.Stdout), gc.Equals, "")
   139  }
   140  
   141  func (s *removeSuite) TestRemoveFailWithId(c *gc.C) {
   142  	ctrl, client := s.patch(c)
   143  	defer ctrl.Finish()
   144  
   145  	gomock.InOrder(
   146  		client.EXPECT().Remove([]string{"spam"}).Return(
   147  			[]params.ErrorResult{{Error: &params.Error{Message: "failed!"}}},
   148  			nil,
   149  		),
   150  		client.EXPECT().Close(),
   151  	)
   152  
   153  	_, err := cmdtesting.RunCommand(c, s.command, "spam")
   154  	c.Check(errors.Cause(err), gc.ErrorMatches, "failed to remove spam: failed!")
   155  }
   156  
   157  func (s *removeSuite) TestRemoveFail(c *gc.C) {
   158  	ctrl, client := s.patch(c)
   159  	defer ctrl.Finish()
   160  
   161  	gomock.InOrder(
   162  		client.EXPECT().Remove([]string{"spam"}).Return(
   163  			nil,
   164  			errors.Errorf("not found"),
   165  		),
   166  		client.EXPECT().Close(),
   167  	)
   168  
   169  	_, err := cmdtesting.RunCommand(c, s.command, "spam")
   170  	c.Check(errors.Cause(err), gc.ErrorMatches, "not found")
   171  }
   172  
   173  func bufferString(w io.Writer) string {
   174  	return w.(*bytes.Buffer).String()
   175  }