github.com/mattyw/juju@v0.0.0-20140610034352-732aecd63861/worker/uniter/jujuc/relation-list_test.go (about)

     1  // Copyright 2012, 2013 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package jujuc_test
     5  
     6  import (
     7  	"fmt"
     8  
     9  	gc "launchpad.net/gocheck"
    10  
    11  	"github.com/juju/juju/cmd"
    12  	"github.com/juju/juju/testing"
    13  	"github.com/juju/juju/worker/uniter/jujuc"
    14  )
    15  
    16  type RelationListSuite struct {
    17  	ContextSuite
    18  }
    19  
    20  var _ = gc.Suite(&RelationListSuite{})
    21  
    22  var relationListTests = []struct {
    23  	summary            string
    24  	relid              int
    25  	members0, members1 []string
    26  	args               []string
    27  	code               int
    28  	out                string
    29  }{
    30  	{
    31  		summary: "no default relation, no arg",
    32  		relid:   -1,
    33  		code:    2,
    34  		out:     "no relation id specified",
    35  	}, {
    36  		summary: "no default relation, bad arg",
    37  		relid:   -1,
    38  		args:    []string{"-r", "bad"},
    39  		code:    2,
    40  		out:     `invalid value "bad" for flag -r: invalid relation id`,
    41  	}, {
    42  		summary: "no default relation, unknown arg",
    43  		relid:   -1,
    44  		args:    []string{"-r", "unknown:123"},
    45  		code:    2,
    46  		out:     `invalid value "unknown:123" for flag -r: unknown relation id`,
    47  	}, {
    48  		summary: "default relation, bad arg",
    49  		relid:   1,
    50  		args:    []string{"-r", "bad"},
    51  		code:    2,
    52  		out:     `invalid value "bad" for flag -r: invalid relation id`,
    53  	}, {
    54  		summary: "default relation, unknown arg",
    55  		relid:   1,
    56  		args:    []string{"-r", "unknown:123"},
    57  		code:    2,
    58  		out:     `invalid value "unknown:123" for flag -r: unknown relation id`,
    59  	}, {
    60  		summary: "default relation, no members",
    61  		relid:   1,
    62  	}, {
    63  		summary:  "default relation, members",
    64  		members1: []string{"foo", "bar", "baz"},
    65  		relid:    1,
    66  		out:      "bar\nbaz\nfoo",
    67  	}, {
    68  		summary:  "alternative relation, members",
    69  		members0: []string{"pew", "pow", "paw"},
    70  		relid:    1,
    71  		args:     []string{"-r", "ignored:0"},
    72  		out:      "paw\npew\npow",
    73  	}, {
    74  		summary: "explicit smart formatting 1",
    75  		relid:   1,
    76  		args:    []string{"--format", "smart"},
    77  	}, {
    78  		summary:  "explicit smart formatting 2",
    79  		members1: []string{"foo", "bar", "baz"},
    80  		relid:    1,
    81  		args:     []string{"--format", "smart"},
    82  		out:      "bar\nbaz\nfoo",
    83  	}, {
    84  		summary: "json formatting 1",
    85  		relid:   1,
    86  		args:    []string{"--format", "json"},
    87  		out:     "[]",
    88  	}, {
    89  		summary:  "json formatting 2",
    90  		members1: []string{"foo", "bar", "baz"},
    91  		relid:    1,
    92  		args:     []string{"--format", "json"},
    93  		out:      `["bar","baz","foo"]`,
    94  	}, {
    95  		summary: "yaml formatting 1",
    96  		relid:   1,
    97  		args:    []string{"--format", "yaml"},
    98  		out:     "[]",
    99  	}, {
   100  		summary:  "yaml formatting 2",
   101  		members1: []string{"foo", "bar", "baz"},
   102  		relid:    1,
   103  		args:     []string{"--format", "yaml"},
   104  		out:      "- bar\n- baz\n- foo",
   105  	},
   106  }
   107  
   108  func (s *RelationListSuite) TestRelationList(c *gc.C) {
   109  	for i, t := range relationListTests {
   110  		c.Logf("test %d: %s", i, t.summary)
   111  		hctx := s.GetHookContext(c, t.relid, "")
   112  		setMembers(hctx.rels[0], t.members0)
   113  		setMembers(hctx.rels[1], t.members1)
   114  		com, err := jujuc.NewCommand(hctx, "relation-list")
   115  		c.Assert(err, gc.IsNil)
   116  		ctx := testing.Context(c)
   117  		code := cmd.Main(com, ctx, t.args)
   118  		c.Logf(bufferString(ctx.Stderr))
   119  		c.Assert(code, gc.Equals, t.code)
   120  		if code == 0 {
   121  			c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
   122  			expect := t.out
   123  			if expect != "" {
   124  				expect = expect + "\n"
   125  			}
   126  			c.Assert(bufferString(ctx.Stdout), gc.Equals, expect)
   127  		} else {
   128  			c.Assert(bufferString(ctx.Stdout), gc.Equals, "")
   129  			expect := fmt.Sprintf(`(.|\n)*error: %s\n`, t.out)
   130  			c.Assert(bufferString(ctx.Stderr), gc.Matches, expect)
   131  		}
   132  	}
   133  }
   134  
   135  func (s *RelationListSuite) TestRelationListHelp(c *gc.C) {
   136  	template := `
   137  usage: relation-list [options]
   138  purpose: list relation units
   139  
   140  options:
   141  --format  (= smart)
   142      specify output format (json|smart|yaml)
   143  -o, --output (= "")
   144      specify an output file
   145  -r  (= %s)
   146      specify a relation by id
   147  %s`[1:]
   148  
   149  	for relid, t := range map[int]struct {
   150  		usage, doc string
   151  	}{
   152  		-1: {"", "\n-r must be specified when not in a relation hook\n"},
   153  		0:  {"peer0:0", ""},
   154  	} {
   155  		c.Logf("test relid %d", relid)
   156  		hctx := s.GetHookContext(c, relid, "")
   157  		com, err := jujuc.NewCommand(hctx, "relation-list")
   158  		c.Assert(err, gc.IsNil)
   159  		ctx := testing.Context(c)
   160  		code := cmd.Main(com, ctx, []string{"--help"})
   161  		c.Assert(code, gc.Equals, 0)
   162  		expect := fmt.Sprintf(template, t.usage, t.doc)
   163  		c.Assert(bufferString(ctx.Stdout), gc.Equals, expect)
   164  		c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
   165  	}
   166  }
   167  
   168  func setMembers(rctx *ContextRelation, members []string) {
   169  	rctx.units = map[string]Settings{}
   170  	for _, name := range members {
   171  		rctx.units[name] = nil
   172  	}
   173  }