github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/apiserver/facades/agent/migrationflag/facade_test.go (about)

     1  // Copyright 2016 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package migrationflag_test
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	"github.com/juju/testing"
     9  	jc "github.com/juju/testing/checkers"
    10  	gc "gopkg.in/check.v1"
    11  
    12  	"github.com/juju/juju/apiserver/common"
    13  	"github.com/juju/juju/apiserver/facades/agent/migrationflag"
    14  	"github.com/juju/juju/apiserver/params"
    15  	coretesting "github.com/juju/juju/testing"
    16  )
    17  
    18  type FacadeSuite struct {
    19  	testing.IsolationSuite
    20  }
    21  
    22  var _ = gc.Suite(&FacadeSuite{})
    23  
    24  func (*FacadeSuite) TestAcceptsMachineAgent(c *gc.C) {
    25  	facade, err := migrationflag.New(nil, nil, agentAuth{machine: true})
    26  	c.Check(err, jc.ErrorIsNil)
    27  	c.Check(facade, gc.NotNil)
    28  }
    29  
    30  func (*FacadeSuite) TestAcceptsUnitAgent(c *gc.C) {
    31  	facade, err := migrationflag.New(nil, nil, agentAuth{machine: true})
    32  	c.Check(err, jc.ErrorIsNil)
    33  	c.Check(facade, gc.NotNil)
    34  }
    35  
    36  func (*FacadeSuite) TestAcceptsApplicationAgent(c *gc.C) {
    37  	facade, err := migrationflag.New(nil, nil, agentAuth{application: true})
    38  	c.Check(err, jc.ErrorIsNil)
    39  	c.Check(facade, gc.NotNil)
    40  }
    41  
    42  func (*FacadeSuite) TestRejectsNonAgent(c *gc.C) {
    43  	facade, err := migrationflag.New(nil, nil, agentAuth{})
    44  	c.Check(err, gc.Equals, common.ErrPerm)
    45  	c.Check(facade, gc.IsNil)
    46  }
    47  
    48  func (*FacadeSuite) TestPhaseSuccess(c *gc.C) {
    49  	stub := &testing.Stub{}
    50  	backend := newMockBackend(stub)
    51  	facade, err := migrationflag.New(backend, nil, authOK)
    52  	c.Assert(err, jc.ErrorIsNil)
    53  
    54  	results := facade.Phase(entities(
    55  		coretesting.ModelTag.String(),
    56  		coretesting.ModelTag.String(),
    57  	))
    58  	c.Assert(results.Results, gc.HasLen, 2)
    59  	stub.CheckCallNames(c, "MigrationPhase", "MigrationPhase")
    60  
    61  	for _, result := range results.Results {
    62  		c.Check(result.Error, gc.IsNil)
    63  		c.Check(result.Phase, gc.Equals, "REAP")
    64  	}
    65  }
    66  
    67  func (*FacadeSuite) TestPhaseErrors(c *gc.C) {
    68  	stub := &testing.Stub{}
    69  	stub.SetErrors(errors.New("ouch"))
    70  	backend := newMockBackend(stub)
    71  	facade, err := migrationflag.New(backend, nil, authOK)
    72  	c.Assert(err, jc.ErrorIsNil)
    73  
    74  	// 3 entities: unparseable, unauthorized, call error.
    75  	results := facade.Phase(entities(
    76  		"urgle",
    77  		unknownModel,
    78  		coretesting.ModelTag.String(),
    79  	))
    80  	c.Assert(results.Results, gc.HasLen, 3)
    81  	stub.CheckCallNames(c, "MigrationPhase")
    82  
    83  	c.Check(results.Results, jc.DeepEquals, []params.PhaseResult{{
    84  		Error: &params.Error{
    85  			Message: `"urgle" is not a valid tag`,
    86  		}}, {
    87  		Error: &params.Error{
    88  			Message: "permission denied",
    89  			Code:    "unauthorized access",
    90  		}}, {
    91  		Error: &params.Error{
    92  			Message: "ouch",
    93  		},
    94  	}})
    95  }
    96  
    97  func (*FacadeSuite) TestWatchSuccess(c *gc.C) {
    98  	stub := &testing.Stub{}
    99  	backend := newMockBackend(stub)
   100  	resources := common.NewResources()
   101  	facade, err := migrationflag.New(backend, resources, authOK)
   102  	c.Assert(err, jc.ErrorIsNil)
   103  
   104  	results := facade.Watch(entities(
   105  		coretesting.ModelTag.String(),
   106  		coretesting.ModelTag.String(),
   107  	))
   108  	c.Assert(results.Results, gc.HasLen, 2)
   109  	stub.CheckCallNames(c, "WatchMigrationPhase", "WatchMigrationPhase")
   110  
   111  	check := func(result params.NotifyWatchResult) {
   112  		c.Check(result.Error, gc.IsNil)
   113  		resource := resources.Get(result.NotifyWatcherId)
   114  		c.Check(resource, gc.NotNil)
   115  	}
   116  	first := results.Results[0]
   117  	second := results.Results[1]
   118  	check(first)
   119  	check(second)
   120  	c.Check(first.NotifyWatcherId, gc.Not(gc.Equals), second.NotifyWatcherId)
   121  }
   122  
   123  func (*FacadeSuite) TestWatchErrors(c *gc.C) {
   124  	stub := &testing.Stub{}
   125  	stub.SetErrors(errors.New("blort")) // trigger channel closed error
   126  	backend := newMockBackend(stub)
   127  	resources := common.NewResources()
   128  	facade, err := migrationflag.New(backend, resources, authOK)
   129  	c.Assert(err, jc.ErrorIsNil)
   130  
   131  	// 3 entities: unparseable, unauthorized, closed channel.
   132  	results := facade.Watch(entities(
   133  		"urgle",
   134  		unknownModel,
   135  		coretesting.ModelTag.String(),
   136  	))
   137  	c.Assert(results.Results, gc.HasLen, 3)
   138  	stub.CheckCallNames(c, "WatchMigrationPhase")
   139  
   140  	c.Check(results.Results, jc.DeepEquals, []params.NotifyWatchResult{{
   141  		Error: &params.Error{
   142  			Message: `"urgle" is not a valid tag`,
   143  		}}, {
   144  		Error: &params.Error{
   145  			Message: "permission denied",
   146  			Code:    "unauthorized access",
   147  		}}, {
   148  		Error: &params.Error{
   149  			Message: "blort",
   150  		}},
   151  	})
   152  	c.Check(resources.Count(), gc.Equals, 0)
   153  }