github.com/toplink-cn/moby@v0.0.0-20240305205811-460b4aebdf81/daemon/network/filter_test.go (about)

     1  //go:build !windows
     2  
     3  package network // import "github.com/docker/docker/daemon/network"
     4  
     5  import (
     6  	"strings"
     7  	"testing"
     8  
     9  	"github.com/docker/docker/api/types"
    10  	"github.com/docker/docker/api/types/filters"
    11  )
    12  
    13  func TestFilterNetworks(t *testing.T) {
    14  	networks := []types.NetworkResource{
    15  		{
    16  			Name:   "host",
    17  			Driver: "host",
    18  			Scope:  "local",
    19  		},
    20  		{
    21  			Name:   "bridge",
    22  			Driver: "bridge",
    23  			Scope:  "local",
    24  		},
    25  		{
    26  			Name:   "none",
    27  			Driver: "null",
    28  			Scope:  "local",
    29  		},
    30  		{
    31  			Name:   "myoverlay",
    32  			Driver: "overlay",
    33  			Scope:  "swarm",
    34  		},
    35  		{
    36  			Name:   "mydrivernet",
    37  			Driver: "mydriver",
    38  			Scope:  "local",
    39  		},
    40  		{
    41  			Name:   "mykvnet",
    42  			Driver: "mykvdriver",
    43  			Scope:  "global",
    44  		},
    45  		{
    46  			Name:   "networkwithcontainer",
    47  			Driver: "nwc",
    48  			Scope:  "local",
    49  			Containers: map[string]types.EndpointResource{
    50  				"customcontainer": {
    51  					Name: "customendpoint",
    52  				},
    53  			},
    54  		},
    55  	}
    56  
    57  	testCases := []struct {
    58  		filter      filters.Args
    59  		resultCount int
    60  		err         string
    61  		name        string
    62  		results     []string
    63  	}{
    64  		{
    65  			filter:      filters.NewArgs(filters.Arg("driver", "bridge")),
    66  			resultCount: 1,
    67  			err:         "",
    68  			name:        "bridge driver filters",
    69  		},
    70  		{
    71  			filter:      filters.NewArgs(filters.Arg("driver", "overlay")),
    72  			resultCount: 1,
    73  			err:         "",
    74  			name:        "overlay driver filters",
    75  		},
    76  		{
    77  			filter:      filters.NewArgs(filters.Arg("driver", "noname")),
    78  			resultCount: 0,
    79  			err:         "",
    80  			name:        "no name driver filters",
    81  		},
    82  		{
    83  			filter:      filters.NewArgs(filters.Arg("type", "custom")),
    84  			resultCount: 4,
    85  			err:         "",
    86  			name:        "custom driver filters",
    87  		},
    88  		{
    89  			filter:      filters.NewArgs(filters.Arg("type", "builtin")),
    90  			resultCount: 3,
    91  			err:         "",
    92  			name:        "builtin driver filters",
    93  		},
    94  		{
    95  			filter:      filters.NewArgs(filters.Arg("type", "invalid")),
    96  			resultCount: 0,
    97  			err:         "invalid filter: 'type'='invalid'",
    98  			name:        "invalid driver filters",
    99  		},
   100  		{
   101  			filter:      filters.NewArgs(filters.Arg("scope", "local")),
   102  			resultCount: 5,
   103  			err:         "",
   104  			name:        "local scope filters",
   105  		},
   106  		{
   107  			filter:      filters.NewArgs(filters.Arg("scope", "swarm")),
   108  			resultCount: 1,
   109  			err:         "",
   110  			name:        "swarm scope filters",
   111  		},
   112  		{
   113  			filter:      filters.NewArgs(filters.Arg("scope", "global")),
   114  			resultCount: 1,
   115  			err:         "",
   116  			name:        "global scope filters",
   117  		},
   118  		{
   119  			filter:      filters.NewArgs(filters.Arg("dangling", "true")),
   120  			resultCount: 3,
   121  			err:         "",
   122  			name:        "dangling filter is 'True'",
   123  			results:     []string{"myoverlay", "mydrivernet", "mykvnet"},
   124  		},
   125  		{
   126  			filter:      filters.NewArgs(filters.Arg("dangling", "false")),
   127  			resultCount: 4,
   128  			err:         "",
   129  			name:        "dangling filter is 'False'",
   130  			results:     []string{"host", "bridge", "none", "networkwithcontainer"},
   131  		},
   132  	}
   133  
   134  	for _, testCase := range testCases {
   135  		t.Run(testCase.name, func(t *testing.T) {
   136  			ls := make([]types.NetworkResource, 0, len(networks))
   137  			ls = append(ls, networks...)
   138  			result, err := FilterNetworks(ls, testCase.filter)
   139  			if testCase.err != "" {
   140  				if err == nil {
   141  					t.Fatalf("expect error '%s', got no error", testCase.err)
   142  				} else if !strings.Contains(err.Error(), testCase.err) {
   143  					t.Fatalf("expect error '%s', got '%s'", testCase.err, err)
   144  				}
   145  			} else {
   146  				if err != nil {
   147  					t.Fatalf("expect no error, got error '%s'", err)
   148  				}
   149  				// Make sure result is not nil
   150  				if result == nil {
   151  					t.Fatal("filterNetworks should not return nil")
   152  				}
   153  
   154  				if len(result) != testCase.resultCount {
   155  					t.Fatalf("expect '%d' networks, got '%d' networks", testCase.resultCount, len(result))
   156  				}
   157  
   158  				if len(testCase.results) > 0 {
   159  					resultMap := make(map[string]bool)
   160  					for _, r := range result {
   161  						resultMap[r.Name] = true
   162  					}
   163  					for _, r := range testCase.results {
   164  						if _, ok := resultMap[r]; !ok {
   165  							t.Fatalf("expected result: '%s' not found", r)
   166  						}
   167  					}
   168  				}
   169  			}
   170  		})
   171  	}
   172  }