github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/worker/fortress/occupy_test.go (about)

     1  // Copyright 2016 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package fortress_test
     5  
     6  import (
     7  	"time"
     8  
     9  	"github.com/juju/errors"
    10  	"github.com/juju/testing"
    11  	jc "github.com/juju/testing/checkers"
    12  	gc "gopkg.in/check.v1"
    13  	"gopkg.in/juju/worker.v1"
    14  	"gopkg.in/juju/worker.v1/workertest"
    15  
    16  	coretesting "github.com/juju/juju/testing"
    17  	"github.com/juju/juju/worker/fortress"
    18  )
    19  
    20  type OccupySuite struct {
    21  	testing.IsolationSuite
    22  }
    23  
    24  var _ = gc.Suite(&OccupySuite{})
    25  
    26  func (*OccupySuite) TestAbort(c *gc.C) {
    27  	fix := newFixture(c)
    28  	defer fix.TearDown(c)
    29  
    30  	// Try to occupy an unlocked fortress.
    31  	run := func() (worker.Worker, error) {
    32  		panic("shouldn't happen")
    33  	}
    34  	abort := make(chan struct{})
    35  	done := make(chan struct{})
    36  	go func() {
    37  		defer close(done)
    38  		worker, err := fortress.Occupy(fix.Guest(c), run, abort)
    39  		c.Check(worker, gc.IsNil)
    40  		c.Check(errors.Cause(err), gc.Equals, fortress.ErrAborted)
    41  	}()
    42  
    43  	// Observe that nothing happens.
    44  	select {
    45  	case <-done:
    46  		c.Fatalf("started early")
    47  	case <-time.After(coretesting.ShortWait):
    48  	}
    49  
    50  	// Abort and wait for completion.
    51  	close(abort)
    52  	select {
    53  	case <-done:
    54  	case <-time.After(coretesting.LongWait):
    55  		c.Fatalf("never cancelled")
    56  	}
    57  }
    58  
    59  func (*OccupySuite) TestStartError(c *gc.C) {
    60  	fix := newFixture(c)
    61  	defer fix.TearDown(c)
    62  	c.Check(fix.Guard(c).Unlock(), jc.ErrorIsNil)
    63  
    64  	// Error just passes straight through.
    65  	run := func() (worker.Worker, error) {
    66  		return nil, errors.New("splosh")
    67  	}
    68  	worker, err := fortress.Occupy(fix.Guest(c), run, nil)
    69  	c.Check(worker, gc.IsNil)
    70  	c.Check(err, gc.ErrorMatches, "splosh")
    71  
    72  	// Guard can lock fortress immediately.
    73  	err = fix.Guard(c).Lockdown(nil)
    74  	c.Check(err, jc.ErrorIsNil)
    75  	AssertLocked(c, fix.Guest(c))
    76  }
    77  
    78  func (*OccupySuite) TestStartSuccess(c *gc.C) {
    79  	fix := newFixture(c)
    80  	defer fix.TearDown(c)
    81  	c.Check(fix.Guard(c).Unlock(), jc.ErrorIsNil)
    82  
    83  	// Start a worker...
    84  	expect := workertest.NewErrorWorker(nil)
    85  	defer workertest.CleanKill(c, expect)
    86  	run := func() (worker.Worker, error) {
    87  		return expect, nil
    88  	}
    89  	worker, err := fortress.Occupy(fix.Guest(c), run, nil)
    90  	c.Assert(err, jc.ErrorIsNil)
    91  	c.Check(worker, gc.Equals, expect)
    92  
    93  	// ...and check we can't lockdown again...
    94  	locked := make(chan error, 1)
    95  	go func() {
    96  		locked <- fix.Guard(c).Lockdown(nil)
    97  	}()
    98  	select {
    99  	case err := <-locked:
   100  		c.Fatalf("unexpected Lockdown result: %v", err)
   101  	case <-time.After(coretesting.ShortWait):
   102  	}
   103  
   104  	// ...until the worker completes.
   105  	workertest.CleanKill(c, worker)
   106  	select {
   107  	case err := <-locked:
   108  		c.Check(err, jc.ErrorIsNil)
   109  	case <-time.After(coretesting.LongWait):
   110  		c.Fatalf("visit never completed")
   111  	}
   112  }