github.com/rawahars/moby@v24.0.4+incompatible/daemon/network/filter_test.go (about)

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