github.com/cloud-green/juju@v0.0.0-20151002100041-a00291338d3d/cmd/juju/user/add_test.go (about)

     1  // Copyright 2014 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package user_test
     5  
     6  import (
     7  	"strings"
     8  
     9  	"github.com/juju/cmd"
    10  	"github.com/juju/errors"
    11  	"github.com/juju/names"
    12  	jc "github.com/juju/testing/checkers"
    13  	gc "gopkg.in/check.v1"
    14  
    15  	"github.com/juju/juju/apiserver/common"
    16  	"github.com/juju/juju/cmd/envcmd"
    17  	"github.com/juju/juju/cmd/juju/user"
    18  	"github.com/juju/juju/testing"
    19  )
    20  
    21  // All of the functionality of the AddUser api call is contained elsewhere.
    22  // This suite provides basic tests for the "user add" command
    23  type UserAddCommandSuite struct {
    24  	BaseSuite
    25  	mockAPI        *mockAddUserAPI
    26  	randomPassword string
    27  	serverFilename string
    28  }
    29  
    30  var _ = gc.Suite(&UserAddCommandSuite{})
    31  
    32  func (s *UserAddCommandSuite) SetUpTest(c *gc.C) {
    33  	s.BaseSuite.SetUpTest(c)
    34  	s.mockAPI = &mockAddUserAPI{}
    35  	s.randomPassword = ""
    36  	s.serverFilename = ""
    37  	s.PatchValue(user.RandomPasswordNotify, func(pwd string) {
    38  		s.randomPassword = pwd
    39  	})
    40  	s.PatchValue(user.ServerFileNotify, func(filename string) {
    41  		s.serverFilename = filename
    42  	})
    43  }
    44  
    45  func (s *UserAddCommandSuite) run(c *gc.C, args ...string) (*cmd.Context, error) {
    46  	addCommand := envcmd.WrapSystem(user.NewAddCommand(s.mockAPI))
    47  	return testing.RunCommand(c, addCommand, args...)
    48  }
    49  
    50  func (s *UserAddCommandSuite) TestInit(c *gc.C) {
    51  	for i, test := range []struct {
    52  		args        []string
    53  		user        string
    54  		displayname string
    55  		outPath     string
    56  		errorString string
    57  	}{
    58  		{
    59  			errorString: "no username supplied",
    60  		}, {
    61  			args:    []string{"foobar"},
    62  			user:    "foobar",
    63  			outPath: "foobar.server",
    64  		}, {
    65  			args:        []string{"foobar", "Foo Bar"},
    66  			user:        "foobar",
    67  			displayname: "Foo Bar",
    68  			outPath:     "foobar.server",
    69  		}, {
    70  			args:        []string{"foobar", "Foo Bar", "extra"},
    71  			errorString: `unrecognized args: \["extra"\]`,
    72  		}, {
    73  			args:    []string{"foobar", "--output", "somefile"},
    74  			user:    "foobar",
    75  			outPath: "somefile",
    76  		}, {
    77  			args:    []string{"foobar", "-o", "somefile"},
    78  			user:    "foobar",
    79  			outPath: "somefile",
    80  		},
    81  	} {
    82  		c.Logf("test %d", i)
    83  		addUserCmd := &user.AddCommand{}
    84  		err := testing.InitCommand(addUserCmd, test.args)
    85  		if test.errorString == "" {
    86  			c.Check(addUserCmd.User, gc.Equals, test.user)
    87  			c.Check(addUserCmd.DisplayName, gc.Equals, test.displayname)
    88  			c.Check(addUserCmd.OutPath, gc.Equals, test.outPath)
    89  		} else {
    90  			c.Check(err, gc.ErrorMatches, test.errorString)
    91  		}
    92  	}
    93  }
    94  
    95  func (s *UserAddCommandSuite) TestRandomPassword(c *gc.C) {
    96  	_, err := s.run(c, "foobar")
    97  	c.Assert(err, jc.ErrorIsNil)
    98  	c.Assert(s.randomPassword, gc.HasLen, 24)
    99  }
   100  
   101  func (s *UserAddCommandSuite) TestUsername(c *gc.C) {
   102  	context, err := s.run(c, "foobar")
   103  	c.Assert(err, jc.ErrorIsNil)
   104  	c.Assert(s.mockAPI.username, gc.Equals, "foobar")
   105  	c.Assert(s.mockAPI.displayname, gc.Equals, "")
   106  	expected := `
   107  user "foobar" added
   108  server file written to .*foobar.server
   109  `[1:]
   110  	c.Assert(testing.Stderr(context), gc.Matches, expected)
   111  	s.assertServerFileMatches(c, s.serverFilename, "foobar", s.randomPassword)
   112  }
   113  
   114  func (s *UserAddCommandSuite) TestUsernameAndDisplayname(c *gc.C) {
   115  	context, err := s.run(c, "foobar", "Foo Bar")
   116  	c.Assert(err, jc.ErrorIsNil)
   117  	c.Assert(s.mockAPI.username, gc.Equals, "foobar")
   118  	c.Assert(s.mockAPI.displayname, gc.Equals, "Foo Bar")
   119  	expected := `user "Foo Bar (foobar)" added`
   120  	c.Assert(testing.Stderr(context), jc.Contains, expected)
   121  	s.assertServerFileMatches(c, s.serverFilename, "foobar", s.randomPassword)
   122  }
   123  
   124  func (s *UserAddCommandSuite) TestBlockAddUser(c *gc.C) {
   125  	// Block operation
   126  	s.mockAPI.blocked = true
   127  	_, err := s.run(c, "foobar", "Foo Bar")
   128  	c.Assert(err, gc.ErrorMatches, cmd.ErrSilent.Error())
   129  	// msg is logged
   130  	stripped := strings.Replace(c.GetTestLog(), "\n", "", -1)
   131  	c.Check(stripped, gc.Matches, ".*To unblock changes.*")
   132  }
   133  
   134  func (s *UserAddCommandSuite) TestAddUserErrorResponse(c *gc.C) {
   135  	s.mockAPI.failMessage = "failed to create user, chaos ensues"
   136  	_, err := s.run(c, "foobar")
   137  	c.Assert(err, gc.ErrorMatches, s.mockAPI.failMessage)
   138  }
   139  
   140  type mockAddUserAPI struct {
   141  	failMessage string
   142  	username    string
   143  	displayname string
   144  	password    string
   145  
   146  	shareFailMsg string
   147  	sharedUsers  []names.UserTag
   148  	blocked      bool
   149  }
   150  
   151  func (m *mockAddUserAPI) AddUser(username, displayname, password string) (names.UserTag, error) {
   152  	if m.blocked {
   153  		return names.UserTag{}, common.ErrOperationBlocked("The operation has been blocked.")
   154  	}
   155  
   156  	m.username = username
   157  	m.displayname = displayname
   158  	m.password = password
   159  	if m.failMessage == "" {
   160  		return names.NewLocalUserTag(username), nil
   161  	}
   162  	return names.UserTag{}, errors.New(m.failMessage)
   163  }
   164  
   165  func (*mockAddUserAPI) Close() error {
   166  	return nil
   167  }