github.com/vieux/docker@v0.6.3-0.20161004191708-e097c2a938c7/cli/command/formatter/network_test.go (about)

     1  package formatter
     2  
     3  import (
     4  	"bytes"
     5  	"strings"
     6  	"testing"
     7  
     8  	"github.com/docker/docker/api/types"
     9  	"github.com/docker/docker/pkg/stringid"
    10  	"github.com/docker/docker/pkg/testutil/assert"
    11  )
    12  
    13  func TestNetworkContext(t *testing.T) {
    14  	networkID := stringid.GenerateRandomID()
    15  
    16  	var ctx networkContext
    17  	cases := []struct {
    18  		networkCtx networkContext
    19  		expValue   string
    20  		expHeader  string
    21  		call       func() string
    22  	}{
    23  		{networkContext{
    24  			n:     types.NetworkResource{ID: networkID},
    25  			trunc: false,
    26  		}, networkID, networkIDHeader, ctx.ID},
    27  		{networkContext{
    28  			n:     types.NetworkResource{ID: networkID},
    29  			trunc: true,
    30  		}, stringid.TruncateID(networkID), networkIDHeader, ctx.ID},
    31  		{networkContext{
    32  			n: types.NetworkResource{Name: "network_name"},
    33  		}, "network_name", nameHeader, ctx.Name},
    34  		{networkContext{
    35  			n: types.NetworkResource{Driver: "driver_name"},
    36  		}, "driver_name", driverHeader, ctx.Driver},
    37  		{networkContext{
    38  			n: types.NetworkResource{EnableIPv6: true},
    39  		}, "true", ipv6Header, ctx.IPv6},
    40  		{networkContext{
    41  			n: types.NetworkResource{EnableIPv6: false},
    42  		}, "false", ipv6Header, ctx.IPv6},
    43  		{networkContext{
    44  			n: types.NetworkResource{Internal: true},
    45  		}, "true", internalHeader, ctx.Internal},
    46  		{networkContext{
    47  			n: types.NetworkResource{Internal: false},
    48  		}, "false", internalHeader, ctx.Internal},
    49  		{networkContext{
    50  			n: types.NetworkResource{},
    51  		}, "", labelsHeader, ctx.Labels},
    52  		{networkContext{
    53  			n: types.NetworkResource{Labels: map[string]string{"label1": "value1", "label2": "value2"}},
    54  		}, "label1=value1,label2=value2", labelsHeader, ctx.Labels},
    55  	}
    56  
    57  	for _, c := range cases {
    58  		ctx = c.networkCtx
    59  		v := c.call()
    60  		if strings.Contains(v, ",") {
    61  			compareMultipleValues(t, v, c.expValue)
    62  		} else if v != c.expValue {
    63  			t.Fatalf("Expected %s, was %s\n", c.expValue, v)
    64  		}
    65  
    66  		h := ctx.FullHeader()
    67  		if h != c.expHeader {
    68  			t.Fatalf("Expected %s, was %s\n", c.expHeader, h)
    69  		}
    70  	}
    71  }
    72  
    73  func TestNetworkContextWrite(t *testing.T) {
    74  	cases := []struct {
    75  		context  Context
    76  		expected string
    77  	}{
    78  
    79  		// Errors
    80  		{
    81  			Context{Format: "{{InvalidFunction}}"},
    82  			`Template parsing error: template: :1: function "InvalidFunction" not defined
    83  `,
    84  		},
    85  		{
    86  			Context{Format: "{{nil}}"},
    87  			`Template parsing error: template: :1:2: executing "" at <nil>: nil is not a command
    88  `,
    89  		},
    90  		// Table format
    91  		{
    92  			Context{Format: NewNetworkFormat("table", false)},
    93  			`NETWORK ID          NAME                DRIVER              SCOPE
    94  networkID1          foobar_baz          foo                 local
    95  networkID2          foobar_bar          bar                 local
    96  `,
    97  		},
    98  		{
    99  			Context{Format: NewNetworkFormat("table", true)},
   100  			`networkID1
   101  networkID2
   102  `,
   103  		},
   104  		{
   105  			Context{Format: NewNetworkFormat("table {{.Name}}", false)},
   106  			`NAME
   107  foobar_baz
   108  foobar_bar
   109  `,
   110  		},
   111  		{
   112  			Context{Format: NewNetworkFormat("table {{.Name}}", true)},
   113  			`NAME
   114  foobar_baz
   115  foobar_bar
   116  `,
   117  		},
   118  		// Raw Format
   119  		{
   120  			Context{Format: NewNetworkFormat("raw", false)},
   121  			`network_id: networkID1
   122  name: foobar_baz
   123  driver: foo
   124  scope: local
   125  
   126  network_id: networkID2
   127  name: foobar_bar
   128  driver: bar
   129  scope: local
   130  
   131  `,
   132  		},
   133  		{
   134  			Context{Format: NewNetworkFormat("raw", true)},
   135  			`network_id: networkID1
   136  network_id: networkID2
   137  `,
   138  		},
   139  		// Custom Format
   140  		{
   141  			Context{Format: NewNetworkFormat("{{.Name}}", false)},
   142  			`foobar_baz
   143  foobar_bar
   144  `,
   145  		},
   146  	}
   147  
   148  	for _, testcase := range cases {
   149  		networks := []types.NetworkResource{
   150  			{ID: "networkID1", Name: "foobar_baz", Driver: "foo", Scope: "local"},
   151  			{ID: "networkID2", Name: "foobar_bar", Driver: "bar", Scope: "local"},
   152  		}
   153  		out := bytes.NewBufferString("")
   154  		testcase.context.Output = out
   155  		err := NetworkWrite(testcase.context, networks)
   156  		if err != nil {
   157  			assert.Error(t, err, testcase.expected)
   158  		} else {
   159  			assert.Equal(t, out.String(), testcase.expected)
   160  		}
   161  	}
   162  }