Build packages / CI (push) Blocked by required conditions
Build packages / Version (push) Waiting to run
CI / Web (format, types, tests, bundles) (push) Blocked by required conditions
CI / ShellCheck (push) Blocked by required conditions
CI / Backend (Go: vet, tests, a real ubusd and uhttpd) (push) Blocked by required conditions
CI / Package files (push) Blocked by required conditions
- **Backend rewritten in Go.** One daemon, `dawnlined`, replaces the whole ucode backend: the rpcd plugin, the agent, the CLI and the updater. The package no longer depends on ucode. - **Per-architecture builds.** The release carries the backend for arm64, ARMv7, mips, mipsle and amd64; the router fetches its own after the package is installed and checks its sha256. Dawnline does not run on other architectures (older ARM, 32-bit x86, RISC-V). - **Faster on the router.** A firewall sync takes 0.06 s instead of 0.9 s; a full apply takes about 300 ms. The portal is served by the daemon itself, without a CGI process per request. - **Live pages.** The admin and the portal follow a live stream from the router instead of re-fetching the whole state every 30 seconds. - **Admin redesigned in the portal's style.** Three sections (Overview · Log · Settings); a server is a page of its own with People, Places and Settings; a device opens as a dialog over its person. - **Changes wait for «Apply».** Every setting, and a person's access, is staged in one dock before it reaches the router. - **Configuration rollout.** After a change that makes devices fetch their configuration again, the admin shows how many have fetched it and who has not. Every setting shows beforehand (⟳N) how many devices it will touch. - **Waiting for a decision.** Overview and People put first the people who need one (access ended, limit reached, a device that does not connect), each with its one action a tap away. - **Bulk actions on people.** «Select» (or a long press on a card) picks several people to extend by a month, pause or resume at once. - **Undo.** An action done from a card or a request is undone from its toast. - **Update dialogs redesigned.** An update is one view from its question to its result; Dawnline's own update runs in it like every other, and the page reloads itself once the new version answers. Other versions are a list, each with its notes and Install on a page of its own. - **Site to site: networks behind a router.** A router connected as a device can have networks behind it (up to eight, /16 to /30): the server routes them and applies the router's access to them. A network that shares addresses with a tunnel, the router's own networks or another site is refused by name. - **Routers from the portal.** People can add a router and name its networks on their own page; the admin accepts or declines with a reason, or lets them through without asking. - **Check access and Health know the networks behind routers.** - **Usage limits reworked.** A monthly limit no longer follows the calendar. A person's month starts with their first traffic and ends a month later; the next one starts only when they connect again, so time away uses up none of it. Before, everyone's limit reset on the 1st. - Extra data lasts until that person's month ends; «Reset usage» starts the month anew. - A limit is for a month or for the whole term; the admin and the portal show when it resets. - Charts that said «this month» show the last 30 days. - After the update nobody loses what was counted: the month that was running becomes the person's first and ends on the 1st. - **Access by time of day removed.** The Hours limit is gone from the admin, the portal and the backend; saved hours are dropped. - **Expiry simplified.** An end date always stops access, with a heads-up three days before; the per-person choice is gone. - **No false disconnects from sleeping phones.** A phone or a tablet stays online through ten minutes of silence. - **Mobile Safari fixes.** Pressing a control no longer sends the page to its top; tab tracks that do not fit scroll; switches animate after a press.
371 lines
16 KiB
Go
371 lines
16 KiB
Go
package updater
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"os"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/tickcount/luci-app-dawnline/backend/github"
|
|
"github.com/tickcount/luci-app-dawnline/backend/model"
|
|
"github.com/tickcount/luci-app-dawnline/backend/pkgmgr"
|
|
"github.com/tickcount/luci-app-dawnline/backend/servicelog"
|
|
)
|
|
|
|
// The cases tests/ucode holds the ucode modules to (updates, awg_builds, pkg).
|
|
func TestPureParts(t *testing.T) {
|
|
for _, c := range []struct {
|
|
a, b string
|
|
want int
|
|
}{{"0.5.1", "0.5.1", 0}, {"v0.5.1", "0.5.1", 0}, {"0.5.1", "0.5.2", -1}, {"0.10.0", "0.9.9", 1}, {"0.6", "0.6.0", 0}, {"0.6.0-rc1", "0.6.0", -1},
|
|
{"0.6.0-rc2", "0.6.0-rc10", -1}, {"0.6.0-beta", "0.6.0-rc1", -1}, {"garbage", "0.1", -1}} {
|
|
if got := VersionCmp(c.a, c.b); got != c.want {
|
|
t.Errorf("%s against %s: %d, not %d", c.a, c.b, got, c.want)
|
|
}
|
|
}
|
|
for v, want := range map[string]string{"": "", "3.1.20260812-r1": "3.1", "3.1.0-r1": "3.1", "1.0.20250722-r1": "2.0", "1.0.20250901": "2.0", "1.0.20250610-r1": "1.0",
|
|
"1.0.20241112-r2": "1.0", "6.12.94.3.1.20260906-r1": "3.1", "6.12.94.3.1.20260906": "3.1", "6.6.73.1.0.20250722-r1": "2.0", "6.6.73.1.0.20250612-r1": "1.0",
|
|
"5.15.150.1.0.20240711-r3": "1.0", "3.1.20260812": "3.1"} {
|
|
if got := Gen(v); got != want {
|
|
t.Errorf("the generation of %q: %q, not %q", v, got, want)
|
|
}
|
|
}
|
|
waiting := func() *Record { return &Record{Reloaded: false, Boot: "boot-1", PrevGen: "2.0", PrevCore: 98304.0} }
|
|
swapped, unknown, noBoot := waiting(), waiting(), waiting()
|
|
swapped.Reloaded, unknown.Reloaded, noBoot.Boot = true, nil, nil
|
|
for _, c := range []struct {
|
|
what string
|
|
rec *Record
|
|
boot string
|
|
core int64
|
|
want bool
|
|
}{{"the old module still loaded, same boot", waiting(), "boot-1", 98304, true}, {"rebooted", waiting(), "boot-2", 98304, false},
|
|
{"no module loaded", waiting(), "boot-1", 0, false}, {"another module loaded", waiting(), "boot-1", 110592, false},
|
|
{"the install swapped it", swapped, "boot-1", 98304, false}, {"a module Dawnline did not install", unknown, "boot-1", 98304, false},
|
|
{"a record from before boots were kept", &Record{OSRelease: "6.12.94", Source: "slava"}, "boot-1", 98304, false},
|
|
{"the kernel gave no boot id", noBoot, "", 98304, false}, {"no record", nil, "boot-1", 98304, false}} {
|
|
if got := Pending(c.rec, c.boot, c.core); got != c.want {
|
|
t.Errorf("pending, %s: %v", c.what, got)
|
|
}
|
|
}
|
|
if n, v := pkgmgr.ControlInfo("Package: amneziawg-tools\nVersion: 1.0.20250722-r1\nDepends: libc\n", true); n != "amneziawg-tools" || v != "1.0.20250722-r1" {
|
|
t.Errorf("an ipk's control file: %q %q", n, v)
|
|
}
|
|
dump := "#%SCHEMA: 00504B47\ninfo:\n name: kmod-amneziawg\n version: 6.12.94.3.1.20260906-r1\n depends: # 2 items\n - kernel=6.12.94\npaths: # 2 items\n - name: lib/modules\n"
|
|
if n, v := pkgmgr.ControlInfo(dump, false); n != "kmod-amneziawg" || v != "6.12.94.3.1.20260906-r1" {
|
|
t.Errorf("an apk's dump: %q %q", n, v)
|
|
}
|
|
if n, v := pkgmgr.ControlInfo("", false); n != "" || v != "" {
|
|
t.Error("something read from nothing")
|
|
}
|
|
want := []pkgmgr.Wanted{{Name: "a", Version: "2"}, {Name: "b", Version: "1"}}
|
|
if len(pkgmgr.Mismatched(want, map[string]string{"a": "2", "b": "1"})) != 0 || len(pkgmgr.Mismatched(want, map[string]string{"a": "1", "b": "1"})) != 1 ||
|
|
len(pkgmgr.Mismatched([]pkgmgr.Wanted{{File: "x.apk"}}, nil)) != 1 {
|
|
t.Error("which packages did not take")
|
|
}
|
|
up := pkgmgr.ParseUpgradable("libopenssl3-3.5.1-r1 < 3.5.2-r1\nip-full-6.11.0-r1 < 6.12.0-r1\nnoise\n", true)
|
|
if up["libopenssl3"] != "3.5.2-r1" || up["ip-full"] != "6.12.0-r1" || len(up) != 2 {
|
|
t.Errorf("apk's list: %v", up)
|
|
}
|
|
if up := pkgmgr.ParseUpgradable("acme - 4.0.0-r1 - 4.0.1-r1\n", false); up["acme"] != "4.0.1-r1" {
|
|
t.Errorf("opkg's list: %v", up)
|
|
}
|
|
fam := WithFamily([]string{"openssl-util", "ip-full", "kmod-veth"}, map[string]string{"libopenssl3": "1", "libustream-openssl20201210": "1", "ip-tiny": "1", "acme": "1"})
|
|
if strings.Join(fam, " ") != "ip-tiny libopenssl3 libustream-openssl20201210" {
|
|
t.Errorf("the families: %v", fam)
|
|
}
|
|
for in, want := range map[string][2]string{"app": {"app", ""}, "app@v1.2": {"app", "@v1.2"}, "app:reinstall": {"app", "reinstall"}, "amneziawg:slava:ru": {"amneziawg", "slava:ru"},
|
|
"pkgs:a,b": {"pkgs", "a,b"}, "app:lang:ru": {"app", "lang:ru"}} {
|
|
if n, a := splitTarget(in); n != want[0] || a != want[1] {
|
|
t.Errorf("the target %q: %q %q", in, n, a)
|
|
}
|
|
}
|
|
if fw, ok := FirmwareOf("24.10.6", "mediatek/filogic", "aarch64_cortex-a53", "", "ipk"); !ok || fw.Asset("kmod-amneziawg") != "kmod-amneziawg_v24.10.6_aarch64_cortex-a53_mediatek_filogic.ipk" ||
|
|
fw.ForTag("v24.10.8").Postfix != "_v24.10.8_aarch64_cortex-a53_mediatek_filogic" {
|
|
t.Errorf("the firmware: %+v", fw)
|
|
}
|
|
if fw, ok := FirmwareOf("25.12.3", "x86/64", "", "DISTRIB_ARCH='x86_64'\n", "apk"); !ok || fw.Postfix != "_v25.12.3_x86_64_x86_64" {
|
|
t.Errorf("the arch from the release file: %+v", fw)
|
|
}
|
|
if fw, _ := FirmwareOf("SNAPSHOT", "x86/64", "x86_64", "", "apk"); !fw.Snapshot {
|
|
t.Error("a snapshot is not told")
|
|
}
|
|
for arch, want := range map[string]string{"aarch64_cortex-a53": "arm64", "aarch64_generic": "arm64", "x86_64": "amd64", "mips_24kc": "mips", "mipsel_24kc": "mipsle",
|
|
"mipsel_74kc": "mipsle", "arm_cortex-a7_neon-vfpv4": "arm", "arm_cortex-a9": "arm", "arm_arm926ej-s": "", "arm_xscale": "", "i386_pentium4": "", "riscv64_riscv64": "", "": ""} {
|
|
if got := GoArch(arch); got != want {
|
|
t.Errorf("the binary for %q: %q, not %q", arch, got, want)
|
|
}
|
|
}
|
|
if _, ok := FirmwareOf("", "x86/64", "x86_64", "", "apk"); ok {
|
|
t.Error("a firmware made of nothing")
|
|
}
|
|
}
|
|
|
|
// router is a made-up router: a package manager that keeps versions, GitHub with one newer release.
|
|
type router struct {
|
|
t *testing.T
|
|
dir string
|
|
installed map[string]string
|
|
ran []string
|
|
sums map[string]string
|
|
releases map[string]map[string]string // tag -> asset -> body
|
|
env *Env
|
|
said []string
|
|
}
|
|
|
|
func newRouter(t *testing.T) *router {
|
|
r := &router{t: t, dir: t.TempDir(), installed: map[string]string{"luci-app-dawnline": "0.18.0", "ip-full": "6.11.0-r1"}, releases: map[string]map[string]string{}}
|
|
r.release("v0.18.0", "0.18.0")
|
|
r.release("v0.19.0", "0.19.0")
|
|
clock := time.Unix(1_800_000_000, 0)
|
|
gh := &github.Client{RunDir: r.dir + "/run", Now: func() time.Time { return clock }, Get: func(url string) (int, []byte) {
|
|
rel := func(tag string) map[string]any {
|
|
var assets []any
|
|
for name, body := range r.releases[tag] {
|
|
sum := sha256.Sum256([]byte(body))
|
|
a := map[string]any{"name": name, "id": 1.0}
|
|
if !strings.Contains(name, "nosum") {
|
|
a["digest"] = "sha256:" + hex.EncodeToString(sum[:])
|
|
}
|
|
assets = append(assets, a)
|
|
}
|
|
return map[string]any{"tag_name": tag, "html_url": "https://github.com/" + Repo + "/releases/tag/" + tag, "published_at": "2026-11-01T00:00:00Z", "assets": assets}
|
|
}
|
|
var out any
|
|
switch {
|
|
case strings.HasSuffix(url, "/releases/latest"):
|
|
out = rel("v0.19.0")
|
|
case strings.Contains(url, "/releases/tags/"):
|
|
tag := url[strings.LastIndex(url, "/")+1:]
|
|
if r.releases[tag] == nil {
|
|
return 404, []byte(`{"message":"Not Found"}`)
|
|
}
|
|
out = rel(tag)
|
|
default:
|
|
return 404, []byte(`{"message":"Not Found"}`)
|
|
}
|
|
raw, _ := json.Marshal(out)
|
|
return 200, raw
|
|
}}
|
|
pkg := &pkgmgr.Manager{Apk: true, Run: func(cmd string) (string, int) {
|
|
switch {
|
|
case strings.HasPrefix(cmd, "apk list --installed "):
|
|
name := strings.Trim(strings.TrimPrefix(cmd, "apk list --installed "), "'")
|
|
if v := r.installed[name]; v != "" {
|
|
return name + "-" + v + " x86_64 {feed} [installed]\n", 0
|
|
}
|
|
return "", 0
|
|
case strings.HasPrefix(cmd, "apk adbdump "):
|
|
raw, _ := os.ReadFile(strings.Trim(strings.TrimPrefix(cmd, "apk adbdump "), "'"))
|
|
return string(raw), 0
|
|
case strings.HasPrefix(cmd, "df "):
|
|
return "Filesystem 1024-blocks Used Available Capacity Mounted on\noverlay 100000 1000 99000 1% /overlay\n", 0
|
|
case strings.HasPrefix(cmd, "apk add --allow-untrusted "):
|
|
r.ran = append(r.ran, "apk add files")
|
|
for _, f := range strings.Fields(strings.TrimPrefix(cmd, "apk add --allow-untrusted ")) {
|
|
raw, _ := os.ReadFile(strings.Trim(f, "'"))
|
|
if n, v := pkgmgr.ControlInfo(string(raw), false); n != "" {
|
|
r.installed[n] = v
|
|
}
|
|
}
|
|
return "OK: 10 MiB in 100 packages\n", 0
|
|
case cmd == `apk version -l "<"`:
|
|
return "ip-full-6.11.0-r1 < 6.12.0-r1\nip-tiny-6.11.0-r1 < 6.12.0-r1\n", 0
|
|
}
|
|
r.ran = append(r.ran, cmd)
|
|
return "", 0
|
|
}}
|
|
r.env = &Env{RunDir: r.dir + "/run", DataDir: r.dir + "/data", Version: "0.18.0", Pkg: pkg, GH: gh, Pid: 4242, Now: func() time.Time { return clock }, Sleep: func(time.Duration) {},
|
|
Policy: model.Updates{Check: true, Interval: "1d", Auto: true, Mode: "immediate", Time: "04:00", Targets: []string{"app", "packages"}, Mirrors: true},
|
|
Fetch: func(url, dest string) bool {
|
|
parts := strings.Split(url, "/releases/download/")
|
|
if len(parts) != 2 || strings.HasPrefix(url, "https://gh") {
|
|
return false
|
|
}
|
|
ta := strings.SplitN(parts[1], "/", 2)
|
|
body, has := r.releases[ta[0]][ta[1]]
|
|
if !has {
|
|
return false
|
|
}
|
|
return os.WriteFile(dest, []byte(body), 0o600) == nil
|
|
},
|
|
Run: func(cmd string) (string, int) { r.ran = append(r.ran, cmd); return "", 0 },
|
|
Log: &servicelog.Log{RunDir: r.dir + "/run", Level: func() string { return "info" }, Syslog: func(_, line string) { r.said = append(r.said, line) }}}
|
|
return r
|
|
}
|
|
|
|
func (r *router) release(tag, ver string) {
|
|
r.releases[tag] = map[string]string{"luci-app-dawnline-" + ver + ".apk": "info:\n name: luci-app-dawnline\n version: " + ver + "\n"}
|
|
}
|
|
|
|
func (r *router) job() Job {
|
|
var j Job
|
|
raw, _ := os.ReadFile(r.dir + "/run/update-job.json")
|
|
json.Unmarshal(raw, &j)
|
|
return j
|
|
}
|
|
|
|
func (r *router) run(args ...string) int {
|
|
var out, errs bytes.Buffer
|
|
return Main(r.env, args, &out, &errs)
|
|
}
|
|
|
|
func TestUsage(t *testing.T) {
|
|
r := newRouter(t)
|
|
var out, errs bytes.Buffer
|
|
if Main(r.env, nil, &out, &errs) != 2 || Main(r.env, []string{"dance"}, &out, &errs) != 2 || Main(r.env, []string{"install"}, &out, &errs) != 2 || !strings.HasPrefix(errs.String(), "Usage:") {
|
|
t.Error("a command it does not know")
|
|
}
|
|
if Main(r.env, []string{"help"}, &out, &errs) != 0 || !strings.HasPrefix(out.String(), "Usage:") {
|
|
t.Error("asked for help")
|
|
}
|
|
if _, err := os.Stat(r.dir + "/run"); err == nil {
|
|
t.Error("something was written for no command")
|
|
}
|
|
}
|
|
|
|
func TestCheckAndInstall(t *testing.T) {
|
|
r := newRouter(t)
|
|
r.run("check", "app")
|
|
var c struct {
|
|
Components map[string]map[string]any `json:"components"`
|
|
}
|
|
raw, _ := os.ReadFile(r.dir + "/run/update-check.json")
|
|
json.Unmarshal(raw, &c)
|
|
if a := c.Components["app"]; a["update"] != true || a["latest"] != "0.19.0" || a["status"] != "outdated" || a["installed"] != "0.18.0" {
|
|
t.Fatalf("the check: %s", raw)
|
|
}
|
|
if j := r.job(); j.State != "done" || j.Phase != "Finished" || j.Finished == nil {
|
|
t.Fatalf("the check's job: %+v", j)
|
|
}
|
|
r.run("check", "packages")
|
|
raw, _ = os.ReadFile(r.dir + "/run/update-check.json")
|
|
json.Unmarshal(raw, &c)
|
|
if p := c.Components["packages"]; p["updates"] != 2.0 || p["status"] != "outdated" || c.Components["app"]["latest"] != "0.19.0" {
|
|
t.Fatalf("the packages' check (the app's must stay): %s", raw)
|
|
}
|
|
// the install: verified, the old version kept, a backup first, the package in, postupdate last
|
|
r.env.Policy.Keep = true
|
|
r.ran = nil
|
|
r.run("install", "app")
|
|
j := r.job()
|
|
if j.State != "done" || j.From != "0.18.0" || j.To != "0.19.0" || r.installed["luci-app-dawnline"] != "0.19.0" {
|
|
t.Fatalf("the install: %+v\n%s", j, strings.Join(j.Log, "\n"))
|
|
}
|
|
did := strings.Join(r.ran, "; ")
|
|
if !strings.Contains(did, "dawnline backup --reason pre-update") || !strings.HasSuffix(did, "postupdate '0.19.0' </dev/null >/dev/null 2>&1 &") ||
|
|
strings.Index(did, "backup") > strings.Index(did, "apk add files") {
|
|
t.Errorf("what ran: %s", did)
|
|
}
|
|
if k := kept(r.dir+"/data", "app"); k == nil || k.Version != "0.18.0" || len(k.Files) != 1 {
|
|
t.Errorf("the version kept for a rollback: %+v", k)
|
|
}
|
|
if !strings.Contains(strings.Join(j.Log, "\n"), "sha256 matches the release") {
|
|
t.Errorf("nothing says the file was verified:\n%s", strings.Join(j.Log, "\n"))
|
|
}
|
|
raw, _ = os.ReadFile(r.dir + "/data/update-history.json")
|
|
if !strings.Contains(string(raw), `"kind":"install"`) || !strings.Contains(string(raw), `"to":"0.19.0"`) {
|
|
t.Errorf("the history: %s", raw)
|
|
}
|
|
raw, _ = os.ReadFile(r.dir + "/run/update-check.json")
|
|
json.Unmarshal(raw, &c)
|
|
if a := c.Components["app"]; a["update"] != false || a["installed"] != "0.19.0" {
|
|
t.Errorf("the check after the install still offers it: %s", raw)
|
|
}
|
|
if _, err := os.Stat("/tmp/dawnline-update.4242"); err == nil {
|
|
t.Error("the work directory stays")
|
|
}
|
|
// and back
|
|
r.env.Version = "0.19.0"
|
|
r.ran = nil
|
|
r.run("install", "app:rollback")
|
|
if j := r.job(); j.State != "done" || r.installed["luci-app-dawnline"] != "0.18.0" || kept(r.dir+"/data", "app") != nil {
|
|
t.Errorf("the rollback: %+v", j)
|
|
}
|
|
}
|
|
|
|
func TestInstallRefusals(t *testing.T) {
|
|
r := newRouter(t)
|
|
// a release that publishes no checksum is not installed
|
|
r.releases["v0.20.0"] = map[string]string{"luci-app-dawnline-0.20.0.apk.nosum": "x"}
|
|
r.releases["v0.20.0"]["luci-app-dawnline-0.20.0.apk"] = "info:\n name: luci-app-dawnline\n version: 0.20.0\n"
|
|
delete(r.releases["v0.20.0"], "luci-app-dawnline-0.20.0.apk.nosum")
|
|
r.run("install", "app@v9.9.9")
|
|
j := r.job()
|
|
if j.State != "failed" || !strings.Contains(j.Error.(string), "publishes no checksum") || r.installed["luci-app-dawnline"] != "0.18.0" {
|
|
t.Errorf("a release that is not there: %+v", j)
|
|
}
|
|
found := false
|
|
for _, l := range r.said {
|
|
found = found || strings.Contains(l, "Dawnline update failed")
|
|
}
|
|
raw, _ := os.ReadFile(r.dir + "/data/update-history.json")
|
|
if !found || !strings.Contains(string(raw), `"state":"failed"`) {
|
|
t.Errorf("a failed update is not told: %v / %s", r.said, raw)
|
|
}
|
|
r.run("install", "pkgs:busybox")
|
|
if j := r.job(); j.State != "failed" || j.Error != "busybox is not a package Dawnline manages" {
|
|
t.Errorf("a package that is not ours: %+v", j)
|
|
}
|
|
r.run("install", "nonsense")
|
|
if j := r.job(); j.State != "failed" || j.Error != "Unknown component nonsense" {
|
|
t.Errorf("a component there is none of: %+v", j)
|
|
}
|
|
// one job at a time: a second one leaves without a trace
|
|
held := lock(r.dir + "/run")
|
|
before, _ := os.ReadFile(r.dir + "/run/update-job.json")
|
|
if r.run("check", "app") != 0 {
|
|
t.Error("a busy updater is an error")
|
|
}
|
|
if after, _ := os.ReadFile(r.dir + "/run/update-job.json"); string(after) != string(before) {
|
|
t.Error("a second job wrote over the first")
|
|
}
|
|
held.Close()
|
|
}
|
|
|
|
func TestAuto(t *testing.T) {
|
|
r := newRouter(t)
|
|
// nothing due: no check, no job
|
|
os.MkdirAll(r.dir+"/data", 0o700)
|
|
os.WriteFile(r.dir+"/data/update-auto.json", []byte(`{"check":1799999000}`), 0o600)
|
|
r.run("auto")
|
|
if _, err := os.Stat(r.dir + "/run/update-check.json"); err == nil {
|
|
t.Fatal("checked before its time")
|
|
}
|
|
// due, and updates right away: packages first, Dawnline last
|
|
os.WriteFile(r.dir+"/data/update-auto.json", []byte(`{"check":1799000000}`), 0o600)
|
|
r.ran = nil
|
|
r.run("auto")
|
|
j := r.job()
|
|
if j.State != "done" || !j.Auto || j.Component != "pkgs:ip-full app" || r.installed["luci-app-dawnline"] != "0.19.0" {
|
|
t.Fatalf("the automatic run: %+v\n%s", j, strings.Join(j.Log, "\n"))
|
|
}
|
|
did := strings.Join(r.ran, "; ")
|
|
if !strings.Contains(did, "apk upgrade 'ip-full' 'ip-tiny'") || strings.Index(did, "apk upgrade") > strings.Index(did, "apk add files") {
|
|
t.Errorf("the order: %s", did)
|
|
}
|
|
// an automatic run always keeps the version it replaces
|
|
if k := kept(r.dir+"/data", "app"); k == nil || k.Version != "0.18.0" {
|
|
t.Errorf("nothing kept by an automatic run: %+v", k)
|
|
}
|
|
said := strings.Join(r.said, "\n")
|
|
if !strings.Contains(said, "updates available · Dawnline 0.19.0, 2 system packages") || !strings.Contains(said, "updated automatically · ip-full, ip-tiny") {
|
|
t.Errorf("the service log: %s", said)
|
|
}
|
|
// checks only: found, told once, nothing installed
|
|
r2 := newRouter(t)
|
|
r2.env.Policy.Auto = false
|
|
r2.run("auto")
|
|
r2.run("auto")
|
|
if r2.installed["luci-app-dawnline"] != "0.18.0" || strings.Count(strings.Join(r2.said, "\n"), "updates available") != 1 {
|
|
t.Errorf("a check-only policy: %v", r2.said)
|
|
}
|
|
if _, err := os.Stat(r2.dir + "/run/update-job.json"); err == nil {
|
|
t.Error("an automatic check shows up as a job")
|
|
}
|
|
}
|