github.com/axw/juju@v0.0.0-20161005053422-4bd6544d08d4/worker/dependency/self_test.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package dependency_test
     5  
     6  import (
     7  	"fmt"
     8  
     9  	"github.com/juju/testing"
    10  	jc "github.com/juju/testing/checkers"
    11  	gc "gopkg.in/check.v1"
    12  
    13  	"github.com/juju/juju/worker/dependency"
    14  	"github.com/juju/juju/worker/workertest"
    15  )
    16  
    17  type SelfSuite struct {
    18  	testing.IsolationSuite
    19  	fix *engineFixture
    20  }
    21  
    22  var _ = gc.Suite(&SelfSuite{})
    23  
    24  func (s *SelfSuite) SetUpTest(c *gc.C) {
    25  	s.IsolationSuite.SetUpTest(c)
    26  	s.fix = &engineFixture{}
    27  }
    28  
    29  func (s *SelfSuite) TestInputs(c *gc.C) {
    30  	s.fix.run(c, func(engine *dependency.Engine) {
    31  		manifold := dependency.SelfManifold(engine)
    32  		c.Check(manifold.Inputs, gc.HasLen, 0)
    33  	})
    34  }
    35  
    36  func (s *SelfSuite) TestStart(c *gc.C) {
    37  	s.fix.run(c, func(engine *dependency.Engine) {
    38  		manifold := dependency.SelfManifold(engine)
    39  		actual, err := manifold.Start(nil)
    40  		c.Check(err, jc.ErrorIsNil)
    41  		c.Check(actual, gc.Equals, engine)
    42  	})
    43  }
    44  
    45  func (s *SelfSuite) TestOutputBadInput(c *gc.C) {
    46  	s.fix.run(c, func(engine *dependency.Engine) {
    47  		manifold := dependency.SelfManifold(engine)
    48  		var input dependency.Engine
    49  		err := manifold.Output(&input, nil)
    50  		c.Check(err, gc.ErrorMatches, "unexpected input worker")
    51  	})
    52  }
    53  
    54  func (s *SelfSuite) TestOutputBadOutput(c *gc.C) {
    55  	s.fix.run(c, func(engine *dependency.Engine) {
    56  		manifold := dependency.SelfManifold(engine)
    57  		var unknown interface{}
    58  		err := manifold.Output(engine, &unknown)
    59  		c.Check(err, gc.ErrorMatches, "out should be a \\*Installer or a \\*Reporter; is .*")
    60  		c.Check(unknown, gc.IsNil)
    61  	})
    62  }
    63  
    64  func (s *SelfSuite) TestOutputReporter(c *gc.C) {
    65  	s.fix.run(c, func(engine *dependency.Engine) {
    66  		manifold := dependency.SelfManifold(engine)
    67  		var reporter dependency.Reporter
    68  		err := manifold.Output(engine, &reporter)
    69  		c.Check(err, jc.ErrorIsNil)
    70  		c.Check(reporter, gc.Equals, engine)
    71  	})
    72  }
    73  
    74  func (s *SelfSuite) TestOutputInstaller(c *gc.C) {
    75  	s.fix.run(c, func(engine *dependency.Engine) {
    76  		manifold := dependency.SelfManifold(engine)
    77  		var installer dependency.Installer
    78  		err := manifold.Output(engine, &installer)
    79  		c.Check(err, jc.ErrorIsNil)
    80  		c.Check(installer, gc.Equals, engine)
    81  	})
    82  }
    83  
    84  func (s *SelfSuite) TestActuallyWorks(c *gc.C) {
    85  	s.fix.run(c, func(engine *dependency.Engine) {
    86  
    87  		// Create and install a manifold with an unsatisfied dependency.
    88  		mh1 := newManifoldHarness("self")
    89  		err := engine.Install("dependent", mh1.Manifold())
    90  		c.Assert(err, jc.ErrorIsNil)
    91  		mh1.AssertNoStart(c)
    92  
    93  		// Install an engine inside itself; once it's "started", dependent will
    94  		// be restarted.
    95  		manifold := dependency.SelfManifold(engine)
    96  		err = engine.Install("self", manifold)
    97  		c.Assert(err, jc.ErrorIsNil)
    98  		mh1.AssertOneStart(c)
    99  
   100  		// Give it a moment to screw up if it's going to
   101  		// (injudicious implementation could induce deadlock)
   102  		// then let the fixture worry about a clean kill.
   103  		workertest.CheckAlive(c, engine)
   104  	})
   105  }
   106  
   107  func (s *SelfSuite) TestStress(c *gc.C) {
   108  	s.fix.run(c, func(engine *dependency.Engine) {
   109  
   110  		// Repeatedly install a manifold inside itself.
   111  		manifold := dependency.SelfManifold(engine)
   112  		for i := 0; i < 100; i++ {
   113  			go engine.Install(fmt.Sprintf("self-%d", i), manifold)
   114  		}
   115  
   116  		// Give it a moment to screw up if it's going to
   117  		// (injudicious implementation could induce deadlock)
   118  		// then let the fixture worry about a clean kill.
   119  		workertest.CheckAlive(c, engine)
   120  	})
   121  }