github.com/axw/juju@v0.0.0-20161005053422-4bd6544d08d4/worker/dependency/reporter_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  	"time"
     8  
     9  	"github.com/juju/testing"
    10  	jc "github.com/juju/testing/checkers"
    11  	gc "gopkg.in/check.v1"
    12  
    13  	coretesting "github.com/juju/juju/testing"
    14  	"github.com/juju/juju/worker/dependency"
    15  	"github.com/juju/juju/worker/workertest"
    16  )
    17  
    18  type ReportSuite struct {
    19  	testing.IsolationSuite
    20  	fix *engineFixture
    21  }
    22  
    23  var _ = gc.Suite(&ReportSuite{})
    24  
    25  func (s *ReportSuite) SetUpTest(c *gc.C) {
    26  	s.IsolationSuite.SetUpTest(c)
    27  	s.fix = &engineFixture{}
    28  }
    29  
    30  func (s *ReportSuite) TestReportStarted(c *gc.C) {
    31  	s.fix.run(c, func(engine *dependency.Engine) {
    32  		report := engine.Report()
    33  		c.Check(report, jc.DeepEquals, map[string]interface{}{
    34  			"state":     "started",
    35  			"manifolds": map[string]interface{}{},
    36  		})
    37  	})
    38  }
    39  
    40  func (s *ReportSuite) TestReportStopped(c *gc.C) {
    41  	s.fix.run(c, func(engine *dependency.Engine) {
    42  		workertest.CleanKill(c, engine)
    43  		report := engine.Report()
    44  		c.Check(report, jc.DeepEquals, map[string]interface{}{
    45  			"state":     "stopped",
    46  			"manifolds": map[string]interface{}{},
    47  		})
    48  	})
    49  }
    50  
    51  func (s *ReportSuite) TestReportStopping(c *gc.C) {
    52  	s.fix.run(c, func(engine *dependency.Engine) {
    53  		mh1 := newErrorIgnoringManifoldHarness()
    54  		err := engine.Install("task", mh1.Manifold())
    55  		c.Assert(err, jc.ErrorIsNil)
    56  		defer func() {
    57  			engine.Kill()
    58  			// we *must* inject this between Kill and Wait
    59  			mh1.InjectError(c, nil)
    60  			err := engine.Wait()
    61  			c.Check(err, jc.ErrorIsNil)
    62  		}()
    63  		mh1.AssertOneStart(c)
    64  
    65  		// It may take a short time for the main loop to notice
    66  		// the change and stop the "task" worker.
    67  		engine.Kill()
    68  		isTaskStopping := func(report map[string]interface{}) bool {
    69  			manifolds := report["manifolds"].(map[string]interface{})
    70  			task := manifolds["task"].(map[string]interface{})
    71  			switch taskState := task["state"]; taskState {
    72  			case "started":
    73  				return false
    74  			case "stopping":
    75  				return true
    76  			default:
    77  				c.Fatalf("unexpected task state: %v", taskState)
    78  			}
    79  			panic("unreachable")
    80  		}
    81  
    82  		var report map[string]interface{}
    83  		for i := 0; i < 3; i++ {
    84  			report = engine.Report()
    85  			if isTaskStopping(report) {
    86  				break
    87  			}
    88  			time.Sleep(coretesting.ShortWait)
    89  		}
    90  		c.Check(report, jc.DeepEquals, map[string]interface{}{
    91  			"state": "stopping",
    92  			"manifolds": map[string]interface{}{
    93  				"task": map[string]interface{}{
    94  					"state":        "stopping",
    95  					"inputs":       ([]string)(nil),
    96  					"resource-log": []map[string]interface{}{},
    97  					"report": map[string]interface{}{
    98  						"key1": "hello there",
    99  					},
   100  				},
   101  			},
   102  		})
   103  	})
   104  }
   105  
   106  func (s *ReportSuite) TestReportInputs(c *gc.C) {
   107  	s.fix.run(c, func(engine *dependency.Engine) {
   108  		mh1 := newManifoldHarness()
   109  		err := engine.Install("task", mh1.Manifold())
   110  		c.Assert(err, jc.ErrorIsNil)
   111  		mh1.AssertOneStart(c)
   112  
   113  		mh2 := newManifoldHarness("task")
   114  		err = engine.Install("another task", mh2.Manifold())
   115  		c.Assert(err, jc.ErrorIsNil)
   116  		mh2.AssertOneStart(c)
   117  
   118  		report := engine.Report()
   119  		c.Check(report, jc.DeepEquals, map[string]interface{}{
   120  			"state": "started",
   121  			"manifolds": map[string]interface{}{
   122  				"task": map[string]interface{}{
   123  					"state":        "started",
   124  					"inputs":       ([]string)(nil),
   125  					"resource-log": []map[string]interface{}{},
   126  					"report": map[string]interface{}{
   127  						"key1": "hello there",
   128  					},
   129  				},
   130  				"another task": map[string]interface{}{
   131  					"state":  "started",
   132  					"inputs": []string{"task"},
   133  					"resource-log": []map[string]interface{}{{
   134  						"name": "task",
   135  						"type": "<nil>",
   136  					}},
   137  					"report": map[string]interface{}{
   138  						"key1": "hello there",
   139  					},
   140  				},
   141  			},
   142  		})
   143  	})
   144  }
   145  
   146  func (s *ReportSuite) TestReportError(c *gc.C) {
   147  	s.fix.run(c, func(engine *dependency.Engine) {
   148  		mh1 := newManifoldHarness("missing")
   149  		manifold := mh1.Manifold()
   150  		err := engine.Install("task", manifold)
   151  		c.Assert(err, jc.ErrorIsNil)
   152  		mh1.AssertNoStart(c)
   153  
   154  		workertest.CleanKill(c, engine)
   155  		report := engine.Report()
   156  		c.Check(report, jc.DeepEquals, map[string]interface{}{
   157  			"state": "stopped",
   158  			"manifolds": map[string]interface{}{
   159  				"task": map[string]interface{}{
   160  					"state":  "stopped",
   161  					"error":  `"missing" not running: dependency not available`,
   162  					"inputs": []string{"missing"},
   163  					"resource-log": []map[string]interface{}{{
   164  						"name":  "missing",
   165  						"type":  "<nil>",
   166  						"error": `"missing" not running: dependency not available`,
   167  					}},
   168  				},
   169  			},
   170  		})
   171  	})
   172  }