mirror of
https://github.com/priyanshujain/sanderling.git
synced 2026-10-02 19:17:10 +00:00
343 lines
11 KiB
Go
343 lines
11 KiB
Go
package ios
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
const simctlJSON = `{
|
|
"devices": {
|
|
"com.apple.CoreSimulator.SimRuntime.iOS-17-0": [
|
|
{"udid": "ipad-udid", "state": "Shutdown", "name": "iPad Pro", "isAvailable": true},
|
|
{"udid": "iphone15-udid", "state": "Booted", "name": "iPhone 15", "isAvailable": true},
|
|
{"udid": "broken-udid", "state": "Shutdown", "name": "iPhone 14", "isAvailable": false}
|
|
],
|
|
"com.apple.CoreSimulator.SimRuntime.iOS-16-4": [
|
|
{"udid": "watch-udid", "state": "Shutdown", "name": "Apple Watch", "isAvailable": true}
|
|
]
|
|
}
|
|
}`
|
|
|
|
func TestParseBootedDevice(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
input string
|
|
wantUDID string
|
|
wantNil bool
|
|
}{
|
|
{"picks booted entry", simctlJSON, "iphone15-udid", false},
|
|
{"none booted", `{"devices":{"r":[{"udid":"a","state":"Shutdown","name":"x","isAvailable":true}]}}`, "", true},
|
|
{"empty list", `{"devices":{}}`, "", true},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
got, err := parseBootedDevice([]byte(tc.input))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if tc.wantNil {
|
|
if got != nil {
|
|
t.Fatalf("want nil, got %+v", got)
|
|
}
|
|
return
|
|
}
|
|
if got == nil || got.UDID != tc.wantUDID {
|
|
t.Fatalf("got %+v, want UDID %q", got, tc.wantUDID)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestParseBootedDevice_InvalidJSON(t *testing.T) {
|
|
if _, err := parseBootedDevice([]byte("not json")); err == nil {
|
|
t.Fatal("expected error on malformed JSON")
|
|
}
|
|
}
|
|
|
|
func TestParseAvailableDevices_DropsUnavailable(t *testing.T) {
|
|
got, err := parseAvailableDevices([]byte(simctlJSON))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, d := range got {
|
|
if !d.IsAvailable {
|
|
t.Fatalf("unavailable device leaked through: %+v", d)
|
|
}
|
|
if d.UDID == "broken-udid" {
|
|
t.Fatalf("isAvailable=false device must not be selectable")
|
|
}
|
|
}
|
|
if len(got) != 3 {
|
|
t.Fatalf("got %d available across runtimes, want 3", len(got))
|
|
}
|
|
}
|
|
|
|
func TestPickSimulator(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
query string
|
|
available []simDevice
|
|
wantUDID string // "" with wantErr means error expected
|
|
wantErr bool
|
|
}{
|
|
{
|
|
name: "by name",
|
|
query: "iPhone 15",
|
|
available: []simDevice{{UDID: "aaa", Name: "iPad Pro", IsAvailable: true}, {UDID: "bbb", Name: "iPhone 15", IsAvailable: true}},
|
|
wantUDID: "bbb",
|
|
},
|
|
{
|
|
name: "by udid",
|
|
query: "aaa",
|
|
available: []simDevice{{UDID: "aaa", Name: "iPad Pro", IsAvailable: true}, {UDID: "bbb", Name: "iPhone 14", IsAvailable: true}},
|
|
wantUDID: "aaa",
|
|
},
|
|
{
|
|
name: "unknown name errors",
|
|
query: "Pixel 7",
|
|
available: []simDevice{{UDID: "aaa", Name: "iPad Pro", IsAvailable: true}},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "empty query prefers iPhone",
|
|
query: "",
|
|
available: []simDevice{{UDID: "aaa", Name: "iPad mini", IsAvailable: true}, {UDID: "bbb", Name: "iPhone 16", IsAvailable: true}, {UDID: "ccc", Name: "Apple Watch", IsAvailable: true}},
|
|
wantUDID: "bbb",
|
|
},
|
|
{
|
|
name: "empty query falls back to first",
|
|
query: "",
|
|
available: []simDevice{{UDID: "aaa", Name: "iPad Air", IsAvailable: true}, {UDID: "bbb", Name: "Apple TV", IsAvailable: true}},
|
|
wantUDID: "aaa",
|
|
},
|
|
{
|
|
name: "empty list errors",
|
|
query: "",
|
|
wantErr: true,
|
|
},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
got, err := pickSimulator(tc.query, tc.available)
|
|
if tc.wantErr {
|
|
if err == nil {
|
|
t.Fatalf("expected error for query %q", tc.query)
|
|
}
|
|
return
|
|
}
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got.UDID != tc.wantUDID {
|
|
t.Errorf("got %q, want %q", got.UDID, tc.wantUDID)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestBootedUDID_CanceledContextReturnsEmpty(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
udid := BootedUDID(ctx)
|
|
if udid != "" {
|
|
t.Errorf("expected empty UDID on canceled context, got %q", udid)
|
|
}
|
|
}
|
|
|
|
func swapSeams(t *testing.T) {
|
|
t.Helper()
|
|
origBoot, origWait := boot, waitForBoot
|
|
t.Cleanup(func() { boot, waitForBoot = origBoot, origWait })
|
|
}
|
|
|
|
func TestEnsureSimulator_UsesBootedSimulator(t *testing.T) {
|
|
swapSeams(t)
|
|
origListBooted, origListAvailable := listBooted, listAvailable
|
|
t.Cleanup(func() { listBooted, listAvailable = origListBooted, origListAvailable })
|
|
|
|
listBooted = func(context.Context) (*simDevice, error) {
|
|
return &simDevice{UDID: "iphone15-udid", Name: "iPhone 15"}, nil
|
|
}
|
|
availableCalled := false
|
|
listAvailable = func(context.Context) ([]simDevice, error) {
|
|
availableCalled = true
|
|
return nil, nil
|
|
}
|
|
boot = func(context.Context, string) error {
|
|
t.Fatal("must not boot when a simulator is already booted")
|
|
return nil
|
|
}
|
|
|
|
var out bytes.Buffer
|
|
if err := EnsureSimulator(context.Background(), "", &out); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if availableCalled {
|
|
t.Error("should short-circuit without listing available simulators")
|
|
}
|
|
if !bytes.Contains(out.Bytes(), []byte("iphone15-udid")) {
|
|
t.Errorf("expected booted UDID in output, got %q", out.String())
|
|
}
|
|
}
|
|
|
|
func TestEnsureSimulator_BootsPickedSimulator(t *testing.T) {
|
|
swapSeams(t)
|
|
origListBooted, origListAvailable := listBooted, listAvailable
|
|
t.Cleanup(func() { listBooted, listAvailable = origListBooted, origListAvailable })
|
|
|
|
listBooted = func(context.Context) (*simDevice, error) { return nil, nil }
|
|
listAvailable = func(context.Context) ([]simDevice, error) {
|
|
return []simDevice{
|
|
{UDID: "ipad-udid", Name: "iPad Pro", IsAvailable: true},
|
|
{UDID: "iphone15-udid", Name: "iPhone 15", IsAvailable: true},
|
|
}, nil
|
|
}
|
|
var bootedUDID string
|
|
boot = func(_ context.Context, udid string) error { bootedUDID = udid; return nil }
|
|
waitForBoot = func(context.Context, string, time.Duration) error { return nil }
|
|
|
|
if err := EnsureSimulator(context.Background(), "", new(bytes.Buffer)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if bootedUDID != "iphone15-udid" {
|
|
t.Errorf("booted %q, want iphone15-udid (iPhone preference)", bootedUDID)
|
|
}
|
|
}
|
|
|
|
func swapResolveSeams(t *testing.T) {
|
|
t.Helper()
|
|
origBootedAll, origAvailable := listBootedAll, listAvailable
|
|
t.Cleanup(func() { listBootedAll, listAvailable = origBootedAll, origAvailable })
|
|
}
|
|
|
|
func TestResolveTarget_ExplicitMatchesBootedSimulator(t *testing.T) {
|
|
swapResolveSeams(t)
|
|
listBootedAll = func(context.Context) ([]simDevice, error) {
|
|
return []simDevice{{UDID: "booted-udid", Name: "iPhone 15", State: "Booted", IsAvailable: true}}, nil
|
|
}
|
|
listAvailable = func(context.Context) ([]simDevice, error) {
|
|
t.Fatal("should not list available when a booted simulator matches")
|
|
return nil, nil
|
|
}
|
|
udid, isSimulator, err := ResolveTarget(context.Background(), "iPhone 15")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if udid != "booted-udid" || !isSimulator {
|
|
t.Errorf("got (%q, %v), want (booted-udid, true)", udid, isSimulator)
|
|
}
|
|
}
|
|
|
|
func TestResolveTarget_ExplicitMatchesAvailableByUDID(t *testing.T) {
|
|
swapResolveSeams(t)
|
|
listBootedAll = func(context.Context) ([]simDevice, error) { return nil, nil }
|
|
listAvailable = func(context.Context) ([]simDevice, error) {
|
|
return []simDevice{{UDID: "shutdown-udid", Name: "iPhone 16", IsAvailable: true}}, nil
|
|
}
|
|
udid, isSimulator, err := ResolveTarget(context.Background(), "shutdown-udid")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if udid != "shutdown-udid" || !isSimulator {
|
|
t.Errorf("got (%q, %v), want (shutdown-udid, true)", udid, isSimulator)
|
|
}
|
|
}
|
|
|
|
func TestResolveTarget_UnknownQueryResolvesAsPhysicalDevice(t *testing.T) {
|
|
swapResolveSeams(t)
|
|
listBootedAll = func(context.Context) ([]simDevice, error) { return nil, nil }
|
|
listAvailable = func(context.Context) ([]simDevice, error) {
|
|
return []simDevice{{UDID: "sim-udid", Name: "iPhone 16", IsAvailable: true}}, nil
|
|
}
|
|
udid, isSimulator, err := ResolveTarget(context.Background(), "00008110-physical-device-udid")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if udid != "00008110-physical-device-udid" || isSimulator {
|
|
t.Errorf("got (%q, %v), want (00008110-physical-device-udid, false)", udid, isSimulator)
|
|
}
|
|
}
|
|
|
|
func TestResolveTarget_NoQuerySingleBooted(t *testing.T) {
|
|
swapResolveSeams(t)
|
|
listBootedAll = func(context.Context) ([]simDevice, error) {
|
|
return []simDevice{{UDID: "only-booted", Name: "iPhone 15", State: "Booted", IsAvailable: true}}, nil
|
|
}
|
|
udid, isSimulator, err := ResolveTarget(context.Background(), "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if udid != "only-booted" || !isSimulator {
|
|
t.Errorf("got (%q, %v), want (only-booted, true)", udid, isSimulator)
|
|
}
|
|
}
|
|
|
|
func TestResolveTarget_NoQueryZeroBootedErrors(t *testing.T) {
|
|
swapResolveSeams(t)
|
|
listBootedAll = func(context.Context) ([]simDevice, error) { return nil, nil }
|
|
_, _, err := ResolveTarget(context.Background(), "")
|
|
if err == nil {
|
|
t.Fatal("expected error when no simulator is booted")
|
|
}
|
|
}
|
|
|
|
func TestResolveTarget_NoQueryMultipleBootedErrors(t *testing.T) {
|
|
swapResolveSeams(t)
|
|
listBootedAll = func(context.Context) ([]simDevice, error) {
|
|
return []simDevice{
|
|
{UDID: "udid-a", Name: "iPhone 15", State: "Booted", IsAvailable: true},
|
|
{UDID: "udid-b", Name: "iPad Pro", State: "Booted", IsAvailable: true},
|
|
}, nil
|
|
}
|
|
_, _, err := ResolveTarget(context.Background(), "")
|
|
if err == nil {
|
|
t.Fatal("expected ambiguity error for multiple booted simulators")
|
|
}
|
|
message := err.Error()
|
|
for _, want := range []string{"--ios-device", "iPhone 15", "udid-a", "iPad Pro", "udid-b"} {
|
|
if !strings.Contains(message, want) {
|
|
t.Errorf("ambiguity error missing %q: %v", want, message)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestResolveTarget_BootedListError(t *testing.T) {
|
|
swapResolveSeams(t)
|
|
listBootedAll = func(context.Context) ([]simDevice, error) { return nil, errors.New("xcrun blew up") }
|
|
if _, _, err := ResolveTarget(context.Background(), ""); err == nil {
|
|
t.Fatal("expected booted-list error to propagate")
|
|
}
|
|
}
|
|
|
|
func TestParseBootedDevices_CollectsAllBooted(t *testing.T) {
|
|
got, err := parseBootedDevices([]byte(`{"devices":{"r":[
|
|
{"udid":"a","state":"Booted","name":"iPhone 15","isAvailable":true},
|
|
{"udid":"b","state":"Shutdown","name":"iPad","isAvailable":true},
|
|
{"udid":"c","state":"Booted","name":"iPhone 16","isAvailable":true}
|
|
]}}`))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(got) != 2 {
|
|
t.Fatalf("got %d booted, want 2", len(got))
|
|
}
|
|
}
|
|
|
|
func TestEnsureSimulator_BootedListError(t *testing.T) {
|
|
origListBooted := listBooted
|
|
t.Cleanup(func() { listBooted = origListBooted })
|
|
listBooted = func(context.Context) (*simDevice, error) { return nil, errors.New("xcrun blew up") }
|
|
|
|
err := EnsureSimulator(context.Background(), "", new(bytes.Buffer))
|
|
if err == nil {
|
|
t.Fatal("expected error to propagate")
|
|
}
|
|
if !strings.Contains(err.Error(), "xcrun blew up") {
|
|
t.Errorf("error should wrap cause, got %v", err)
|
|
}
|
|
}
|