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