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

     1  package core_test
     2  
     3  import (
     4  	"errors"
     5  	"testing"
     6  
     7  	rpc "github.com/arduino/arduino-cli/rpc/cc/arduino/cli/commands/v1"
     8  	"github.com/golang/mock/gomock"
     9  	"github.com/robgonnella/ardi/v2/testutil"
    10  	"github.com/stretchr/testify/assert"
    11  )
    12  
    13  // @todo: check that list is actually sorted
    14  func TestPlatformCore(t *testing.T) {
    15  	testutil.RunUnitTest("prints sorted list of all installed platforms to stdout", t, func(env *testutil.UnitTestEnv) {
    16  		platform1 := rpc.Platform{
    17  			Name: "test-platform-1",
    18  		}
    19  
    20  		platform2 := rpc.Platform{
    21  			Name: "test-platform-2",
    22  		}
    23  		platforms := []*rpc.Platform{&platform2, &platform1}
    24  
    25  		instance := &rpc.Instance{Id: int32(1)}
    26  		req := &rpc.PlatformListRequest{
    27  			Instance:      instance,
    28  			UpdatableOnly: false,
    29  			All:           false,
    30  		}
    31  
    32  		env.ArduinoCli.EXPECT().CreateInstance().Return(instance).AnyTimes()
    33  		env.ArduinoCli.EXPECT().GetPlatforms(req).Return(platforms, nil)
    34  
    35  		err := env.ArdiCore.Platform.ListInstalled()
    36  		assert.NoError(env.T, err)
    37  
    38  		assert.Contains(env.T, env.Stdout.String(), platform1.Name)
    39  		assert.Contains(env.T, env.Stdout.String(), platform2.Name)
    40  	})
    41  
    42  	// @todo: check that list is actually sorted
    43  	testutil.RunUnitTest("prints sorted list of all available platforms to stdout", t, func(env *testutil.UnitTestEnv) {
    44  		platform1 := rpc.Platform{
    45  			Name: "test-platform-1",
    46  		}
    47  
    48  		platform2 := rpc.Platform{
    49  			Name: "test-platform-2",
    50  		}
    51  		platforms := []*rpc.Platform{&platform2, &platform1}
    52  
    53  		instance := &rpc.Instance{Id: int32(1)}
    54  		req := &rpc.PlatformSearchRequest{
    55  			Instance:    instance,
    56  			AllVersions: false,
    57  		}
    58  		resp := &rpc.PlatformSearchResponse{
    59  			SearchOutput: platforms,
    60  		}
    61  		env.ArduinoCli.EXPECT().CreateInstance().Return(instance).AnyTimes()
    62  		env.ArduinoCli.EXPECT().UpdateIndex(gomock.Any(), gomock.Any(), gomock.Any()).Times(2)
    63  		env.ArduinoCli.EXPECT().PlatformSearch(req).Return(resp, nil)
    64  
    65  		err := env.ArdiCore.Platform.ListAll()
    66  		assert.NoError(env.T, err)
    67  
    68  		assert.Contains(env.T, env.Stdout.String(), platform1.Name)
    69  		assert.Contains(env.T, env.Stdout.String(), platform2.Name)
    70  	})
    71  
    72  	testutil.RunUnitTest("adds platforms", t, func(env *testutil.UnitTestEnv) {
    73  		platform1 := &rpc.Platform{
    74  			Id:        "test:platform1",
    75  			Name:      "Platform1",
    76  			Installed: "1.3.8",
    77  		}
    78  
    79  		platform2 := &rpc.Platform{
    80  			Id:        "test:platform2",
    81  			Name:      "Platform2",
    82  			Installed: "3.1.9",
    83  		}
    84  
    85  		instance := &rpc.Instance{Id: int32(1)}
    86  		req1 := &rpc.PlatformInstallRequest{
    87  			Instance:        instance,
    88  			PlatformPackage: "test",
    89  			Architecture:    "platform1",
    90  		}
    91  		req2 := &rpc.PlatformInstallRequest{
    92  			Instance:        instance,
    93  			PlatformPackage: "test",
    94  			Architecture:    "platform2",
    95  		}
    96  
    97  		listReq := &rpc.PlatformListRequest{
    98  			Instance:      instance,
    99  			UpdatableOnly: false,
   100  			All:           false,
   101  		}
   102  		platforms := []*rpc.Platform{platform1, platform2}
   103  
   104  		env.ArduinoCli.EXPECT().CreateInstance().Return(instance).AnyTimes()
   105  		env.ArduinoCli.EXPECT().UpdateIndex(gomock.Any(), gomock.Any(), gomock.Any())
   106  
   107  		env.ArduinoCli.EXPECT().PlatformInstall(gomock.Any(), req1, gomock.Any(), gomock.Any())
   108  		env.ArduinoCli.EXPECT().GetPlatforms(listReq).Return([]*rpc.Platform{platform1}, nil)
   109  
   110  		env.ArduinoCli.EXPECT().PlatformInstall(gomock.Any(), req2, gomock.Any(), gomock.Any())
   111  		env.ArduinoCli.EXPECT().GetPlatforms(listReq).Return(platforms, nil)
   112  
   113  		for _, p := range platforms {
   114  			installed, _, err := env.ArdiCore.Platform.Add(p.GetId())
   115  			assert.NoError(env.T, err)
   116  			assert.Equal(env.T, p.GetId(), installed)
   117  		}
   118  	})
   119  
   120  	testutil.RunUnitTest("returns 'platform add' error", t, func(env *testutil.UnitTestEnv) {
   121  		errString := "dummy error"
   122  		dummyErr := errors.New(errString)
   123  
   124  		platform1 := &rpc.Platform{
   125  			Id:        "test:platform1",
   126  			Name:      "Platform1",
   127  			Installed: "1.3.8",
   128  		}
   129  
   130  		platform2 := &rpc.Platform{
   131  			Id:        "test:platform2",
   132  			Name:      "Platform2",
   133  			Installed: "3.1.9",
   134  		}
   135  
   136  		instance := &rpc.Instance{Id: int32(1)}
   137  
   138  		req1 := &rpc.PlatformInstallRequest{
   139  			Instance:        instance,
   140  			PlatformPackage: "test",
   141  			Architecture:    "platform1",
   142  		}
   143  
   144  		req2 := &rpc.PlatformInstallRequest{
   145  			Instance:        instance,
   146  			PlatformPackage: "test",
   147  			Architecture:    "platform2",
   148  		}
   149  
   150  		platforms := []*rpc.Platform{platform1, platform2}
   151  
   152  		env.ArduinoCli.EXPECT().CreateInstance().Return(instance).AnyTimes()
   153  		env.ArduinoCli.EXPECT().UpdateIndex(gomock.Any(), gomock.Any(), gomock.Any())
   154  		env.ArduinoCli.EXPECT().PlatformInstall(gomock.Any(), req1, gomock.Any(), gomock.Any()).Return(nil, dummyErr)
   155  		env.ArduinoCli.EXPECT().PlatformInstall(gomock.Any(), req2, gomock.Any(), gomock.Any()).Return(nil, dummyErr)
   156  
   157  		for _, p := range platforms {
   158  			_, _, err := env.ArdiCore.Platform.Add(p.GetId())
   159  			assert.Error(env.T, err)
   160  			assert.EqualError(env.T, err, errString)
   161  		}
   162  	})
   163  
   164  	testutil.RunUnitTest("removes a platforms", t, func(env *testutil.UnitTestEnv) {
   165  		platform1 := &rpc.Platform{
   166  			Id:        "test:platform1",
   167  			Name:      "Platform1",
   168  			Installed: "1.3.8",
   169  		}
   170  
   171  		platform2 := &rpc.Platform{
   172  			Id:        "test:platform2",
   173  			Name:      "Platform2",
   174  			Installed: "3.1.9",
   175  		}
   176  
   177  		instance := &rpc.Instance{Id: int32(1)}
   178  
   179  		req1 := &rpc.PlatformUninstallRequest{
   180  			Instance:        instance,
   181  			PlatformPackage: "test",
   182  			Architecture:    "platform1",
   183  		}
   184  
   185  		req2 := &rpc.PlatformUninstallRequest{
   186  			Instance:        instance,
   187  			PlatformPackage: "test",
   188  			Architecture:    "platform2",
   189  		}
   190  
   191  		platforms := []*rpc.Platform{platform1, platform2}
   192  
   193  		env.ArduinoCli.EXPECT().CreateInstance().Return(instance).AnyTimes()
   194  		env.ArduinoCli.EXPECT().PlatformUninstall(gomock.Any(), req1, gomock.Any())
   195  		env.ArduinoCli.EXPECT().PlatformUninstall(gomock.Any(), req2, gomock.Any())
   196  
   197  		for _, p := range platforms {
   198  			removed, err := env.ArdiCore.Platform.Remove(p.GetId())
   199  			assert.NoError(env.T, err)
   200  			assert.Equal(env.T, p.GetId(), removed)
   201  		}
   202  	})
   203  
   204  	testutil.RunUnitTest("returns platform remove error", t, func(env *testutil.UnitTestEnv) {
   205  		errString := "dummy error"
   206  		dummyErr := errors.New(errString)
   207  
   208  		platform1 := &rpc.Platform{
   209  			Id:        "test:platform1",
   210  			Name:      "Platform1",
   211  			Installed: "1.3.8",
   212  		}
   213  
   214  		platform2 := &rpc.Platform{
   215  			Id:        "test:platform2",
   216  			Name:      "Platform2",
   217  			Installed: "3.1.9",
   218  		}
   219  
   220  		instance := &rpc.Instance{Id: int32(1)}
   221  
   222  		req1 := &rpc.PlatformUninstallRequest{
   223  			Instance:        instance,
   224  			PlatformPackage: "test",
   225  			Architecture:    "platform1",
   226  		}
   227  
   228  		req2 := &rpc.PlatformUninstallRequest{
   229  			Instance:        instance,
   230  			PlatformPackage: "test",
   231  			Architecture:    "platform2",
   232  		}
   233  
   234  		platforms := []*rpc.Platform{platform1, platform2}
   235  
   236  		env.ArduinoCli.EXPECT().CreateInstance().Return(instance).AnyTimes()
   237  		env.ArduinoCli.EXPECT().PlatformUninstall(gomock.Any(), req1, gomock.Any()).Return(nil, dummyErr)
   238  		env.ArduinoCli.EXPECT().PlatformUninstall(gomock.Any(), req2, gomock.Any()).Return(nil, dummyErr)
   239  
   240  		for _, p := range platforms {
   241  			_, err := env.ArdiCore.Platform.Remove(p.GetId())
   242  			assert.Error(env.T, err)
   243  			assert.EqualError(env.T, err, errString)
   244  		}
   245  	})
   246  }