| // Copyright 2020 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| package main |
| |
| import ( |
| "errors" |
| "fmt" |
| "testing" |
| |
| "go.fuchsia.dev/fuchsia/tools/sdk-tools/sdkcommon" |
| ) |
| |
| // testSDKProperties is used to inject a current device config to use when returning info |
| // and an expected config to test setting. |
| type testSDKProperties struct { |
| expectedConfig sdkcommon.DeviceConfig |
| currentConfigs []sdkcommon.DeviceConfig |
| defaultDeviceName string |
| } |
| |
| func (sdk testSDKProperties) GetDeviceConfiguration(name string) (sdkcommon.DeviceConfig, error) { |
| for _, config := range sdk.currentConfigs { |
| if config.DeviceName == name { |
| return config, nil |
| } |
| } |
| return sdkcommon.DeviceConfig{}, nil |
| } |
| |
| func (sdk testSDKProperties) GetDefaultDeviceName() (string, error) { |
| if sdk.defaultDeviceName != "error" { |
| return sdk.defaultDeviceName, nil |
| } |
| return "", errors.New("Test error returned by mock") |
| } |
| func (sdk testSDKProperties) GetFuchsiaProperty(deviceName string, property string) (string, error) { |
| |
| device := deviceName |
| if device == "" { |
| device = sdk.defaultDeviceName |
| } |
| config, err := sdk.GetDeviceConfiguration(device) |
| if err != nil { |
| return "", err |
| } |
| |
| switch property { |
| case sdkcommon.BucketKey: |
| return config.Bucket, nil |
| case sdkcommon.DeviceIPKey: |
| return config.DeviceIP, nil |
| case sdkcommon.DeviceNameKey: |
| return config.DeviceName, nil |
| case sdkcommon.ImageKey: |
| return config.Image, nil |
| case sdkcommon.PackagePortKey: |
| return config.PackagePort, nil |
| case sdkcommon.PackageRepoKey: |
| return config.PackageRepo, nil |
| case sdkcommon.SSHPortKey: |
| return config.SSHPort, nil |
| } |
| return "", nil |
| } |
| |
| func (sdk testSDKProperties) IsValidProperty(property string) bool { |
| prodSDK := sdkcommon.SDKProperties{} |
| return prodSDK.IsValidProperty(property) |
| } |
| |
| func (sdk testSDKProperties) GetDeviceConfigurations() ([]sdkcommon.DeviceConfig, error) { |
| return sdk.currentConfigs, nil |
| } |
| |
| func (sdk testSDKProperties) SaveDeviceConfiguration(newConfig sdkcommon.DeviceConfig) error { |
| |
| index := -1 |
| for i, config := range sdk.currentConfigs { |
| if config.DeviceName == newConfig.DeviceName { |
| index = i |
| break |
| } |
| } |
| if index >= 0 { |
| sdk.currentConfigs[index] = newConfig |
| } else { |
| sdk.currentConfigs = append(sdk.currentConfigs, newConfig) |
| } |
| |
| if newConfig.DeviceIP != sdk.expectedConfig.DeviceIP { |
| return fmt.Errorf("Unexpected DeviceIP %v expected %v", newConfig.DeviceIP, sdk.expectedConfig.DeviceIP) |
| } |
| if newConfig.Bucket != sdk.expectedConfig.Bucket { |
| return fmt.Errorf("Unexpected Bucket %v expected %v", newConfig.Bucket, sdk.expectedConfig.Bucket) |
| } |
| if newConfig.DeviceName != sdk.expectedConfig.DeviceName { |
| return fmt.Errorf("Unexpected DeviceName %v expected %v", newConfig.DeviceName, sdk.expectedConfig.DeviceName) |
| } |
| if newConfig.Image != sdk.expectedConfig.Image { |
| return fmt.Errorf("Unexpected Image %v expected %v", newConfig.Image, sdk.expectedConfig.Image) |
| } |
| if newConfig.IsDefault != sdk.expectedConfig.IsDefault { |
| return fmt.Errorf("Unexpected IsDefault %v expected %v", newConfig.IsDefault, sdk.expectedConfig.IsDefault) |
| } |
| if newConfig.PackagePort != sdk.expectedConfig.PackagePort { |
| return fmt.Errorf("Unexpected PackagePort %v expected %v", newConfig.PackagePort, sdk.expectedConfig.PackagePort) |
| } |
| if newConfig.PackageRepo != sdk.expectedConfig.PackageRepo { |
| return fmt.Errorf("Unexpected PackageRepo %v expected %v", newConfig.PackageRepo, sdk.expectedConfig.PackageRepo) |
| } |
| if newConfig.SSHPort != sdk.expectedConfig.SSHPort { |
| return fmt.Errorf("Unexpected SSHPort %v expected %v", newConfig.SSHPort, sdk.expectedConfig.SSHPort) |
| } |
| return nil |
| } |
| |
| func TestSetDevice(t *testing.T) { |
| testSDK := testSDKProperties{} |
| |
| // Test empty |
| propertyMap := make(map[string]string) |
| err := doSetDevice(testSDK, "new-device-name", propertyMap) |
| if err == nil { |
| t.Fatal("Expected error for empty properties, but got none") |
| } |
| |
| // Test just changing the default flag. |
| propertyMap = make(map[string]string) |
| propertyMap[sdkcommon.DefaultKey] = "True" |
| testSDK.defaultDeviceName = "other-default-device" |
| testSDK.currentConfigs = []sdkcommon.DeviceConfig{ |
| { |
| DeviceName: "new-device-name", |
| IsDefault: false, |
| }, |
| } |
| testSDK.expectedConfig.IsDefault = true |
| testSDK.expectedConfig.DeviceName = "new-device-name" |
| |
| err = doSetDevice(testSDK, "new-device-name", propertyMap) |
| if err != nil { |
| t.Fatalf("Unexpected error: %v", err) |
| } |
| |
| testSDK.currentConfigs[0].DeviceIP = "10.10.10.10" |
| testSDK.currentConfigs[0].SSHPort = "2000" |
| |
| testSDK.expectedConfig.DeviceIP = "10.0.0.1" |
| testSDK.expectedConfig.SSHPort = testSDK.currentConfigs[0].SSHPort |
| |
| propertyMap[sdkcommon.DeviceIPKey] = testSDK.expectedConfig.DeviceIP |
| err = doSetDevice(testSDK, "new-device-name", propertyMap) |
| if err != nil { |
| t.Fatalf("Unexpected error: %v", err) |
| } |
| |
| } |
| |
| func TestGet(t *testing.T) { |
| testSDK := testSDKProperties{} |
| |
| if _, err := doGet(testSDK, sdkcommon.DeviceNameKey); err != nil { |
| t.Fatal(err) |
| } |
| |
| if _, err := doGet(testSDK, "unknown-prop"); err != nil { |
| expected := "Invalid property name: unknown-prop" |
| actual := fmt.Sprintf("%v", err) |
| if expected != actual { |
| t.Fatalf("Expected error [%v], got [%v]", expected, actual) |
| } |
| } |
| |
| // testing that the device name matters |
| testSDK.defaultDeviceName = "new-device-name" |
| testSDK.currentConfigs = []sdkcommon.DeviceConfig{ |
| { |
| Bucket: "test-bucket", |
| DeviceIP: "10.10.10.10", |
| DeviceName: "new-device-name", |
| IsDefault: false, |
| SSHPort: "8022", |
| }, |
| } |
| value, err := doGet(testSDK, sdkcommon.BucketKey) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if value != "test-bucket" { |
| t.Fatalf("Expected [%v] , got [%v]", value, "test-bucket") |
| } |
| |
| value, err = doGet(testSDK, "unknown-device."+sdkcommon.BucketKey) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if value != "" { |
| t.Fatalf("Expected [%v] , got [%v]", value, "") |
| } |
| |
| value, err = doGet(testSDK, "new-device-name."+sdkcommon.BucketKey) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if value != "test-bucket" { |
| t.Fatalf("Expected [%v] , got [%v]", value, "test-bucket") |
| } |
| } |
| |
| func TestList(t *testing.T) { |
| testSDK := testSDKProperties{} |
| |
| if err := doList(testSDK); err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| func TestGetAll(t *testing.T) { |
| output := []string{} |
| stdoutPrintln = func(value ...interface{}) (int, error) { |
| line := fmt.Sprintln(value...) |
| output = append(output, line) |
| return len(line), nil |
| } |
| defer func() { |
| stdoutPrintln = fmt.Println |
| }() |
| tests := []struct { |
| sdk SDKProvider |
| deviceName string |
| expected []string |
| }{ |
| { |
| sdk: testSDKProperties{}, |
| deviceName: "", |
| expected: []string{ |
| `{ |
| "device-name": "", |
| "bucket": "", |
| "image": "", |
| "device-ip": "", |
| "ssh-port": "", |
| "package-repo": "", |
| "package-port": "", |
| "default": false |
| } |
| `, |
| }, |
| }, |
| { |
| sdk: testSDKProperties{currentConfigs: []sdkcommon.DeviceConfig{ |
| { |
| DeviceName: "device1", |
| }, |
| }}, |
| deviceName: "", |
| expected: []string{ |
| `{ |
| "device-name": "", |
| "bucket": "", |
| "image": "", |
| "device-ip": "", |
| "ssh-port": "", |
| "package-repo": "", |
| "package-port": "", |
| "default": false |
| } |
| `, |
| }, |
| }, |
| { |
| sdk: testSDKProperties{currentConfigs: []sdkcommon.DeviceConfig{ |
| { |
| DeviceName: "device1", |
| }, |
| }, |
| defaultDeviceName: "device1", |
| }, |
| deviceName: "device1", |
| expected: []string{ |
| `{ |
| "device-name": "device1", |
| "bucket": "", |
| "image": "", |
| "device-ip": "", |
| "ssh-port": "", |
| "package-repo": "", |
| "package-port": "", |
| "default": false |
| } |
| `, |
| }, |
| }, |
| } |
| for _, test := range tests { |
| output = []string{} |
| handleGetAll(test.sdk, test.deviceName) |
| if len(output) != len(test.expected) { |
| t.Fatalf("Output length mismatch %v does not match expected %v", output, test.expected) |
| } |
| for i, line := range output { |
| if line != test.expected[i] { |
| t.Fatalf("Output %q does not match expected %q", output, test.expected) |
| } |
| } |
| } |
| } |
