github.com/robgonnella/ardi/v2@v2.4.5-0.20230102052001-11a49de978c3/commands/list_test.go (about)

     1  package commands_test
     2  
     3  import (
     4  	"errors"
     5  	"path"
     6  	"testing"
     7  
     8  	rpc "github.com/arduino/arduino-cli/rpc/cc/arduino/cli/commands/v1"
     9  	"github.com/golang/mock/gomock"
    10  	"github.com/robgonnella/ardi/v2/testutil"
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  func TestListPlatformCommand(t *testing.T) {
    15  	instance := &rpc.Instance{Id: 1}
    16  
    17  	platformReq := &rpc.PlatformListRequest{
    18  		Instance:      instance,
    19  		UpdatableOnly: false,
    20  		All:           false,
    21  	}
    22  
    23  	testutil.RunMockIntegrationTest("errors if project not initialized", t, func(env *testutil.MockIntegrationTestEnv) {
    24  		args := []string{"list", "platforms"}
    25  		err := env.Execute(args)
    26  		assert.Error(env.T, err)
    27  	})
    28  
    29  	testutil.RunMockIntegrationTest("lists platforms", t, func(env *testutil.MockIntegrationTestEnv) {
    30  		err := env.RunProjectInit()
    31  		assert.NoError(env.T, err)
    32  
    33  		expectedPlatform := &rpc.Platform{
    34  			Id:        "cool:platform",
    35  			Installed: "1.2.3",
    36  			Latest:    "1.2.3",
    37  			Name:      "Super Cool Platform",
    38  		}
    39  
    40  		expectedPlatforms := []*rpc.Platform{expectedPlatform}
    41  
    42  		env.ArduinoCli.EXPECT().CreateInstance().Return(instance)
    43  		env.ArduinoCli.EXPECT().GetPlatforms(platformReq).Return(expectedPlatforms, nil)
    44  
    45  		args := []string{"list", "platforms"}
    46  		err = env.Execute(args)
    47  		assert.NoError(env.T, err)
    48  		assert.Contains(env.T, env.Stdout.String(), expectedPlatform.Name)
    49  	})
    50  
    51  	testutil.RunMockIntegrationTest("returns list platforms error", t, func(env *testutil.MockIntegrationTestEnv) {
    52  		err := env.RunProjectInit()
    53  		assert.NoError(env.T, err)
    54  
    55  		dummyErr := errors.New("dummy error")
    56  
    57  		env.ArduinoCli.EXPECT().CreateInstance().Return(instance)
    58  		env.ArduinoCli.EXPECT().GetPlatforms(platformReq).Return(nil, dummyErr)
    59  
    60  		args := []string{"list", "platforms"}
    61  		err = env.Execute(args)
    62  		assert.Error(env.T, err)
    63  		assert.ErrorIs(env.T, err, dummyErr)
    64  	})
    65  }
    66  
    67  func TestListBoardInfoCommands(t *testing.T) {
    68  	instance := &rpc.Instance{Id: 1}
    69  
    70  	platformReq := &rpc.PlatformSearchRequest{
    71  		Instance:    instance,
    72  		AllVersions: false,
    73  	}
    74  
    75  	board := &rpc.Board{
    76  		Name: "Super cool board",
    77  		Fqbn: "super:cool:fqbn",
    78  	}
    79  
    80  	platform := &rpc.Platform{
    81  		Id:     "super:cool",
    82  		Name:   "Super cool platform",
    83  		Boards: []*rpc.Board{board},
    84  	}
    85  
    86  	platformResp := &rpc.PlatformSearchResponse{
    87  		SearchOutput: []*rpc.Platform{platform},
    88  	}
    89  
    90  	testutil.RunMockIntegrationTest("errors if project not initialized - fqbns", t, func(env *testutil.MockIntegrationTestEnv) {
    91  		args := []string{"list", "board-fqbns"}
    92  		err := env.Execute(args)
    93  		assert.Error(env.T, err)
    94  	})
    95  
    96  	testutil.RunMockIntegrationTest("lists board fqbns", t, func(env *testutil.MockIntegrationTestEnv) {
    97  		err := env.RunProjectInit()
    98  		assert.NoError(env.T, err)
    99  
   100  		env.ArduinoCli.EXPECT().CreateInstance().Return(instance)
   101  		env.ArduinoCli.EXPECT().UpdateIndex(gomock.Any(), gomock.Any(), gomock.Any())
   102  		env.ArduinoCli.EXPECT().PlatformSearch(platformReq).Return(platformResp, nil)
   103  
   104  		args := []string{"list", "board-fqbns"}
   105  		err = env.Execute(args)
   106  		assert.NoError(env.T, err)
   107  		assert.Contains(env.T, env.Stdout.String(), board.Name)
   108  		assert.Contains(env.T, env.Stdout.String(), board.Fqbn)
   109  	})
   110  
   111  	testutil.RunMockIntegrationTest("returns list board fqbns error", t, func(env *testutil.MockIntegrationTestEnv) {
   112  		err := env.RunProjectInit()
   113  		assert.NoError(env.T, err)
   114  
   115  		dummyErr := errors.New("dummy error")
   116  
   117  		env.ArduinoCli.EXPECT().CreateInstance().Return(instance)
   118  		env.ArduinoCli.EXPECT().UpdateIndex(gomock.Any(), gomock.Any(), gomock.Any())
   119  		env.ArduinoCli.EXPECT().PlatformSearch(platformReq).Return(nil, dummyErr)
   120  
   121  		args := []string{"list", "board-fqbns"}
   122  		err = env.Execute(args)
   123  		assert.Error(env.T, err)
   124  		assert.ErrorIs(env.T, err, dummyErr)
   125  	})
   126  
   127  	testutil.RunMockIntegrationTest("errors if project not initialized - platforms", t, func(env *testutil.MockIntegrationTestEnv) {
   128  		args := []string{"list", "board-platforms"}
   129  		err := env.Execute(args)
   130  		assert.Error(env.T, err)
   131  	})
   132  
   133  	testutil.RunMockIntegrationTest("lists board platforms", t, func(env *testutil.MockIntegrationTestEnv) {
   134  		err := env.RunProjectInit()
   135  		assert.NoError(env.T, err)
   136  
   137  		env.ArduinoCli.EXPECT().CreateInstance().Return(instance)
   138  		env.ArduinoCli.EXPECT().UpdateIndex(gomock.Any(), gomock.Any(), gomock.Any())
   139  		env.ArduinoCli.EXPECT().PlatformSearch(platformReq).Return(platformResp, nil)
   140  
   141  		args := []string{"list", "board-platforms"}
   142  		err = env.Execute(args)
   143  		assert.NoError(env.T, err)
   144  		assert.Contains(env.T, env.Stdout.String(), board.Name)
   145  		assert.Contains(env.T, env.Stdout.String(), platform.Id)
   146  	})
   147  
   148  	testutil.RunMockIntegrationTest("returns list board platforms error", t, func(env *testutil.MockIntegrationTestEnv) {
   149  		err := env.RunProjectInit()
   150  		assert.NoError(env.T, err)
   151  
   152  		dummyErr := errors.New("dummy error")
   153  
   154  		env.ArduinoCli.EXPECT().CreateInstance().Return(instance)
   155  		env.ArduinoCli.EXPECT().UpdateIndex(gomock.Any(), gomock.Any(), gomock.Any())
   156  		env.ArduinoCli.EXPECT().PlatformSearch(platformReq).Return(nil, dummyErr)
   157  
   158  		args := []string{"list", "board-platforms"}
   159  		err = env.Execute(args)
   160  		assert.Error(env.T, err)
   161  		assert.ErrorIs(env.T, err, dummyErr)
   162  	})
   163  }
   164  
   165  func TestListLibraryCommand(t *testing.T) {
   166  	instance := &rpc.Instance{Id: 1}
   167  
   168  	listReq := &rpc.LibraryListRequest{
   169  		Instance: instance,
   170  	}
   171  
   172  	testutil.RunMockIntegrationTest("errors if project not initialized", t, func(env *testutil.MockIntegrationTestEnv) {
   173  		args := []string{"list", "libs"}
   174  		err := env.Execute(args)
   175  		assert.Error(env.T, err)
   176  	})
   177  
   178  	testutil.RunMockIntegrationTest("lists installed libraries", t, func(env *testutil.MockIntegrationTestEnv) {
   179  		err := env.RunProjectInit()
   180  		assert.NoError(env.T, err)
   181  
   182  		installedLib := &rpc.InstalledLibrary{
   183  			Library: &rpc.Library{
   184  				Name:    "Some_Cool_Library",
   185  				Version: "1.3.5",
   186  			},
   187  		}
   188  		listResp := &rpc.LibraryListResponse{
   189  			InstalledLibraries: []*rpc.InstalledLibrary{installedLib},
   190  		}
   191  
   192  		env.ArduinoCli.EXPECT().CreateInstance().Return(instance)
   193  		env.ArduinoCli.EXPECT().LibraryList(gomock.Any(), listReq).Return(listResp, nil)
   194  
   195  		args := []string{"list", "libs"}
   196  		err = env.Execute(args)
   197  		assert.NoError(env.T, err)
   198  		assert.Contains(env.T, env.Stdout.String(), installedLib.Library.Name)
   199  		assert.Contains(env.T, env.Stdout.String(), installedLib.Library.Version)
   200  	})
   201  
   202  	testutil.RunMockIntegrationTest("returns list libs error", t, func(env *testutil.MockIntegrationTestEnv) {
   203  		err := env.RunProjectInit()
   204  		assert.NoError(env.T, err)
   205  
   206  		dummyErr := errors.New("dummy error")
   207  
   208  		env.ArduinoCli.EXPECT().CreateInstance().Return(instance)
   209  		env.ArduinoCli.EXPECT().LibraryList(gomock.Any(), listReq).Return(nil, dummyErr)
   210  
   211  		args := []string{"list", "libs"}
   212  		err = env.Execute(args)
   213  		assert.Error(env.T, err)
   214  		assert.ErrorIs(env.T, err, dummyErr)
   215  	})
   216  }
   217  
   218  func TestListBuildCommand(t *testing.T) {
   219  	build := "cool"
   220  	fqbn := "super:cool:fqbn"
   221  	sketchDir := testutil.BlinkProjectDir()
   222  	sketch := path.Join(sketchDir, "blink.ino")
   223  
   224  	testutil.RunMockIntegrationTest("errors if project not initialized", t, func(env *testutil.MockIntegrationTestEnv) {
   225  		args := []string{"list", "builds"}
   226  		err := env.Execute(args)
   227  		assert.Error(env.T, err)
   228  	})
   229  
   230  	testutil.RunMockIntegrationTest("lists builds", t, func(env *testutil.MockIntegrationTestEnv) {
   231  		err := env.RunProjectInit()
   232  		assert.NoError(env.T, err)
   233  
   234  		args := []string{"add", "build", "-n", build, "-f", fqbn, "-s", sketch}
   235  		err = env.Execute(args)
   236  		assert.NoError(env.T, err)
   237  
   238  		args = []string{"list", "builds"}
   239  		err = env.Execute(args)
   240  		assert.NoError(env.T, err)
   241  		assert.Contains(env.T, env.Stdout.String(), build)
   242  		assert.Contains(env.T, env.Stdout.String(), fqbn)
   243  		assert.Contains(env.T, env.Stdout.String(), sketchDir)
   244  		assert.Contains(env.T, env.Stdout.String(), sketch)
   245  	})
   246  
   247  	testutil.RunMockIntegrationTest("doesnt error if no builds to list", t, func(env *testutil.MockIntegrationTestEnv) {
   248  		err := env.RunProjectInit()
   249  		assert.NoError(env.T, err)
   250  
   251  		args := []string{"list", "builds"}
   252  		err = env.Execute(args)
   253  		assert.NoError(env.T, err)
   254  	})
   255  }
   256  
   257  func TestListBoardURLCommand(t *testing.T) {
   258  	testutil.RunMockIntegrationTest("errors if project not initialized", t, func(env *testutil.MockIntegrationTestEnv) {
   259  		args := []string{"list", "board-urls"}
   260  		err := env.Execute(args)
   261  		assert.Error(env.T, err)
   262  	})
   263  
   264  	testutil.RunMockIntegrationTest("lists board urls", t, func(env *testutil.MockIntegrationTestEnv) {
   265  		err := env.RunProjectInit()
   266  		assert.NoError(env.T, err)
   267  
   268  		boardUrl := "https://somecoolboardurl.com"
   269  		args := []string{"add", "board-url", boardUrl}
   270  		err = env.Execute(args)
   271  		assert.NoError(env.T, err)
   272  
   273  		args = []string{"list", "board-urls"}
   274  		err = env.Execute(args)
   275  		assert.NoError(env.T, err)
   276  		assert.Contains(env.T, env.Stdout.String(), boardUrl)
   277  	})
   278  
   279  	testutil.RunMockIntegrationTest("doesnt error if no board urls to list", t, func(env *testutil.MockIntegrationTestEnv) {
   280  		err := env.RunProjectInit()
   281  		assert.NoError(env.T, err)
   282  
   283  		args := []string{"list", "board-urls"}
   284  		err = env.Execute(args)
   285  		assert.NoError(env.T, err)
   286  	})
   287  }