github.com/brahmaroutu/docker@v1.2.1-0.20160809185609-eb28dde01f16/api/client/formatter/network_test.go (about)

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