mirror of
https://github.com/priyanshujain/sanderling.git
synced 2026-10-02 11:07:10 +00:00
pj
6b1c17328c
* fix(cli): fall back to node_modules for @uatu/spec resolution
Drop the hard failure when the uatu source tree is not reachable from
the spec file. Users integrating uatu in their own app have @uatu/spec
installed via npm; esbuild now resolves it from node_modules.
* build(gradle): drop :sample-app include from root settings
The sample now has its own Gradle project in examples/sample-app/android.
* build(sample-app): vendor gradle wrapper
Users running the sample build the APK via ./gradlew from inside the
sample-app's own android/ directory, no repo-root wrapper required.
* build(sample-app): make gradle project standalone
Drop the project(':sdk-android') dependency in favor of the Maven
Central coordinate io.github.priyanshujain:sdk-android. The sample now
owns its settings.gradle.kts and gradle.properties, so it builds
without any pieces of the uatu source tree.
* chore(sample-app): declare @uatu/spec npm dependency
Mirrors what a downstream user would put in their own package.json.
Uses file: for pre-release development; becomes a normal semver pin
once @uatu/spec ships to npm.
* docs(sample-app): rewrite justfile and add README
Justfile drops repo_root; all recipes run against the local gradle
wrapper and uatu from PATH. README is scoped to what a user needs to
run the sample against their own device.
* docs(manual): update sample install steps to standalone layout
./gradlew :sample-app:installDebug no longer exists; the sample owns
its own wrapper under android/.
* feat(sdk): log when Uatu.start succeeds
Silent SDK start makes the "SDK didn't connect" failure mode
impossible to debug. One INFO line at start time is enough.
* fix(sidecar): launch via am start -W instead of monkey
monkey -p <pkg> -c LAUNCHER 1 is unreliable on API 36+: it reports no
error but silently fails to start the activity, so the SDK never runs
and the CLI times out on the SDK-accept handshake.
Resolve the launcher activity via `cmd package resolve-activity
--brief` and launch it with `am start -W -n`. -W makes the call block
until the activity is up, which also makes the subsequent SDK
accept timing deterministic.
* feat(cli): auto-resolve Android device; boot AVD if none connected
--avd becomes optional. Resolution order:
- use any already-connected adb device;
- else if --avd names an existing AVD, boot it and wait for boot;
- else if --avd is missing or names no AVD, error with a clear message.
Falls back to $ANDROID_HOME/emulator/emulator when the binary is not on
PATH, so a standard Android SDK install works without extra shell setup.
* docs(sample-app): AVD is optional; document both paths
just test runs against any connected device. If none, pass AVD=<name>
to have uatu boot the emulator for you.
* feat(cli): auto-discover Android SDK; auto-pick the lone AVD
adb and emulator are looked up via PATH, then $ANDROID_HOME,
$ANDROID_SDK_ROOT, ~/Library/Android/sdk, ~/Android/Sdk, and the
Homebrew cask path. The discovered platform-tools directory is
prepended to the sidecar's PATH so its adb subprocess calls work too.
When --avd isn't passed and no device is connected, the CLI picks the
sole local AVD and boots it. Multiple AVDs → error listing them.
* build(make): add `make install` that go-installs uatu onto PATH
Puts `uatu` into $GOBIN (or $GOPATH/bin) so the sample and any local
dev flow can call it without PATH= prefixes.
* docs(sample-app): zero-config just test; dotenv-load for persistence
Drop the expectation that users prefix commands with PATH=, ANDROID_HOME=,
or AVD=. `just test` now works as-is; optional knobs can be pinned in a
.env file alongside the justfile.
* fix(sample-app): auto-detect ANDROID_HOME for Gradle tasks
The Go CLI finds the SDK itself, but AGP still needs ANDROID_HOME to
resolve `sdk.dir`. The justfile now resolves it from env or canonical
install paths before invoking ./gradlew, so `just install` works out
of the box on a standard Android SDK setup.
* gitignore runs directory for sample app
94 lines
2.0 KiB
Go
94 lines
2.0 KiB
Go
package main
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
func TestParseAdbDevices_OnlineOnly(t *testing.T) {
|
|
output := `List of devices attached
|
|
emulator-5554 device
|
|
emulator-5556 offline
|
|
physical-abc device
|
|
`
|
|
|
|
got := parseAdbDevices(output)
|
|
want := []string{"emulator-5554", "physical-abc"}
|
|
if !reflect.DeepEqual(got, want) {
|
|
t.Fatalf("got %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestParseAdbDevices_Empty(t *testing.T) {
|
|
output := "List of devices attached\n\n"
|
|
|
|
got := parseAdbDevices(output)
|
|
if len(got) != 0 {
|
|
t.Fatalf("got %v, want empty", got)
|
|
}
|
|
}
|
|
|
|
func TestParseAVDList_DropsInfoLines(t *testing.T) {
|
|
output := `INFO | Storing crashdata in: /tmp/x
|
|
Medium_Phone_API_36.0
|
|
uatu_test
|
|
`
|
|
|
|
got := parseAVDList(output)
|
|
want := []string{"Medium_Phone_API_36.0", "uatu_test"}
|
|
if !reflect.DeepEqual(got, want) {
|
|
t.Fatalf("got %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPickAVD_ExplicitName(t *testing.T) {
|
|
got, err := pickAVD("Pixel_7", []string{"Pixel_7", "uatu_test"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got != "Pixel_7" {
|
|
t.Fatalf("got %q, want Pixel_7", got)
|
|
}
|
|
}
|
|
|
|
func TestPickAVD_ExplicitMissing(t *testing.T) {
|
|
_, err := pickAVD("Nope", []string{"Pixel_7"})
|
|
if err == nil {
|
|
t.Fatal("expected error")
|
|
}
|
|
}
|
|
|
|
func TestPickAVD_SingleAvailable(t *testing.T) {
|
|
got, err := pickAVD("", []string{"uatu_test"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got != "uatu_test" {
|
|
t.Fatalf("got %q, want uatu_test", got)
|
|
}
|
|
}
|
|
|
|
func TestPickAVD_AmbiguousWithoutHint(t *testing.T) {
|
|
_, err := pickAVD("", []string{"a", "b"})
|
|
if err == nil {
|
|
t.Fatal("expected error when multiple AVDs and no --avd")
|
|
}
|
|
}
|
|
|
|
func TestPickAVD_NoneAvailable(t *testing.T) {
|
|
_, err := pickAVD("", nil)
|
|
if err == nil {
|
|
t.Fatal("expected error when no AVDs exist")
|
|
}
|
|
}
|
|
|
|
func TestPathContains(t *testing.T) {
|
|
path := "/usr/bin:/opt/tools:/usr/local/bin"
|
|
if !pathContains(path, "/opt/tools") {
|
|
t.Error("expected /opt/tools in PATH")
|
|
}
|
|
if pathContains(path, "/nope") {
|
|
t.Error("did not expect /nope in PATH")
|
|
}
|
|
}
|