gopkg.in/docker/docker.v20@v20.10.27/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  	bridgeDriverFilters := filters.NewArgs()
    59  	bridgeDriverFilters.Add("driver", "bridge")
    60  
    61  	overlayDriverFilters := filters.NewArgs()
    62  	overlayDriverFilters.Add("driver", "overlay")
    63  
    64  	nonameDriverFilters := filters.NewArgs()
    65  	nonameDriverFilters.Add("driver", "noname")
    66  
    67  	customDriverFilters := filters.NewArgs()
    68  	customDriverFilters.Add("type", "custom")
    69  
    70  	builtinDriverFilters := filters.NewArgs()
    71  	builtinDriverFilters.Add("type", "builtin")
    72  
    73  	invalidDriverFilters := filters.NewArgs()
    74  	invalidDriverFilters.Add("type", "invalid")
    75  
    76  	localScopeFilters := filters.NewArgs()
    77  	localScopeFilters.Add("scope", "local")
    78  
    79  	swarmScopeFilters := filters.NewArgs()
    80  	swarmScopeFilters.Add("scope", "swarm")
    81  
    82  	globalScopeFilters := filters.NewArgs()
    83  	globalScopeFilters.Add("scope", "global")
    84  
    85  	trueDanglingFilters := filters.NewArgs()
    86  	trueDanglingFilters.Add("dangling", "true")
    87  
    88  	falseDanglingFilters := filters.NewArgs()
    89  	falseDanglingFilters.Add("dangling", "false")
    90  
    91  	testCases := []struct {
    92  		filter      filters.Args
    93  		resultCount int
    94  		err         string
    95  		name        string
    96  		results     []string
    97  	}{
    98  		{
    99  			filter:      bridgeDriverFilters,
   100  			resultCount: 1,
   101  			err:         "",
   102  			name:        "bridge driver filters",
   103  		},
   104  		{
   105  			filter:      overlayDriverFilters,
   106  			resultCount: 1,
   107  			err:         "",
   108  			name:        "overlay driver filters",
   109  		},
   110  		{
   111  			filter:      nonameDriverFilters,
   112  			resultCount: 0,
   113  			err:         "",
   114  			name:        "no name driver filters",
   115  		},
   116  		{
   117  			filter:      customDriverFilters,
   118  			resultCount: 4,
   119  			err:         "",
   120  			name:        "custom driver filters",
   121  		},
   122  		{
   123  			filter:      builtinDriverFilters,
   124  			resultCount: 3,
   125  			err:         "",
   126  			name:        "builtin driver filters",
   127  		},
   128  		{
   129  			filter:      invalidDriverFilters,
   130  			resultCount: 0,
   131  			err:         "invalid filter: 'type'='invalid'",
   132  			name:        "invalid driver filters",
   133  		},
   134  		{
   135  			filter:      localScopeFilters,
   136  			resultCount: 5,
   137  			err:         "",
   138  			name:        "local scope filters",
   139  		},
   140  		{
   141  			filter:      swarmScopeFilters,
   142  			resultCount: 1,
   143  			err:         "",
   144  			name:        "swarm scope filters",
   145  		},
   146  		{
   147  			filter:      globalScopeFilters,
   148  			resultCount: 1,
   149  			err:         "",
   150  			name:        "global scope filters",
   151  		},
   152  		{
   153  			filter:      trueDanglingFilters,
   154  			resultCount: 3,
   155  			err:         "",
   156  			name:        "dangling filter is 'True'",
   157  			results:     []string{"myoverlay", "mydrivernet", "mykvnet"},
   158  		},
   159  		{
   160  			filter:      falseDanglingFilters,
   161  			resultCount: 4,
   162  			err:         "",
   163  			name:        "dangling filter is 'False'",
   164  			results:     []string{"host", "bridge", "none", "networkwithcontainer"},
   165  		},
   166  	}
   167  
   168  	for _, testCase := range testCases {
   169  		t.Run(testCase.name, func(t *testing.T) {
   170  			ls := make([]types.NetworkResource, 0, len(networks))
   171  			ls = append(ls, networks...)
   172  			result, err := FilterNetworks(ls, testCase.filter)
   173  			if testCase.err != "" {
   174  				if err == nil {
   175  					t.Fatalf("expect error '%s', got no error", testCase.err)
   176  
   177  				} else if !strings.Contains(err.Error(), testCase.err) {
   178  					t.Fatalf("expect error '%s', got '%s'", testCase.err, err)
   179  				}
   180  			} else {
   181  				if err != nil {
   182  					t.Fatalf("expect no error, got error '%s'", err)
   183  				}
   184  				// Make sure result is not nil
   185  				if result == nil {
   186  					t.Fatal("filterNetworks should not return nil")
   187  				}
   188  
   189  				if len(result) != testCase.resultCount {
   190  					t.Fatalf("expect '%d' networks, got '%d' networks", testCase.resultCount, len(result))
   191  				}
   192  
   193  				if len(testCase.results) > 0 {
   194  					resultMap := make(map[string]bool)
   195  					for _, r := range result {
   196  						resultMap[r.Name] = true
   197  					}
   198  					for _, r := range testCase.results {
   199  						if _, ok := resultMap[r]; !ok {
   200  							t.Fatalf("expected result: '%s' not found", r)
   201  						}
   202  					}
   203  				}
   204  			}
   205  		})
   206  	}
   207  }