github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/apiserver/migrationflag/facade_test.go (about)

     1  // Copyright 2016 Canonical Ltd.
     2  // Licensed under the LGPLv3, 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/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) TestRejectsNonAgent(c *gc.C) {
    37  	facade, err := migrationflag.New(nil, nil, agentAuth{})
    38  	c.Check(err, gc.Equals, common.ErrPerm)
    39  	c.Check(facade, gc.IsNil)
    40  }
    41  
    42  func (*FacadeSuite) TestPhaseSuccess(c *gc.C) {
    43  	stub := &testing.Stub{}
    44  	backend := newMockBackend(stub)
    45  	facade, err := migrationflag.New(backend, nil, authOK)
    46  	c.Assert(err, jc.ErrorIsNil)
    47  
    48  	results := facade.Phase(entities(
    49  		coretesting.ModelTag.String(),
    50  		coretesting.ModelTag.String(),
    51  	))
    52  	c.Assert(results.Results, gc.HasLen, 2)
    53  	stub.CheckCallNames(c, "MigrationPhase", "MigrationPhase")
    54  
    55  	for _, result := range results.Results {
    56  		c.Check(result.Error, gc.IsNil)
    57  		c.Check(result.Phase, gc.Equals, "REAP")
    58  	}
    59  }
    60  
    61  func (*FacadeSuite) TestPhaseErrors(c *gc.C) {
    62  	stub := &testing.Stub{}
    63  	stub.SetErrors(errors.New("ouch"))
    64  	backend := newMockBackend(stub)
    65  	facade, err := migrationflag.New(backend, nil, authOK)
    66  	c.Assert(err, jc.ErrorIsNil)
    67  
    68  	// 3 entities: unparseable, unauthorized, call error.
    69  	results := facade.Phase(entities(
    70  		"urgle",
    71  		unknownModel,
    72  		coretesting.ModelTag.String(),
    73  	))
    74  	c.Assert(results.Results, gc.HasLen, 3)
    75  	stub.CheckCallNames(c, "MigrationPhase")
    76  
    77  	c.Check(results.Results, jc.DeepEquals, []params.PhaseResult{{
    78  		Error: &params.Error{
    79  			Message: `"urgle" is not a valid tag`,
    80  		}}, {
    81  		Error: &params.Error{
    82  			Message: "permission denied",
    83  			Code:    "unauthorized access",
    84  		}}, {
    85  		Error: &params.Error{
    86  			Message: "ouch",
    87  		},
    88  	}})
    89  }
    90  
    91  func (*FacadeSuite) TestWatchSuccess(c *gc.C) {
    92  	stub := &testing.Stub{}
    93  	backend := newMockBackend(stub)
    94  	resources := common.NewResources()
    95  	facade, err := migrationflag.New(backend, resources, authOK)
    96  	c.Assert(err, jc.ErrorIsNil)
    97  
    98  	results := facade.Watch(entities(
    99  		coretesting.ModelTag.String(),
   100  		coretesting.ModelTag.String(),
   101  	))
   102  	c.Assert(results.Results, gc.HasLen, 2)
   103  	stub.CheckCallNames(c, "WatchMigrationPhase", "WatchMigrationPhase")
   104  
   105  	check := func(result params.NotifyWatchResult) {
   106  		c.Check(result.Error, gc.IsNil)
   107  		resource := resources.Get(result.NotifyWatcherId)
   108  		c.Check(resource, gc.NotNil)
   109  	}
   110  	first := results.Results[0]
   111  	second := results.Results[1]
   112  	check(first)
   113  	check(second)
   114  	c.Check(first.NotifyWatcherId, gc.Not(gc.Equals), second.NotifyWatcherId)
   115  }
   116  
   117  func (*FacadeSuite) TestWatchErrors(c *gc.C) {
   118  	stub := &testing.Stub{}
   119  	stub.SetErrors(errors.New("blort"), nil, errors.New("squish"))
   120  	backend := newMockBackend(stub)
   121  	resources := common.NewResources()
   122  	facade, err := migrationflag.New(backend, resources, authOK)
   123  	c.Assert(err, jc.ErrorIsNil)
   124  
   125  	// 4 entities: unparseable, unauthorized, watch error, closed chan.
   126  	results := facade.Watch(entities(
   127  		"urgle",
   128  		unknownModel,
   129  		coretesting.ModelTag.String(),
   130  		coretesting.ModelTag.String(),
   131  	))
   132  	c.Assert(results.Results, gc.HasLen, 4)
   133  	stub.CheckCallNames(c, "WatchMigrationPhase", "WatchMigrationPhase")
   134  
   135  	c.Check(results.Results, jc.DeepEquals, []params.NotifyWatchResult{{
   136  		Error: &params.Error{
   137  			Message: `"urgle" is not a valid tag`,
   138  		}}, {
   139  		Error: &params.Error{
   140  			Message: "permission denied",
   141  			Code:    "unauthorized access",
   142  		}}, {
   143  		Error: &params.Error{
   144  			Message: "blort",
   145  		}}, {
   146  		Error: &params.Error{
   147  			Message: "squish",
   148  		},
   149  	}})
   150  	c.Check(resources.Count(), gc.Equals, 0)
   151  }