github.com/panekj/cli@v0.0.0-20230304125325-467dd2f3797e/cli/command/idresolver/idresolver_test.go (about)

     1  package idresolver
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	. "github.com/docker/cli/internal/test/builders" // Import builders to get the builder function as package function
     8  	"github.com/docker/docker/api/types/swarm"
     9  	"github.com/pkg/errors"
    10  	"gotest.tools/v3/assert"
    11  	is "gotest.tools/v3/assert/cmp"
    12  )
    13  
    14  func TestResolveError(t *testing.T) {
    15  	cli := &fakeClient{
    16  		nodeInspectFunc: func(nodeID string) (swarm.Node, []byte, error) {
    17  			return swarm.Node{}, []byte{}, errors.Errorf("error inspecting node")
    18  		},
    19  	}
    20  
    21  	idResolver := New(cli, false)
    22  	_, err := idResolver.Resolve(context.Background(), struct{}{}, "nodeID")
    23  
    24  	assert.Error(t, err, "unsupported type")
    25  }
    26  
    27  func TestResolveWithNoResolveOption(t *testing.T) {
    28  	resolved := false
    29  	cli := &fakeClient{
    30  		nodeInspectFunc: func(nodeID string) (swarm.Node, []byte, error) {
    31  			resolved = true
    32  			return swarm.Node{}, []byte{}, nil
    33  		},
    34  		serviceInspectFunc: func(serviceID string) (swarm.Service, []byte, error) {
    35  			resolved = true
    36  			return swarm.Service{}, []byte{}, nil
    37  		},
    38  	}
    39  
    40  	idResolver := New(cli, true)
    41  	id, err := idResolver.Resolve(context.Background(), swarm.Node{}, "nodeID")
    42  
    43  	assert.NilError(t, err)
    44  	assert.Check(t, is.Equal("nodeID", id))
    45  	assert.Check(t, !resolved)
    46  }
    47  
    48  func TestResolveWithCache(t *testing.T) {
    49  	inspectCounter := 0
    50  	cli := &fakeClient{
    51  		nodeInspectFunc: func(nodeID string) (swarm.Node, []byte, error) {
    52  			inspectCounter++
    53  			return *Node(NodeName("node-foo")), []byte{}, nil
    54  		},
    55  	}
    56  
    57  	idResolver := New(cli, false)
    58  
    59  	ctx := context.Background()
    60  	for i := 0; i < 2; i++ {
    61  		id, err := idResolver.Resolve(ctx, swarm.Node{}, "nodeID")
    62  		assert.NilError(t, err)
    63  		assert.Check(t, is.Equal("node-foo", id))
    64  	}
    65  
    66  	assert.Check(t, is.Equal(1, inspectCounter))
    67  }
    68  
    69  func TestResolveNode(t *testing.T) {
    70  	testCases := []struct {
    71  		nodeID          string
    72  		nodeInspectFunc func(string) (swarm.Node, []byte, error)
    73  		expectedID      string
    74  	}{
    75  		{
    76  			nodeID: "nodeID",
    77  			nodeInspectFunc: func(string) (swarm.Node, []byte, error) {
    78  				return swarm.Node{}, []byte{}, errors.Errorf("error inspecting node")
    79  			},
    80  			expectedID: "nodeID",
    81  		},
    82  		{
    83  			nodeID: "nodeID",
    84  			nodeInspectFunc: func(string) (swarm.Node, []byte, error) {
    85  				return *Node(NodeName("node-foo")), []byte{}, nil
    86  			},
    87  			expectedID: "node-foo",
    88  		},
    89  		{
    90  			nodeID: "nodeID",
    91  			nodeInspectFunc: func(string) (swarm.Node, []byte, error) {
    92  				return *Node(NodeName(""), Hostname("node-hostname")), []byte{}, nil
    93  			},
    94  			expectedID: "node-hostname",
    95  		},
    96  	}
    97  
    98  	ctx := context.Background()
    99  	for _, tc := range testCases {
   100  		cli := &fakeClient{
   101  			nodeInspectFunc: tc.nodeInspectFunc,
   102  		}
   103  		idResolver := New(cli, false)
   104  		id, err := idResolver.Resolve(ctx, swarm.Node{}, tc.nodeID)
   105  
   106  		assert.NilError(t, err)
   107  		assert.Check(t, is.Equal(tc.expectedID, id))
   108  	}
   109  }
   110  
   111  func TestResolveService(t *testing.T) {
   112  	testCases := []struct {
   113  		serviceID          string
   114  		serviceInspectFunc func(string) (swarm.Service, []byte, error)
   115  		expectedID         string
   116  	}{
   117  		{
   118  			serviceID: "serviceID",
   119  			serviceInspectFunc: func(string) (swarm.Service, []byte, error) {
   120  				return swarm.Service{}, []byte{}, errors.Errorf("error inspecting service")
   121  			},
   122  			expectedID: "serviceID",
   123  		},
   124  		{
   125  			serviceID: "serviceID",
   126  			serviceInspectFunc: func(string) (swarm.Service, []byte, error) {
   127  				return *Service(ServiceName("service-foo")), []byte{}, nil
   128  			},
   129  			expectedID: "service-foo",
   130  		},
   131  	}
   132  
   133  	ctx := context.Background()
   134  	for _, tc := range testCases {
   135  		cli := &fakeClient{
   136  			serviceInspectFunc: tc.serviceInspectFunc,
   137  		}
   138  		idResolver := New(cli, false)
   139  		id, err := idResolver.Resolve(ctx, swarm.Service{}, tc.serviceID)
   140  
   141  		assert.NilError(t, err)
   142  		assert.Check(t, is.Equal(tc.expectedID, id))
   143  	}
   144  }