c7ad5bd fix(repos): build AUR helper as user to avoid permission issues · archup

M .gitignore +1 -0


@@ -22,6 +22,7 @@ coverage.out
22	/*.md	22		/*.md
23	!README.md	23		!README.md
24	!CHANGELOG.md	24		!CHANGELOG.md
		25	+	!LICENSE.md
25	!RELEASING.md	26		!RELEASING.md
26		27
27		28

M Makefile +5 -0


@@ -3,6 +3,11 @@
3		3
4	# Get version from git tag or use dev	4		# Get version from git tag or use dev
5	VERSION := $(shell git describe --tags --always --dirty 2>/dev/null \|\| echo "dev")	5		VERSION := $(shell git describe --tags --always --dirty 2>/dev/null \|\| echo "dev")
		6	+	# Append branch name if not on main
		7	+	CURRENT_BRANCH := $(shell git rev-parse --abbrev-ref HEAD 2>/dev/null)
		8	+	ifeq ($(CURRENT_BRANCH),dev)
		9	+	VERSION := $(VERSION)-dev
		10	+	endif
6	LDFLAGS := -ldflags "-X main.version=$(VERSION)"	11		LDFLAGS := -ldflags "-X main.version=$(VERSION)"
7	LDFLAGS_STRIP := -ldflags "-X main.version=$(VERSION) -s -w"	12		LDFLAGS_STRIP := -ldflags "-X main.version=$(VERSION) -s -w"
8		13

M cmd/archup-installer/main.go +16 -8

 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/bnema/archup/internal/cleanup"
 	"github.com/bnema/archup/internal/config"
+	"github.com/bnema/archup/internal/interfaces"
 	"github.com/bnema/archup/internal/logger"
 	"github.com/bnema/archup/internal/phases"
 	"github.com/bnema/archup/internal/ui"
 	// Initialize orchestrator
 	orchestrator := phases.NewOrchestrator(cfg, config.DefaultLogPath)
+	// Create concrete implementations of interfaces for dependency injection
+	fs := &interfaces.DefaultFileSystem{}
+	httpClient := &interfaces.DefaultHTTPClient{}
+	sysExec := &interfaces.DefaultSystemExecutor{}
+	chrExec := &interfaces.DefaultChrootExecutor{}
+	cmdExec := &interfaces.DefaultCommandExecutor{}
 	// Register all phases with logger
 	phasesToRegister := []phases.Phase{
-		phases.NewBootstrapPhase(cfg, log),
+		phases.NewBootstrapPhase(cfg, log, httpClient, fs),
-		phases.NewPreflightPhase(cfg, log),
+		phases.NewPreflightPhase(cfg, log, fs, cmdExec),
-		phases.NewPartitioningPhase(cfg, log),
+		phases.NewPartitioningPhase(cfg, log, sysExec),
-		phases.NewBaseInstallPhase(cfg, log),
+		phases.NewBaseInstallPhase(cfg, log, fs, sysExec),
-		phases.NewConfigPhase(cfg, log),
+		phases.NewConfigPhase(cfg, log, fs, sysExec, chrExec),
-		phases.NewBootPhase(cfg, log),
+		phases.NewBootPhase(cfg, log, fs, sysExec, chrExec),
-		phases.NewReposPhase(cfg, log),
+		phases.NewReposPhase(cfg, log, fs, sysExec, chrExec),
-		phases.NewPostInstallPhase(cfg, log),
+		phases.NewPostInstallPhase(cfg, log, fs, httpClient, sysExec, chrExec),
 	}
 	for _, phase := range phasesToRegister {

M go.mod +1 -0


@@ -7,6 +7,7 @@ require (
7	github.com/charmbracelet/bubbletea v1.3.10	7		github.com/charmbracelet/bubbletea v1.3.10
8	github.com/charmbracelet/huh v0.8.0	8		github.com/charmbracelet/huh v0.8.0
9	github.com/charmbracelet/lipgloss v1.1.0	9		github.com/charmbracelet/lipgloss v1.1.0
		10	+	go.uber.org/mock v0.6.0
10	)	11		)
11		12
12	require (	13		require (

M go.sum +2 -0 generated file: collapsed

load diff

A internal/interfaces/interfaces.go +140 -0

@@ -0,0 +1,140 @@
	1	+	package interfaces
	2	+
	3	+	import (
	4	+	"io"
	5	+	"net/http"
	6	+	"os"
	7	+	"os/exec"
	8	+
	9	+	"github.com/bnema/archup/internal/system"
	10	+	)
	11	+
	12	+	// FileSystem abstracts file system operations for testing
	13	+	type FileSystem interface {
	14	+	Stat(name string) (os.FileInfo, error)
	15	+	IsNotExist(err error) bool
	16	+	Open(name string) (io.ReadCloser, error)
	17	+	ReadFile(filename string) ([]byte, error)
	18	+	WriteFile(filename string, data []byte, perm os.FileMode) error
	19	+	Create(name string) (io.WriteCloser, error)
	20	+	MkdirAll(path string, perm os.FileMode) error
	21	+	RemoveAll(path string) error
	22	+	Chmod(name string, mode os.FileMode) error
	23	+	}
	24	+
	25	+	// CommandExecutor abstracts command execution
	26	+	type CommandExecutor interface {
	27	+	Execute(name string, args ...string) ([]byte, error)
	28	+	}
	29	+
	30	+	// SystemExecutor abstracts system package functions
	31	+	type SystemExecutor interface {
	32	+	RunSimple(command string, args ...string) system.CommandResult
	33	+	DetectCPUInfo() (*system.CPUInfo, error)
	34	+	}
	35	+
	36	+	// ChrootExecutor abstracts chroot operations
	37	+	type ChrootExecutor interface {
	38	+	ChrootExec(logPath, mountPoint, command string, args ...string) error
	39	+	ChrootSystemctl(logPath, mountPoint, action, service string) error
	40	+	ChrootExecWithStdin(logPath, mountPoint, command, stdin string) error
	41	+	ChrootPacman(logPath, mountPoint, operation string, packages ...string) error
	42	+	DownloadAndInstallPackages(logPath, chrootPath string, urls ...string) error
	43	+	}
	44	+
	45	+	// HTTPClient abstracts HTTP operations
	46	+	type HTTPClient interface {
	47	+	Get(url string) (*http.Response, error)
	48	+	}
	49	+
	50	+	// ConfigSaver abstracts config save operation
	51	+	type ConfigSaver interface {
	52	+	Save() error
	53	+	}
	54	+
	55	+	// DefaultFileSystem is the concrete implementation using OS functions
	56	+	type DefaultFileSystem struct{}
	57	+
	58	+	func (d *DefaultFileSystem) Stat(name string) (os.FileInfo, error) {
	59	+	return os.Stat(name)
	60	+	}
	61	+
	62	+	func (d *DefaultFileSystem) IsNotExist(err error) bool {
	63	+	return os.IsNotExist(err)
	64	+	}
	65	+
	66	+	func (d *DefaultFileSystem) Open(name string) (io.ReadCloser, error) {
	67	+	return os.Open(name)
	68	+	}
	69	+
	70	+	func (d *DefaultFileSystem) ReadFile(filename string) ([]byte, error) {
	71	+	return os.ReadFile(filename)
	72	+	}
	73	+
	74	+	func (d *DefaultFileSystem) WriteFile(filename string, data []byte, perm os.FileMode) error {
	75	+	return os.WriteFile(filename, data, perm)
	76	+	}
	77	+
	78	+	func (d *DefaultFileSystem) Create(name string) (io.WriteCloser, error) {
	79	+	return os.Create(name)
	80	+	}
	81	+
	82	+	func (d *DefaultFileSystem) MkdirAll(path string, perm os.FileMode) error {
	83	+	return os.MkdirAll(path, perm)
	84	+	}
	85	+
	86	+	func (d *DefaultFileSystem) RemoveAll(path string) error {
	87	+	return os.RemoveAll(path)
	88	+	}
	89	+
	90	+	func (d *DefaultFileSystem) Chmod(name string, mode os.FileMode) error {
	91	+	return os.Chmod(name, mode)
	92	+	}
	93	+
	94	+	// DefaultCommandExecutor is the concrete implementation using os/exec
	95	+	type DefaultCommandExecutor struct{}
	96	+
	97	+	func (d *DefaultCommandExecutor) Execute(name string, args ...string) ([]byte, error) {
	98	+	return exec.Command(name, args...).Output()
	99	+	}
	100	+
	101	+	// DefaultHTTPClient is the concrete implementation using net/http
	102	+	type DefaultHTTPClient struct{}
	103	+
	104	+	func (d DefaultHTTPClient) Get(url string) (http.Response, error) {
	105	+	return http.Get(url)
	106	+	}
	107	+
	108	+	// DefaultSystemExecutor is the concrete implementation using system functions
	109	+	type DefaultSystemExecutor struct{}
	110	+
	111	+	func (d *DefaultSystemExecutor) RunSimple(command string, args ...string) system.CommandResult {
	112	+	return system.RunSimple(command, args...)
	113	+	}
	114	+
	115	+	func (d DefaultSystemExecutor) DetectCPUInfo() (system.CPUInfo, error) {
	116	+	return system.DetectCPUInfo()
	117	+	}
	118	+
	119	+	// DefaultChrootExecutor is the concrete implementation using chroot functions
	120	+	type DefaultChrootExecutor struct{}
	121	+
	122	+	func (d *DefaultChrootExecutor) ChrootExec(logPath, mountPoint, command string, args ...string) error {
	123	+	return system.ChrootExec(logPath, mountPoint, command, args...)
	124	+	}
	125	+
	126	+	func (d *DefaultChrootExecutor) ChrootSystemctl(logPath, mountPoint, action, service string) error {
	127	+	return system.ChrootSystemctl(logPath, mountPoint, action, service)
	128	+	}
	129	+
	130	+	func (d *DefaultChrootExecutor) ChrootExecWithStdin(logPath, mountPoint, command, stdin string) error {
	131	+	return system.ChrootExecWithStdin(logPath, mountPoint, command, stdin)
	132	+	}
	133	+
	134	+	func (d *DefaultChrootExecutor) ChrootPacman(logPath, mountPoint, operation string, packages ...string) error {
	135	+	return system.ChrootPacman(logPath, mountPoint, operation, packages...)
	136	+	}
	137	+
	138	+	func (d *DefaultChrootExecutor) DownloadAndInstallPackages(logPath, chrootPath string, urls ...string) error {
	139	+	return system.DownloadAndInstallPackages(logPath, chrootPath, urls...)
	140	+	}

A internal/interfaces/mocks/mock_interfaces.go +462 -0

@@ -0,0 +1,462 @@
	1	+	// Code generated by MockGen. DO NOT EDIT.
	2	+	// Source: /home/brice/dev/projects/archup/internal/interfaces/interfaces.go
	3	+	//
	4	+	// Generated by this command:
	5	+	//
	6	+	// mockgen -source=/home/brice/dev/projects/archup/internal/interfaces/interfaces.go -destination=/home/brice/dev/projects/archup/internal/interfaces/mocks/mock_interfaces.go -package=mocks
	7	+	//
	8	+
	9	+	// Package mocks is a generated GoMock package.
	10	+	package mocks
	11	+
	12	+	import (
	13	+	io "io"
	14	+	http "net/http"
	15	+	os "os"
	16	+	reflect "reflect"
	17	+
	18	+	system "github.com/bnema/archup/internal/system"
	19	+	gomock "go.uber.org/mock/gomock"
	20	+	)
	21	+
	22	+	// MockFileSystem is a mock of FileSystem interface.
	23	+	type MockFileSystem struct {
	24	+	ctrl *gomock.Controller
	25	+	recorder *MockFileSystemMockRecorder
	26	+	isgomock struct{}
	27	+	}
	28	+
	29	+	// MockFileSystemMockRecorder is the mock recorder for MockFileSystem.
	30	+	type MockFileSystemMockRecorder struct {
	31	+	mock *MockFileSystem
	32	+	}
	33	+
	34	+	// NewMockFileSystem creates a new mock instance.
	35	+	func NewMockFileSystem(ctrl gomock.Controller) MockFileSystem {
	36	+	mock := &MockFileSystem{ctrl: ctrl}
	37	+	mock.recorder = &MockFileSystemMockRecorder{mock}
	38	+	return mock
	39	+	}
	40	+
	41	+	// EXPECT returns an object that allows the caller to indicate expected use.
	42	+	func (m MockFileSystem) EXPECT() MockFileSystemMockRecorder {
	43	+	return m.recorder
	44	+	}
	45	+
	46	+	// Chmod mocks base method.
	47	+	func (m *MockFileSystem) Chmod(name string, mode os.FileMode) error {
	48	+	m.ctrl.T.Helper()
	49	+	ret := m.ctrl.Call(m, "Chmod", name, mode)
	50	+	ret0, _ := ret[0].(error)
	51	+	return ret0
	52	+	}
	53	+
	54	+	// Chmod indicates an expected call of Chmod.
	55	+	func (mr MockFileSystemMockRecorder) Chmod(name, mode any) gomock.Call {
	56	+	mr.mock.ctrl.T.Helper()
	57	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chmod", reflect.TypeOf((*MockFileSystem)(nil).Chmod), name, mode)
	58	+	}
	59	+
	60	+	// Create mocks base method.
	61	+	func (m *MockFileSystem) Create(name string) (io.WriteCloser, error) {
	62	+	m.ctrl.T.Helper()
	63	+	ret := m.ctrl.Call(m, "Create", name)
	64	+	ret0, _ := ret[0].(io.WriteCloser)
	65	+	ret1, _ := ret[1].(error)
	66	+	return ret0, ret1
	67	+	}
	68	+
	69	+	// Create indicates an expected call of Create.
	70	+	func (mr MockFileSystemMockRecorder) Create(name any) gomock.Call {
	71	+	mr.mock.ctrl.T.Helper()
	72	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockFileSystem)(nil).Create), name)
	73	+	}
	74	+
	75	+	// IsNotExist mocks base method.
	76	+	func (m *MockFileSystem) IsNotExist(err error) bool {
	77	+	m.ctrl.T.Helper()
	78	+	ret := m.ctrl.Call(m, "IsNotExist", err)
	79	+	ret0, _ := ret[0].(bool)
	80	+	return ret0
	81	+	}
	82	+
	83	+	// IsNotExist indicates an expected call of IsNotExist.
	84	+	func (mr MockFileSystemMockRecorder) IsNotExist(err any) gomock.Call {
	85	+	mr.mock.ctrl.T.Helper()
	86	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNotExist", reflect.TypeOf((*MockFileSystem)(nil).IsNotExist), err)
	87	+	}
	88	+
	89	+	// MkdirAll mocks base method.
	90	+	func (m *MockFileSystem) MkdirAll(path string, perm os.FileMode) error {
	91	+	m.ctrl.T.Helper()
	92	+	ret := m.ctrl.Call(m, "MkdirAll", path, perm)
	93	+	ret0, _ := ret[0].(error)
	94	+	return ret0
	95	+	}
	96	+
	97	+	// MkdirAll indicates an expected call of MkdirAll.
	98	+	func (mr MockFileSystemMockRecorder) MkdirAll(path, perm any) gomock.Call {
	99	+	mr.mock.ctrl.T.Helper()
	100	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MkdirAll", reflect.TypeOf((*MockFileSystem)(nil).MkdirAll), path, perm)
	101	+	}
	102	+
	103	+	// Open mocks base method.
	104	+	func (m *MockFileSystem) Open(name string) (io.ReadCloser, error) {
	105	+	m.ctrl.T.Helper()
	106	+	ret := m.ctrl.Call(m, "Open", name)
	107	+	ret0, _ := ret[0].(io.ReadCloser)
	108	+	ret1, _ := ret[1].(error)
	109	+	return ret0, ret1
	110	+	}
	111	+
	112	+	// Open indicates an expected call of Open.
	113	+	func (mr MockFileSystemMockRecorder) Open(name any) gomock.Call {
	114	+	mr.mock.ctrl.T.Helper()
	115	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*MockFileSystem)(nil).Open), name)
	116	+	}
	117	+
	118	+	// ReadFile mocks base method.
	119	+	func (m *MockFileSystem) ReadFile(filename string) ([]byte, error) {
	120	+	m.ctrl.T.Helper()
	121	+	ret := m.ctrl.Call(m, "ReadFile", filename)
	122	+	ret0, _ := ret[0].([]byte)
	123	+	ret1, _ := ret[1].(error)
	124	+	return ret0, ret1
	125	+	}
	126	+
	127	+	// ReadFile indicates an expected call of ReadFile.
	128	+	func (mr MockFileSystemMockRecorder) ReadFile(filename any) gomock.Call {
	129	+	mr.mock.ctrl.T.Helper()
	130	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadFile", reflect.TypeOf((*MockFileSystem)(nil).ReadFile), filename)
	131	+	}
	132	+
	133	+	// RemoveAll mocks base method.
	134	+	func (m *MockFileSystem) RemoveAll(path string) error {
	135	+	m.ctrl.T.Helper()
	136	+	ret := m.ctrl.Call(m, "RemoveAll", path)
	137	+	ret0, _ := ret[0].(error)
	138	+	return ret0
	139	+	}
	140	+
	141	+	// RemoveAll indicates an expected call of RemoveAll.
	142	+	func (mr MockFileSystemMockRecorder) RemoveAll(path any) gomock.Call {
	143	+	mr.mock.ctrl.T.Helper()
	144	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAll", reflect.TypeOf((*MockFileSystem)(nil).RemoveAll), path)
	145	+	}
	146	+
	147	+	// Stat mocks base method.
	148	+	func (m *MockFileSystem) Stat(name string) (os.FileInfo, error) {
	149	+	m.ctrl.T.Helper()
	150	+	ret := m.ctrl.Call(m, "Stat", name)
	151	+	ret0, _ := ret[0].(os.FileInfo)
	152	+	ret1, _ := ret[1].(error)
	153	+	return ret0, ret1
	154	+	}
	155	+
	156	+	// Stat indicates an expected call of Stat.
	157	+	func (mr MockFileSystemMockRecorder) Stat(name any) gomock.Call {
	158	+	mr.mock.ctrl.T.Helper()
	159	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockFileSystem)(nil).Stat), name)
	160	+	}
	161	+
	162	+	// WriteFile mocks base method.
	163	+	func (m *MockFileSystem) WriteFile(filename string, data []byte, perm os.FileMode) error {
	164	+	m.ctrl.T.Helper()
	165	+	ret := m.ctrl.Call(m, "WriteFile", filename, data, perm)
	166	+	ret0, _ := ret[0].(error)
	167	+	return ret0
	168	+	}
	169	+
	170	+	// WriteFile indicates an expected call of WriteFile.
	171	+	func (mr MockFileSystemMockRecorder) WriteFile(filename, data, perm any) gomock.Call {
	172	+	mr.mock.ctrl.T.Helper()
	173	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteFile", reflect.TypeOf((*MockFileSystem)(nil).WriteFile), filename, data, perm)
	174	+	}
	175	+
	176	+	// MockCommandExecutor is a mock of CommandExecutor interface.
	177	+	type MockCommandExecutor struct {
	178	+	ctrl *gomock.Controller
	179	+	recorder *MockCommandExecutorMockRecorder
	180	+	isgomock struct{}
	181	+	}
	182	+
	183	+	// MockCommandExecutorMockRecorder is the mock recorder for MockCommandExecutor.
	184	+	type MockCommandExecutorMockRecorder struct {
	185	+	mock *MockCommandExecutor
	186	+	}
	187	+
	188	+	// NewMockCommandExecutor creates a new mock instance.
	189	+	func NewMockCommandExecutor(ctrl gomock.Controller) MockCommandExecutor {
	190	+	mock := &MockCommandExecutor{ctrl: ctrl}
	191	+	mock.recorder = &MockCommandExecutorMockRecorder{mock}
	192	+	return mock
	193	+	}
	194	+
	195	+	// EXPECT returns an object that allows the caller to indicate expected use.
	196	+	func (m MockCommandExecutor) EXPECT() MockCommandExecutorMockRecorder {
	197	+	return m.recorder
	198	+	}
	199	+
	200	+	// Execute mocks base method.
	201	+	func (m *MockCommandExecutor) Execute(name string, args ...string) ([]byte, error) {
	202	+	m.ctrl.T.Helper()
	203	+	varargs := []any{name}
	204	+	for _, a := range args {
	205	+	varargs = append(varargs, a)
	206	+	}
	207	+	ret := m.ctrl.Call(m, "Execute", varargs...)
	208	+	ret0, _ := ret[0].([]byte)
	209	+	ret1, _ := ret[1].(error)
	210	+	return ret0, ret1
	211	+	}
	212	+
	213	+	// Execute indicates an expected call of Execute.
	214	+	func (mr MockCommandExecutorMockRecorder) Execute(name any, args ...any) gomock.Call {
	215	+	mr.mock.ctrl.T.Helper()
	216	+	varargs := append([]any{name}, args...)
	217	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Execute", reflect.TypeOf((*MockCommandExecutor)(nil).Execute), varargs...)
	218	+	}
	219	+
	220	+	// MockSystemExecutor is a mock of SystemExecutor interface.
	221	+	type MockSystemExecutor struct {
	222	+	ctrl *gomock.Controller
	223	+	recorder *MockSystemExecutorMockRecorder
	224	+	isgomock struct{}
	225	+	}
	226	+
	227	+	// MockSystemExecutorMockRecorder is the mock recorder for MockSystemExecutor.
	228	+	type MockSystemExecutorMockRecorder struct {
	229	+	mock *MockSystemExecutor
	230	+	}
	231	+
	232	+	// NewMockSystemExecutor creates a new mock instance.
	233	+	func NewMockSystemExecutor(ctrl gomock.Controller) MockSystemExecutor {
	234	+	mock := &MockSystemExecutor{ctrl: ctrl}
	235	+	mock.recorder = &MockSystemExecutorMockRecorder{mock}
	236	+	return mock
	237	+	}
	238	+
	239	+	// EXPECT returns an object that allows the caller to indicate expected use.
	240	+	func (m MockSystemExecutor) EXPECT() MockSystemExecutorMockRecorder {
	241	+	return m.recorder
	242	+	}
	243	+
	244	+	// DetectCPUInfo mocks base method.
	245	+	func (m MockSystemExecutor) DetectCPUInfo() (system.CPUInfo, error) {
	246	+	m.ctrl.T.Helper()
	247	+	ret := m.ctrl.Call(m, "DetectCPUInfo")
	248	+	ret0, _ := ret[0].(*system.CPUInfo)
	249	+	ret1, _ := ret[1].(error)
	250	+	return ret0, ret1
	251	+	}
	252	+
	253	+	// DetectCPUInfo indicates an expected call of DetectCPUInfo.
	254	+	func (mr MockSystemExecutorMockRecorder) DetectCPUInfo() gomock.Call {
	255	+	mr.mock.ctrl.T.Helper()
	256	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetectCPUInfo", reflect.TypeOf((*MockSystemExecutor)(nil).DetectCPUInfo))
	257	+	}
	258	+
	259	+	// RunSimple mocks base method.
	260	+	func (m *MockSystemExecutor) RunSimple(command string, args ...string) system.CommandResult {
	261	+	m.ctrl.T.Helper()
	262	+	varargs := []any{command}
	263	+	for _, a := range args {
	264	+	varargs = append(varargs, a)
	265	+	}
	266	+	ret := m.ctrl.Call(m, "RunSimple", varargs...)
	267	+	ret0, _ := ret[0].(system.CommandResult)
	268	+	return ret0
	269	+	}
	270	+
	271	+	// RunSimple indicates an expected call of RunSimple.
	272	+	func (mr MockSystemExecutorMockRecorder) RunSimple(command any, args ...any) gomock.Call {
	273	+	mr.mock.ctrl.T.Helper()
	274	+	varargs := append([]any{command}, args...)
	275	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunSimple", reflect.TypeOf((*MockSystemExecutor)(nil).RunSimple), varargs...)
	276	+	}
	277	+
	278	+	// MockChrootExecutor is a mock of ChrootExecutor interface.
	279	+	type MockChrootExecutor struct {
	280	+	ctrl *gomock.Controller
	281	+	recorder *MockChrootExecutorMockRecorder
	282	+	isgomock struct{}
	283	+	}
	284	+
	285	+	// MockChrootExecutorMockRecorder is the mock recorder for MockChrootExecutor.
	286	+	type MockChrootExecutorMockRecorder struct {
	287	+	mock *MockChrootExecutor
	288	+	}
	289	+
	290	+	// NewMockChrootExecutor creates a new mock instance.
	291	+	func NewMockChrootExecutor(ctrl gomock.Controller) MockChrootExecutor {
	292	+	mock := &MockChrootExecutor{ctrl: ctrl}
	293	+	mock.recorder = &MockChrootExecutorMockRecorder{mock}
	294	+	return mock
	295	+	}
	296	+
	297	+	// EXPECT returns an object that allows the caller to indicate expected use.
	298	+	func (m MockChrootExecutor) EXPECT() MockChrootExecutorMockRecorder {
	299	+	return m.recorder
	300	+	}
	301	+
	302	+	// ChrootExec mocks base method.
	303	+	func (m *MockChrootExecutor) ChrootExec(logPath, mountPoint, command string, args ...string) error {
	304	+	m.ctrl.T.Helper()
	305	+	varargs := []any{logPath, mountPoint, command}
	306	+	for _, a := range args {
	307	+	varargs = append(varargs, a)
	308	+	}
	309	+	ret := m.ctrl.Call(m, "ChrootExec", varargs...)
	310	+	ret0, _ := ret[0].(error)
	311	+	return ret0
	312	+	}
	313	+
	314	+	// ChrootExec indicates an expected call of ChrootExec.
	315	+	func (mr MockChrootExecutorMockRecorder) ChrootExec(logPath, mountPoint, command any, args ...any) gomock.Call {
	316	+	mr.mock.ctrl.T.Helper()
	317	+	varargs := append([]any{logPath, mountPoint, command}, args...)
	318	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChrootExec", reflect.TypeOf((*MockChrootExecutor)(nil).ChrootExec), varargs...)
	319	+	}
	320	+
	321	+	// ChrootExecWithStdin mocks base method.
	322	+	func (m *MockChrootExecutor) ChrootExecWithStdin(logPath, mountPoint, command, stdin string) error {
	323	+	m.ctrl.T.Helper()
	324	+	ret := m.ctrl.Call(m, "ChrootExecWithStdin", logPath, mountPoint, command, stdin)
	325	+	ret0, _ := ret[0].(error)
	326	+	return ret0
	327	+	}
	328	+
	329	+	// ChrootExecWithStdin indicates an expected call of ChrootExecWithStdin.
	330	+	func (mr MockChrootExecutorMockRecorder) ChrootExecWithStdin(logPath, mountPoint, command, stdin any) gomock.Call {
	331	+	mr.mock.ctrl.T.Helper()
	332	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChrootExecWithStdin", reflect.TypeOf((*MockChrootExecutor)(nil).ChrootExecWithStdin), logPath, mountPoint, command, stdin)
	333	+	}
	334	+
	335	+	// ChrootPacman mocks base method.
	336	+	func (m *MockChrootExecutor) ChrootPacman(logPath, mountPoint, operation string, packages ...string) error {
	337	+	m.ctrl.T.Helper()
	338	+	varargs := []any{logPath, mountPoint, operation}
	339	+	for _, a := range packages {
	340	+	varargs = append(varargs, a)
	341	+	}
	342	+	ret := m.ctrl.Call(m, "ChrootPacman", varargs...)
	343	+	ret0, _ := ret[0].(error)
	344	+	return ret0
	345	+	}
	346	+
	347	+	// ChrootPacman indicates an expected call of ChrootPacman.
	348	+	func (mr MockChrootExecutorMockRecorder) ChrootPacman(logPath, mountPoint, operation any, packages ...any) gomock.Call {
	349	+	mr.mock.ctrl.T.Helper()
	350	+	varargs := append([]any{logPath, mountPoint, operation}, packages...)
	351	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChrootPacman", reflect.TypeOf((*MockChrootExecutor)(nil).ChrootPacman), varargs...)
	352	+	}
	353	+
	354	+	// ChrootSystemctl mocks base method.
	355	+	func (m *MockChrootExecutor) ChrootSystemctl(logPath, mountPoint, action, service string) error {
	356	+	m.ctrl.T.Helper()
	357	+	ret := m.ctrl.Call(m, "ChrootSystemctl", logPath, mountPoint, action, service)
	358	+	ret0, _ := ret[0].(error)
	359	+	return ret0
	360	+	}
	361	+
	362	+	// ChrootSystemctl indicates an expected call of ChrootSystemctl.
	363	+	func (mr MockChrootExecutorMockRecorder) ChrootSystemctl(logPath, mountPoint, action, service any) gomock.Call {
	364	+	mr.mock.ctrl.T.Helper()
	365	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChrootSystemctl", reflect.TypeOf((*MockChrootExecutor)(nil).ChrootSystemctl), logPath, mountPoint, action, service)
	366	+	}
	367	+
	368	+	// DownloadAndInstallPackages mocks base method.
	369	+	func (m *MockChrootExecutor) DownloadAndInstallPackages(logPath, chrootPath string, urls ...string) error {
	370	+	m.ctrl.T.Helper()
	371	+	varargs := []any{logPath, chrootPath}
	372	+	for _, a := range urls {
	373	+	varargs = append(varargs, a)
	374	+	}
	375	+	ret := m.ctrl.Call(m, "DownloadAndInstallPackages", varargs...)
	376	+	ret0, _ := ret[0].(error)
	377	+	return ret0
	378	+	}
	379	+
	380	+	// DownloadAndInstallPackages indicates an expected call of DownloadAndInstallPackages.
	381	+	func (mr MockChrootExecutorMockRecorder) DownloadAndInstallPackages(logPath, chrootPath any, urls ...any) gomock.Call {
	382	+	mr.mock.ctrl.T.Helper()
	383	+	varargs := append([]any{logPath, chrootPath}, urls...)
	384	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadAndInstallPackages", reflect.TypeOf((*MockChrootExecutor)(nil).DownloadAndInstallPackages), varargs...)
	385	+	}
	386	+
	387	+	// MockHTTPClient is a mock of HTTPClient interface.
	388	+	type MockHTTPClient struct {
	389	+	ctrl *gomock.Controller
	390	+	recorder *MockHTTPClientMockRecorder
	391	+	isgomock struct{}
	392	+	}
	393	+
	394	+	// MockHTTPClientMockRecorder is the mock recorder for MockHTTPClient.
	395	+	type MockHTTPClientMockRecorder struct {
	396	+	mock *MockHTTPClient
	397	+	}
	398	+
	399	+	// NewMockHTTPClient creates a new mock instance.
	400	+	func NewMockHTTPClient(ctrl gomock.Controller) MockHTTPClient {
	401	+	mock := &MockHTTPClient{ctrl: ctrl}
	402	+	mock.recorder = &MockHTTPClientMockRecorder{mock}
	403	+	return mock
	404	+	}
	405	+
	406	+	// EXPECT returns an object that allows the caller to indicate expected use.
	407	+	func (m MockHTTPClient) EXPECT() MockHTTPClientMockRecorder {
	408	+	return m.recorder
	409	+	}
	410	+
	411	+	// Get mocks base method.
	412	+	func (m MockHTTPClient) Get(url string) (http.Response, error) {
	413	+	m.ctrl.T.Helper()
	414	+	ret := m.ctrl.Call(m, "Get", url)
	415	+	ret0, _ := ret[0].(*http.Response)
	416	+	ret1, _ := ret[1].(error)
	417	+	return ret0, ret1
	418	+	}
	419	+
	420	+	// Get indicates an expected call of Get.
	421	+	func (mr MockHTTPClientMockRecorder) Get(url any) gomock.Call {
	422	+	mr.mock.ctrl.T.Helper()
	423	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockHTTPClient)(nil).Get), url)
	424	+	}
	425	+
	426	+	// MockConfigSaver is a mock of ConfigSaver interface.
	427	+	type MockConfigSaver struct {
	428	+	ctrl *gomock.Controller
	429	+	recorder *MockConfigSaverMockRecorder
	430	+	isgomock struct{}
	431	+	}
	432	+
	433	+	// MockConfigSaverMockRecorder is the mock recorder for MockConfigSaver.
	434	+	type MockConfigSaverMockRecorder struct {
	435	+	mock *MockConfigSaver
	436	+	}
	437	+
	438	+	// NewMockConfigSaver creates a new mock instance.
	439	+	func NewMockConfigSaver(ctrl gomock.Controller) MockConfigSaver {
	440	+	mock := &MockConfigSaver{ctrl: ctrl}
	441	+	mock.recorder = &MockConfigSaverMockRecorder{mock}
	442	+	return mock
	443	+	}
	444	+
	445	+	// EXPECT returns an object that allows the caller to indicate expected use.
	446	+	func (m MockConfigSaver) EXPECT() MockConfigSaverMockRecorder {
	447	+	return m.recorder
	448	+	}
	449	+
	450	+	// Save mocks base method.
	451	+	func (m *MockConfigSaver) Save() error {
	452	+	m.ctrl.T.Helper()
	453	+	ret := m.ctrl.Call(m, "Save")
	454	+	ret0, _ := ret[0].(error)
	455	+	return ret0
	456	+	}
	457	+
	458	+	// Save indicates an expected call of Save.
	459	+	func (mr MockConfigSaverMockRecorder) Save() gomock.Call {
	460	+	mr.mock.ctrl.T.Helper()
	461	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockConfigSaver)(nil).Save))
	462	+	}

M internal/phases/base.go +12 -9

 import (
 	"bufio"
 	"fmt"
-	"os"
 	"strings"
 	"github.com/bnema/archup/internal/config"
+	"github.com/bnema/archup/internal/interfaces"
 	"github.com/bnema/archup/internal/logger"
-	"github.com/bnema/archup/internal/system"
 )
 // BaseInstallPhase handles base system installation
 type BaseInstallPhase struct {
 	*BasePhase
+	fs      interfaces.FileSystem
+	sysExec interfaces.SystemExecutor
 	packages []string
 }
 // NewBaseInstallPhase creates a new base installation phase
-func NewBaseInstallPhase(cfg *config.Config, log *logger.Logger) *BaseInstallPhase {
+func NewBaseInstallPhase(cfg *config.Config, log *logger.Logger, fs interfaces.FileSystem, sysExec interfaces.SystemExecutor) *BaseInstallPhase {
 	return &BaseInstallPhase{
 		BasePhase: NewBasePhase("base", "Base System Installation", cfg, log),
+		fs:        fs,
+		sysExec:   sysExec,
 	}
 }
 // PreCheck validates prerequisites
 func (p *BaseInstallPhase) PreCheck() error {
 	// Verify /mnt is mounted
-	result := system.RunSimple("mountpoint", "-q", "/mnt")
+	result := p.sysExec.RunSimple("mountpoint", "-q", "/mnt")
 	switch {
 	case result.ExitCode != 0:
 		return fmt.Errorf("/mnt is not mounted")
 	p.SendOutput(progressChan, "Detecting CPU vendor...")
 	// Read /proc/cpuinfo to detect vendor
-	file, err := os.Open("/proc/cpuinfo")
+	file, err := p.fs.Open("/proc/cpuinfo")
 	switch {
 	case err != nil:
 		return fmt.Errorf("failed to read /proc/cpuinfo: %w", err)
 	// Use DefaultInstallDir directly to match where bootstrap downloads files
 	packageFile := config.DefaultInstallDir + "/" + config.BasePackagesFile
-	file, err := os.Open(packageFile)
+	file, err := p.fs.Open(packageFile)
 	switch {
 	case err != nil:
 		return nil, fmt.Errorf("failed to open %s: %w", packageFile, err)
 func (p *BaseInstallPhase) generateFstab(progressChan chan<- ProgressUpdate) error {
 	p.SendOutput(progressChan, "Generating fstab with UUIDs...")
-	result := system.RunSimple("sh", "-c", "genfstab -U /mnt >> /mnt/etc/fstab")
+	result := p.sysExec.RunSimple("sh", "-c", "genfstab -U /mnt >> /mnt/etc/fstab")
 	switch {
 	case result.ExitCode != 0:
 		return fmt.Errorf("genfstab failed: %w", result.Error)
 // PostCheck validates installation
 func (p *BaseInstallPhase) PostCheck() error {
 	// Check if base system exists
-	result := system.RunSimple("test", "-d", "/mnt/usr")
+	result := p.sysExec.RunSimple("test", "-d", "/mnt/usr")
 	switch {
 	case result.ExitCode != 0:
 		return fmt.Errorf("/mnt/usr does not exist")
 	}
 	// Check if fstab exists
-	result = system.RunSimple("test", "-f", "/mnt/etc/fstab")
+	result = p.sysExec.RunSimple("test", "-f", "/mnt/etc/fstab")
 	switch {
 	case result.ExitCode != 0:
 		return fmt.Errorf("/mnt/etc/fstab was not created")

M internal/phases/base_test.go +3 -13

 				return
 			}
 			if tt.wantErr && err != nil {
-				if errMsg := err.Error(); tt.errContains != "" && !containsSubstringBaseTest(errMsg, tt.errContains) {
+				if errMsg := err.Error(); tt.errContains != "" && !containsSubstring(errMsg, tt.errContains) {
 					t.Errorf("PreCheck() error = %q, should contain %q", errMsg, tt.errContains)
 				}
 			}
 				return
 			}
 			if tt.wantErr && err != nil {
-				if errMsg := err.Error(); tt.errContains != "" && !containsSubstringBaseTest(errMsg, tt.errContains) {
+				if errMsg := err.Error(); tt.errContains != "" && !containsSubstring(errMsg, tt.errContains) {
 					t.Errorf("generateFstab() error = %q, should contain %q", errMsg, tt.errContains)
 				}
 			}
 				return
 			}
 			if tt.wantErr && err != nil {
-				if errMsg := err.Error(); tt.errContains != "" && !containsSubstringBaseTest(errMsg, tt.errContains) {
+				if errMsg := err.Error(); tt.errContains != "" && !containsSubstring(errMsg, tt.errContains) {
 					t.Errorf("PostCheck() error = %q, should contain %q", errMsg, tt.errContains)
 				}
 			}
 		t.Error("CanSkip() = true, want false")
 	}
 }
-// Helper function for substring matching (avoid duplication across test files)
-func containsSubstringBaseTest(s, substr string) bool {
-	for i := 0; i < len(s)-len(substr)+1; i++ {
-		if s[i:i+len(substr)] == substr {
-			return true
-		}
-	}
-	return false
-}

M internal/phases/boot.go +25 -19

 import (
 	"fmt"
-	"os"
 	"path/filepath"
 	"regexp"
 	"strings"
 	"github.com/bnema/archup/internal/config"
+	"github.com/bnema/archup/internal/interfaces"
 	"github.com/bnema/archup/internal/logger"
 	"github.com/bnema/archup/internal/system"
 )
 // BootPhase handles bootloader installation
 type BootPhase struct {
 	*BasePhase
+	fs       interfaces.FileSystem
+	sysExec  interfaces.SystemExecutor
+	chrExec  interfaces.ChrootExecutor
 }
 // NewBootPhase creates a new boot phase
-func NewBootPhase(cfg *config.Config, log *logger.Logger) *BootPhase {
+func NewBootPhase(cfg *config.Config, log *logger.Logger, fs interfaces.FileSystem, sysExec interfaces.SystemExecutor, chrExec interfaces.ChrootExecutor) *BootPhase {
 	return &BootPhase{
 		BasePhase: NewBasePhase("boot", "Bootloader Installation", cfg, log),
+		fs:        fs,
+		sysExec:   sysExec,
+		chrExec:   chrExec,
 	}
 }
 // PreCheck validates boot prerequisites
 func (p *BootPhase) PreCheck() error {
 	// Verify /mnt is mounted
-	result := system.RunSimple("mountpoint", "-q", config.PathMnt)
+	result := p.sysExec.RunSimple("mountpoint", "-q", config.PathMnt)
 	switch {
 	case result.ExitCode != 0:
 		return fmt.Errorf("%s is not mounted", config.PathMnt)
 	}
 	// Verify boot partition is mounted
-	result = system.RunSimple("mountpoint", "-q", config.PathMntBoot)
+	result = p.sysExec.RunSimple("mountpoint", "-q", config.PathMntBoot)
 	switch {
 	case result.ExitCode != 0:
 		return fmt.Errorf("%s is not mounted", config.PathMntBoot)
 	p.SendOutput(progressChan, "Configuring initramfs...")
 	// Read current mkinitcpio.conf
-	content, err := os.ReadFile(config.PathMntEtcMkinitcpio)
+	content, err := p.fs.ReadFile(config.PathMntEtcMkinitcpio)
 	switch {
 	case err != nil:
 		return fmt.Errorf("failed to read mkinitcpio.conf: %w", err)
 	newContent := hooksRegex.ReplaceAllString(string(content), hooks)
 	// Write updated config
-	switch err := os.WriteFile(config.PathMntEtcMkinitcpio, []byte(newContent), 0644); {
+	switch err := p.fs.WriteFile(config.PathMntEtcMkinitcpio, []byte(newContent), 0644); {
 	case err != nil:
 		return fmt.Errorf("failed to write mkinitcpio.conf: %w", err)
 	}
 	// Regenerate initramfs
 	p.SendOutput(progressChan, "Regenerating initramfs...")
-	switch err := system.ChrootExec(p.logger.LogPath(),config.PathMnt, "mkinitcpio -P"); {
+	switch err := p.chrExec.ChrootExec(p.logger.LogPath(),config.PathMnt, "mkinitcpio -P"); {
 	case err != nil:
 		return fmt.Errorf("failed to regenerate initramfs: %w", err)
 	}
 	// Install Limine to disk (BIOS - optional, may fail on UEFI-only)
 	biosCmd := fmt.Sprintf("limine bios-install %s", p.config.TargetDisk)
-	switch err := system.ChrootExec(p.logger.LogPath(),config.PathMnt, biosCmd); {
+	switch err := p.chrExec.ChrootExec(p.logger.LogPath(),config.PathMnt, biosCmd); {
 	case err != nil:
 		p.SendOutput(progressChan, "[WARN] BIOS installation skipped (UEFI-only system)")
 	default:
 	}
 	// Create Limine directory
-	switch err := os.MkdirAll(config.PathMntBootEFILimine, 0755); {
+	switch err := p.fs.MkdirAll(config.PathMntBootEFILimine, 0755); {
 	case err != nil:
 		return fmt.Errorf("failed to create Limine directory: %w", err)
 	}
 	// Get root partition UUID
 	rootPartition := p.config.RootPartition
-	result := system.RunSimple("blkid", "-s", "UUID", "-o", "value", rootPartition)
+	result := p.sysExec.RunSimple("blkid", "-s", "UUID", "-o", "value", rootPartition)
 	switch {
 	case result.ExitCode != 0:
 		return fmt.Errorf("failed to get root partition UUID: %w", result.Error)
 	switch {
 	case p.config.AMDPState != "":
 		// Detect CPU to get Zen generation for proper kernel params
-		cpuInfo, err := system.DetectCPUInfo()
+		cpuInfo, err := p.sysExec.DetectCPUInfo()
 		var amdParams string
 		if err == nil && cpuInfo.AMDZenGen != nil {
 			// Use helper function that adds extra params for Zen 2 if needed
 	// Read Limine config template
 	templatePath := p.getInstallPath(config.LimineConfigTemplate)
-	templateContent, err := os.ReadFile(templatePath)
+	templateContent, err := p.fs.ReadFile(templatePath)
 	switch {
 	case err != nil:
 		return fmt.Errorf("failed to read Limine template: %w", err)
 	// Write Limine configuration
 	limineConfigPath := filepath.Join(config.PathMntBootEFILimine, config.FileLimineConfig)
-	switch err := os.WriteFile(limineConfigPath, []byte(limineConfig), 0644); {
+	switch err := p.fs.WriteFile(limineConfigPath, []byte(limineConfig), 0644); {
 	case err != nil:
 		return fmt.Errorf("failed to write Limine config: %w", err)
 	}
 		config.UEFIBootLoader,
 	)
-	switch err := system.ChrootExec(p.logger.LogPath(),config.PathMnt, efiCmd); {
+	switch err := p.chrExec.ChrootExec(p.logger.LogPath(),config.PathMnt, efiCmd); {
 	case err != nil:
 		return fmt.Errorf("failed to create UEFI boot entry: %w", err)
 	}
 func (p *BootPhase) PostCheck() error {
 	// Verify Limine bootloader exists
 	bootloaderPath := filepath.Join(config.PathMntBootEFILimine, config.FileLimineBootloader)
-	switch _, err := os.Stat(bootloaderPath); {
+	switch _, err := p.fs.Stat(bootloaderPath); {
-	case os.IsNotExist(err):
+	case p.fs.IsNotExist(err):
 		return fmt.Errorf("Limine bootloader was not installed")
 	}
 	// Verify Limine config exists
 	configPath := filepath.Join(config.PathMntBootEFILimine, config.FileLimineConfig)
-	switch _, err := os.Stat(configPath); {
+	switch _, err := p.fs.Stat(configPath); {
-	case os.IsNotExist(err):
+	case p.fs.IsNotExist(err):
 		return fmt.Errorf("Limine config was not created")
 	}
 // Rollback for boot phase
 func (p *BootPhase) Rollback() error {
 	// Remove Limine files if they exist
-	switch err := os.RemoveAll(config.PathMntBootEFILimine); {
+	switch err := p.fs.RemoveAll(config.PathMntBootEFILimine); {
 	case err != nil:
 		p.SendOutput(nil, fmt.Sprintf("[WARN] Failed to remove Limine directory: %v", err))
 	}

A internal/phases/boot_test.go +526 -0

@@ -0,0 +1,526 @@
	1	+	package phases
	2	+
	3	+	import (
	4	+	"fmt"
	5	+	"path/filepath"
	6	+	"testing"
	7	+
	8	+	"github.com/bnema/archup/internal/config"
	9	+	"github.com/bnema/archup/internal/interfaces/mocks"
	10	+	"github.com/bnema/archup/internal/logger"
	11	+	"github.com/bnema/archup/internal/system"
	12	+	"go.uber.org/mock/gomock"
	13	+	)
	14	+
	15	+	// TestBootPhasePreCheck tests boot prerequisites
	16	+	func TestBootPhasePreCheck(t *testing.T) {
	17	+	tests := []struct {
	18	+	name string
	19	+	setupMocks func(*mocks.MockSystemExecutor)
	20	+	wantErr bool
	21	+	errContains string
	22	+	}{
	23	+	{
	24	+	name: "Both /mnt and /mnt/boot mounted",
	25	+	setupMocks: func(mockSysExec *mocks.MockSystemExecutor) {
	26	+	mockSysExec.EXPECT().RunSimple("mountpoint", "-q", config.PathMnt).Return(system.CommandResult{ExitCode: 0}).Times(1)
	27	+	mockSysExec.EXPECT().RunSimple("mountpoint", "-q", config.PathMntBoot).Return(system.CommandResult{ExitCode: 0}).Times(1)
	28	+	},
	29	+	wantErr: false,
	30	+	},
	31	+	{
	32	+	name: "/mnt not mounted",
	33	+	setupMocks: func(mockSysExec *mocks.MockSystemExecutor) {
	34	+	mockSysExec.EXPECT().RunSimple("mountpoint", "-q", config.PathMnt).Return(system.CommandResult{ExitCode: 32}).Times(1)
	35	+	},
	36	+	wantErr: true,
	37	+	errContains: "is not mounted",
	38	+	},
	39	+	{
	40	+	name: "/mnt/boot not mounted",
	41	+	setupMocks: func(mockSysExec *mocks.MockSystemExecutor) {
	42	+	mockSysExec.EXPECT().RunSimple("mountpoint", "-q", config.PathMnt).Return(system.CommandResult{ExitCode: 0}).Times(1)
	43	+	mockSysExec.EXPECT().RunSimple("mountpoint", "-q", config.PathMntBoot).Return(system.CommandResult{ExitCode: 32}).Times(1)
	44	+	},
	45	+	wantErr: true,
	46	+	errContains: "is not mounted",
	47	+	},
	48	+	}
	49	+
	50	+	for _, tt := range tests {
	51	+	t.Run(tt.name, func(t *testing.T) {
	52	+	ctrl := gomock.NewController(t)
	53	+	defer ctrl.Finish()
	54	+
	55	+	mockFS := mocks.NewMockFileSystem(ctrl)
	56	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	57	+	mockChrExec := mocks.NewMockChrootExecutor(ctrl)
	58	+
	59	+	tt.setupMocks(mockSysExec)
	60	+
	61	+	tmpDir := t.TempDir()
	62	+	logPath := filepath.Join(tmpDir, "test.log")
	63	+	log, err := logger.New(logPath, false)
	64	+	if err != nil {
	65	+	t.Fatalf("Failed to create logger: %v", err)
	66	+	}
	67	+	defer log.Close()
	68	+
	69	+	cfg := config.NewConfig("test")
	70	+	phase := NewBootPhase(cfg, log, mockFS, mockSysExec, mockChrExec)
	71	+
	72	+	err = phase.PreCheck()
	73	+	if (err != nil) != tt.wantErr {
	74	+	t.Errorf("PreCheck() error = %v, wantErr %v", err, tt.wantErr)
	75	+	return
	76	+	}
	77	+	if tt.wantErr && err != nil {
	78	+	if errMsg := err.Error(); tt.errContains != "" && !containsSubstring(errMsg, tt.errContains) {
	79	+	t.Errorf("PreCheck() error = %q, should contain %q", errMsg, tt.errContains)
	80	+	}
	81	+	}
	82	+	})
	83	+	}
	84	+	}
	85	+
	86	+	// TestBootPhaseExtractPartitionNumber tests partition number extraction
	87	+	func TestBootPhaseExtractPartitionNumber(t *testing.T) {
	88	+	tests := []struct {
	89	+	name string
	90	+	devicePath string
	91	+	expectedNum string
	92	+	}{
	93	+	{
	94	+	name: "SATA partition /dev/sda1",
	95	+	devicePath: "/dev/sda1",
	96	+	expectedNum: "1",
	97	+	},
	98	+	{
	99	+	name: "SATA partition /dev/sdb2",
	100	+	devicePath: "/dev/sdb2",
	101	+	expectedNum: "2",
	102	+	},
	103	+	{
	104	+	name: "NVMe partition /dev/nvme0n1p1",
	105	+	devicePath: "/dev/nvme0n1p1",
	106	+	expectedNum: "1",
	107	+	},
	108	+	{
	109	+	name: "NVMe partition /dev/nvme0n1p2",
	110	+	devicePath: "/dev/nvme0n1p2",
	111	+	expectedNum: "2",
	112	+	},
	113	+	{
	114	+	name: "VirtIO partition /dev/vda1",
	115	+	devicePath: "/dev/vda1",
	116	+	expectedNum: "1",
	117	+	},
	118	+	{
	119	+	name: "Multiple digit partition /dev/sda12",
	120	+	devicePath: "/dev/sda12",
	121	+	expectedNum: "12",
	122	+	},
	123	+	{
	124	+	name: "No partition number - returns empty",
	125	+	devicePath: "/dev/sda",
	126	+	expectedNum: "",
	127	+	},
	128	+	}
	129	+
	130	+	for _, tt := range tests {
	131	+	t.Run(tt.name, func(t *testing.T) {
	132	+	ctrl := gomock.NewController(t)
	133	+	defer ctrl.Finish()
	134	+
	135	+	mockFS := mocks.NewMockFileSystem(ctrl)
	136	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	137	+	mockChrExec := mocks.NewMockChrootExecutor(ctrl)
	138	+
	139	+	tmpDir := t.TempDir()
	140	+	logPath := filepath.Join(tmpDir, "test.log")
	141	+	log, err := logger.New(logPath, false)
	142	+	if err != nil {
	143	+	t.Fatalf("Failed to create logger: %v", err)
	144	+	}
	145	+	defer log.Close()
	146	+
	147	+	cfg := config.NewConfig("test")
	148	+	phase := NewBootPhase(cfg, log, mockFS, mockSysExec, mockChrExec)
	149	+
	150	+	result := phase.extractPartitionNumber(tt.devicePath)
	151	+	if result != tt.expectedNum {
	152	+	t.Errorf("extractPartitionNumber(%q) = %q, want %q", tt.devicePath, result, tt.expectedNum)
	153	+	}
	154	+	})
	155	+	}
	156	+	}
	157	+
	158	+	// TestBootPhasePostCheck tests boot configuration validation
	159	+	func TestBootPhasePostCheck(t *testing.T) {
	160	+	tests := []struct {
	161	+	name string
	162	+	setupMocks func(*mocks.MockFileSystem)
	163	+	wantErr bool
	164	+	errContains string
	165	+	}{
	166	+	{
	167	+	name: "Both bootloader and config exist",
	168	+	setupMocks: func(mockFS *mocks.MockFileSystem) {
	169	+	bootloaderPath := filepath.Join(config.PathMntBootEFILimine, config.FileLimineBootloader)
	170	+	configPath := filepath.Join(config.PathMntBootEFILimine, config.FileLimineConfig)
	171	+
	172	+	mockFS.EXPECT().Stat(bootloaderPath).Return(mockFileInfo{}, nil).Times(1)
	173	+	mockFS.EXPECT().IsNotExist(gomock.Any()).Return(false).Times(1)
	174	+	mockFS.EXPECT().Stat(configPath).Return(mockFileInfo{}, nil).Times(1)
	175	+	mockFS.EXPECT().IsNotExist(gomock.Any()).Return(false).Times(1)
	176	+	},
	177	+	wantErr: false,
	178	+	},
	179	+	{
	180	+	name: "Bootloader missing",
	181	+	setupMocks: func(mockFS *mocks.MockFileSystem) {
	182	+	bootloaderPath := filepath.Join(config.PathMntBootEFILimine, config.FileLimineBootloader)
	183	+
	184	+	mockFS.EXPECT().Stat(bootloaderPath).Return(nil, fmt.Errorf("not found")).Times(1)
	185	+	mockFS.EXPECT().IsNotExist(gomock.Any()).Return(true).Times(1)
	186	+	},
	187	+	wantErr: true,
	188	+	errContains: "bootloader was not installed",
	189	+	},
	190	+	{
	191	+	name: "Config missing",
	192	+	setupMocks: func(mockFS *mocks.MockFileSystem) {
	193	+	bootloaderPath := filepath.Join(config.PathMntBootEFILimine, config.FileLimineBootloader)
	194	+	configPath := filepath.Join(config.PathMntBootEFILimine, config.FileLimineConfig)
	195	+
	196	+	mockFS.EXPECT().Stat(bootloaderPath).Return(mockFileInfo{}, nil).Times(1)
	197	+	mockFS.EXPECT().IsNotExist(gomock.Any()).Return(false).Times(1)
	198	+	mockFS.EXPECT().Stat(configPath).Return(nil, fmt.Errorf("not found")).Times(1)
	199	+	mockFS.EXPECT().IsNotExist(gomock.Any()).Return(true).Times(1)
	200	+	},
	201	+	wantErr: true,
	202	+	errContains: "config was not created",
	203	+	},
	204	+	}
	205	+
	206	+	for _, tt := range tests {
	207	+	t.Run(tt.name, func(t *testing.T) {
	208	+	ctrl := gomock.NewController(t)
	209	+	defer ctrl.Finish()
	210	+
	211	+	mockFS := mocks.NewMockFileSystem(ctrl)
	212	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	213	+	mockChrExec := mocks.NewMockChrootExecutor(ctrl)
	214	+
	215	+	tt.setupMocks(mockFS)
	216	+
	217	+	tmpDir := t.TempDir()
	218	+	logPath := filepath.Join(tmpDir, "test.log")
	219	+	log, err := logger.New(logPath, false)
	220	+	if err != nil {
	221	+	t.Fatalf("Failed to create logger: %v", err)
	222	+	}
	223	+	defer log.Close()
	224	+
	225	+	cfg := config.NewConfig("test")
	226	+	cfg.ConfigPath = filepath.Join(tmpDir, "config")
	227	+
	228	+	phase := NewBootPhase(cfg, log, mockFS, mockSysExec, mockChrExec)
	229	+
	230	+	err = phase.PostCheck()
	231	+	if (err != nil) != tt.wantErr {
	232	+	t.Errorf("PostCheck() error = %v, wantErr %v", err, tt.wantErr)
	233	+	return
	234	+	}
	235	+	if tt.wantErr && err != nil {
	236	+	if errMsg := err.Error(); tt.errContains != "" && !containsSubstring(errMsg, tt.errContains) {
	237	+	t.Errorf("PostCheck() error = %q, should contain %q", errMsg, tt.errContains)
	238	+	}
	239	+	}
	240	+	})
	241	+	}
	242	+	}
	243	+
	244	+	// TestBootPhaseRollback tests boot phase rollback
	245	+	func TestBootPhaseRollback(t *testing.T) {
	246	+	tests := []struct {
	247	+	name string
	248	+	setupMocks func(*mocks.MockFileSystem)
	249	+	wantErr bool
	250	+	}{
	251	+	{
	252	+	name: "Rollback success",
	253	+	setupMocks: func(mockFS *mocks.MockFileSystem) {
	254	+	mockFS.EXPECT().RemoveAll(config.PathMntBootEFILimine).Return(nil).Times(1)
	255	+	},
	256	+	wantErr: false,
	257	+	},
	258	+	{
	259	+	name: "Rollback with directory removal failure - continues",
	260	+	setupMocks: func(mockFS *mocks.MockFileSystem) {
	261	+	mockFS.EXPECT().RemoveAll(config.PathMntBootEFILimine).Return(fmt.Errorf("permission denied")).Times(1)
	262	+	},
	263	+	wantErr: false, // Rollback doesn't fail on removal errors
	264	+	},
	265	+	}
	266	+
	267	+	for _, tt := range tests {
	268	+	t.Run(tt.name, func(t *testing.T) {
	269	+	ctrl := gomock.NewController(t)
	270	+	defer ctrl.Finish()
	271	+
	272	+	mockFS := mocks.NewMockFileSystem(ctrl)
	273	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	274	+	mockChrExec := mocks.NewMockChrootExecutor(ctrl)
	275	+
	276	+	tt.setupMocks(mockFS)
	277	+
	278	+	tmpDir := t.TempDir()
	279	+	logPath := filepath.Join(tmpDir, "test.log")
	280	+	log, err := logger.New(logPath, false)
	281	+	if err != nil {
	282	+	t.Fatalf("Failed to create logger: %v", err)
	283	+	}
	284	+	defer log.Close()
	285	+
	286	+	cfg := config.NewConfig("test")
	287	+	phase := NewBootPhase(cfg, log, mockFS, mockSysExec, mockChrExec)
	288	+
	289	+	err = phase.Rollback()
	290	+	if (err != nil) != tt.wantErr {
	291	+	t.Errorf("Rollback() error = %v, wantErr %v", err, tt.wantErr)
	292	+	}
	293	+	})
	294	+	}
	295	+	}
	296	+
	297	+	// TestBootPhaseCanSkip tests the CanSkip method
	298	+	func TestBootPhaseCanSkip(t *testing.T) {
	299	+	ctrl := gomock.NewController(t)
	300	+	defer ctrl.Finish()
	301	+
	302	+	mockFS := mocks.NewMockFileSystem(ctrl)
	303	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	304	+	mockChrExec := mocks.NewMockChrootExecutor(ctrl)
	305	+
	306	+	tmpDir := t.TempDir()
	307	+	logPath := filepath.Join(tmpDir, "test.log")
	308	+	log, err := logger.New(logPath, false)
	309	+	if err != nil {
	310	+	t.Fatalf("Failed to create logger: %v", err)
	311	+	}
	312	+	defer log.Close()
	313	+
	314	+	cfg := config.NewConfig("test")
	315	+	phase := NewBootPhase(cfg, log, mockFS, mockSysExec, mockChrExec)
	316	+
	317	+	if phase.CanSkip() {
	318	+	t.Error("CanSkip() = true, want false")
	319	+	}
	320	+	}
	321	+
	322	+	// TestBootPhaseExecute tests the Execute method structure
	323	+	func TestBootPhaseExecute(t *testing.T) {
	324	+	ctrl := gomock.NewController(t)
	325	+	defer ctrl.Finish()
	326	+
	327	+	mockFS := mocks.NewMockFileSystem(ctrl)
	328	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	329	+	mockChrExec := mocks.NewMockChrootExecutor(ctrl)
	330	+
	331	+	// Allow any file system operations since Execute calls various methods
	332	+	mockFS.EXPECT().ReadFile(gomock.Any()).Return([]byte{}, nil).AnyTimes()
	333	+	mockFS.EXPECT().WriteFile(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
	334	+	mockFS.EXPECT().MkdirAll(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
	335	+	mockChrExec.EXPECT().ChrootExec(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
	336	+	mockSysExec.EXPECT().RunSimple(gomock.Any(), gomock.Any(), gomock.Any()).Return(system.CommandResult{Output: "1234-5678"}).AnyTimes()
	337	+
	338	+	tmpDir := t.TempDir()
	339	+	logPath := filepath.Join(tmpDir, "test.log")
	340	+	log, err := logger.New(logPath, false)
	341	+	if err != nil {
	342	+	t.Fatalf("Failed to create logger: %v", err)
	343	+	}
	344	+	defer log.Close()
	345	+
	346	+	cfg := config.NewConfig("test")
	347	+	cfg.TargetDisk = "/dev/sda"
	348	+	cfg.EFIPartition = "/dev/sda1"
	349	+	cfg.RootPartition = "/dev/sda2"
	350	+	cfg.KernelChoice = "linux"
	351	+
	352	+	phase := NewBootPhase(cfg, log, mockFS, mockSysExec, mockChrExec)
	353	+
	354	+	progressChan := make(chan ProgressUpdate, 100)
	355	+
	356	+	// Note: Full Execute testing is complex due to logger.ExecCommand() and various file system calls
	357	+	// We just verify that Execute returns a PhaseResult
	358	+	result := phase.Execute(progressChan)
	359	+
	360	+	// Verify result type is correct - either success or error, the structure is valid
	361	+	_ = result // If we got here, Execute returned a valid result structure
	362	+	}
	363	+
	364	+	// TestBootPhaseKernelParameterConstruction tests kernel parameter building
	365	+	func TestBootPhaseKernelParameterConstruction(t *testing.T) {
	366	+	tests := []struct {
	367	+	name string
	368	+	encryptionType string
	369	+	rootUUID string
	370	+	expectedParams string // partial match check
	371	+	}{
	372	+	{
	373	+	name: "Unencrypted root",
	374	+	encryptionType: config.EncryptionNone,
	375	+	rootUUID: "1234-5678",
	376	+	expectedParams: "root=UUID=1234-5678",
	377	+	},
	378	+	{
	379	+	name: "LUKS encrypted root",
	380	+	encryptionType: config.EncryptionLUKS,
	381	+	rootUUID: "1234-5678",
	382	+	expectedParams: "cryptdevice=UUID=1234-5678:cryptroot",
	383	+	},
	384	+	{
	385	+	name: "LUKS+LVM encrypted root",
	386	+	encryptionType: config.EncryptionLUKSLVM,
	387	+	rootUUID: "1234-5678",
	388	+	expectedParams: "cryptdevice=UUID=1234-5678:cryptroot",
	389	+	},
	390	+	}
	391	+
	392	+	for _, tt := range tests {
	393	+	t.Run(tt.name, func(t *testing.T) {
	394	+	ctrl := gomock.NewController(t)
	395	+	defer ctrl.Finish()
	396	+
	397	+	mockFS := mocks.NewMockFileSystem(ctrl)
	398	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	399	+	mockChrExec := mocks.NewMockChrootExecutor(ctrl)
	400	+
	401	+	tmpDir := t.TempDir()
	402	+	logPath := filepath.Join(tmpDir, "test.log")
	403	+	log, err := logger.New(logPath, false)
	404	+	if err != nil {
	405	+	t.Fatalf("Failed to create logger: %v", err)
	406	+	}
	407	+	defer log.Close()
	408	+
	409	+	cfg := config.NewConfig("test")
	410	+	cfg.EncryptionType = tt.encryptionType
	411	+	cfg.RootPartition = "/dev/sda2"
	412	+
	413	+	phase := NewBootPhase(cfg, log, mockFS, mockSysExec, mockChrExec)
	414	+
	415	+	// Verify encryption type is stored correctly
	416	+	if phase.config.EncryptionType != tt.encryptionType {
	417	+	t.Errorf("Encryption type = %q, want %q", phase.config.EncryptionType, tt.encryptionType)
	418	+	}
	419	+	})
	420	+	}
	421	+	}
	422	+
	423	+	// TestBootPhaseInstallPathConstruction tests install path building
	424	+	func TestBootPhaseInstallPathConstruction(t *testing.T) {
	425	+	tests := []struct {
	426	+	name string
	427	+	filename string
	428	+	expected string
	429	+	}{
	430	+	{
	431	+	name: "Limine config template",
	432	+	filename: config.LimineConfigTemplate,
	433	+	expected: filepath.Join(config.DefaultInstallDir, config.LimineConfigTemplate),
	434	+	},
	435	+	{
	436	+	name: "Custom filename",
	437	+	filename: "test.conf",
	438	+	expected: filepath.Join(config.DefaultInstallDir, "test.conf"),
	439	+	},
	440	+	}
	441	+
	442	+	for _, tt := range tests {
	443	+	t.Run(tt.name, func(t *testing.T) {
	444	+	ctrl := gomock.NewController(t)
	445	+	defer ctrl.Finish()
	446	+
	447	+	mockFS := mocks.NewMockFileSystem(ctrl)
	448	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	449	+	mockChrExec := mocks.NewMockChrootExecutor(ctrl)
	450	+
	451	+	tmpDir := t.TempDir()
	452	+	logPath := filepath.Join(tmpDir, "test.log")
	453	+	log, err := logger.New(logPath, false)
	454	+	if err != nil {
	455	+	t.Fatalf("Failed to create logger: %v", err)
	456	+	}
	457	+	defer log.Close()
	458	+
	459	+	cfg := config.NewConfig("test")
	460	+	phase := NewBootPhase(cfg, log, mockFS, mockSysExec, mockChrExec)
	461	+
	462	+	result := phase.getInstallPath(tt.filename)
	463	+	if result != tt.expected {
	464	+	t.Errorf("getInstallPath(%q) = %q, want %q", tt.filename, result, tt.expected)
	465	+	}
	466	+	})
	467	+	}
	468	+	}
	469	+
	470	+	// TestBootPhaseFileSystemOperations tests file system interaction patterns
	471	+	func TestBootPhaseFileSystemOperations(t *testing.T) {
	472	+	tests := []struct {
	473	+	name string
	474	+	operation string // "read", "write", "mkdir"
	475	+	}{
	476	+	{
	477	+	name: "Mkinitcpio config read",
	478	+	operation: "read",
	479	+	},
	480	+	{
	481	+	name: "Limine config write",
	482	+	operation: "write",
	483	+	},
	484	+	{
	485	+	name: "Create Limine directory",
	486	+	operation: "mkdir",
	487	+	},
	488	+	}
	489	+
	490	+	for _, tt := range tests {
	491	+	t.Run(tt.name, func(t *testing.T) {
	492	+	ctrl := gomock.NewController(t)
	493	+	defer ctrl.Finish()
	494	+
	495	+	mockFS := mocks.NewMockFileSystem(ctrl)
	496	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	497	+	mockChrExec := mocks.NewMockChrootExecutor(ctrl)
	498	+
	499	+	// Setup basic expectations based on operation
	500	+	switch tt.operation {
	501	+	case "read":
	502	+	mockFS.EXPECT().ReadFile(gomock.Any()).Return([]byte("content"), nil).AnyTimes()
	503	+	case "write":
	504	+	mockFS.EXPECT().WriteFile(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
	505	+	case "mkdir":
	506	+	mockFS.EXPECT().MkdirAll(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
	507	+	}
	508	+
	509	+	tmpDir := t.TempDir()
	510	+	logPath := filepath.Join(tmpDir, "test.log")
	511	+	log, err := logger.New(logPath, false)
	512	+	if err != nil {
	513	+	t.Fatalf("Failed to create logger: %v", err)
	514	+	}
	515	+	defer log.Close()
	516	+
	517	+	cfg := config.NewConfig("test")
	518	+	phase := NewBootPhase(cfg, log, mockFS, mockSysExec, mockChrExec)
	519	+
	520	+	// Verify phase can be created
	521	+	if phase == nil {
	522	+	t.Error("BootPhase is nil")
	523	+	}
	524	+	})
	525	+	}
	526	+	}

M internal/phases/bootstrap.go +13 -9

 	"fmt"
 	"io"
 	"net/http"
-	"os"
 	"path/filepath"
 	"github.com/bnema/archup/internal/config"
+	"github.com/bnema/archup/internal/interfaces"
 	"github.com/bnema/archup/internal/logger"
 )
 // BootstrapPhase handles initial setup and file downloads
 type BootstrapPhase struct {
 	*BasePhase
+	httpClient interfaces.HTTPClient
+	fs         interfaces.FileSystem
 }
 // NewBootstrapPhase creates a new bootstrap phase
-func NewBootstrapPhase(cfg *config.Config, log *logger.Logger) *BootstrapPhase {
+func NewBootstrapPhase(cfg *config.Config, log *logger.Logger, httpClient interfaces.HTTPClient, fs interfaces.FileSystem) *BootstrapPhase {
 	return &BootstrapPhase{
-		BasePhase: NewBasePhase("bootstrap", "Bootstrap", cfg, log),
+		BasePhase:  NewBasePhase("bootstrap", "Bootstrap", cfg, log),
+		httpClient: httpClient,
+		fs:         fs,
 	}
 }
 // PreCheck validates bootstrap prerequisites
 func (p *BootstrapPhase) PreCheck() error {
 	// Check internet connectivity
-	resp, err := http.Get("https://raw.githubusercontent.com")
+	resp, err := p.httpClient.Get("https://raw.githubusercontent.com")
 	switch {
 	case err != nil:
 		return fmt.Errorf("no internet connectivity: %w", err)
 	p.SendOutput(progressChan, "Starting bootstrap phase...")
 	// Create install directory
-	switch err := os.MkdirAll(config.DefaultInstallDir, 0755); {
+	switch err := p.fs.MkdirAll(config.DefaultInstallDir, 0755); {
 	case err != nil:
 		p.SendError(progressChan, err)
 		return PhaseResult{Success: false, Error: err}
 func (p *BootstrapPhase) downloadFile(url, destPath string) error {
 	// Create destination directory if needed
 	destDir := filepath.Dir(destPath)
-	switch err := os.MkdirAll(destDir, 0755); {
+	switch err := p.fs.MkdirAll(destDir, 0755); {
 	case err != nil:
 		return fmt.Errorf("failed to create directory: %w", err)
 	}
 	// Download file
-	resp, err := http.Get(url)
+	resp, err := p.httpClient.Get(url)
 	switch {
 	case err != nil:
 		return fmt.Errorf("HTTP request failed: %w", err)
 	}
 	// Create destination file
-	destFile, err := os.Create(destPath)
+	destFile, err := p.fs.Create(destPath)
 	switch {
 	case err != nil:
 		return fmt.Errorf("failed to create file: %w", err)
 // Rollback removes downloaded files
 func (p *BootstrapPhase) Rollback() error {
 	// Remove install directory
-	switch err := os.RemoveAll(config.DefaultInstallDir); {
+	switch err := p.fs.RemoveAll(config.DefaultInstallDir); {
 	case err != nil:
 		return fmt.Errorf("failed to remove install directory: %w", err)
 	}

M internal/phases/bootstrap_test.go +1 -9


@@ -346,12 +346,4 @@ func (m *MockWriteCloser) Close() error {
346		return nil	346		return nil
347		}	347		}
348			348
349	-	// containsSubstring helper function (also defined in preflight_test.go)	349	+	// containsSubstring is defined in helpers_test.go to avoid duplication
350	-	func containsSubstring(s, substr string) bool {
351	-	for i := 0; i < len(s)-len(substr)+1; i++ {
352	-	if s[i:i+len(substr)] == substr {
353	-	return true
354	-	}
355	-	}
356	-	return false
357	-	}

A internal/phases/mocks/mock_phase.go +381 -0

@@ -0,0 +1,381 @@
	1	+	// Code generated by MockGen. DO NOT EDIT.
	2	+	// Source: internal/phases/phase.go
	3	+	//
	4	+	// Generated by this command:
	5	+	//
	6	+	// mockgen -source=internal/phases/phase.go -destination=internal/phases/mocks/mock_phase.go -package=mocks -typed -self_package=github.com/bnema/archup/internal/phases
	7	+	//
	8	+
	9	+	// Package mocks is a generated GoMock package.
	10	+	package mocks
	11	+
	12	+	import (
	13	+	reflect "reflect"
	14	+
	15	+	phases "github.com/bnema/archup/internal/phases"
	16	+	gomock "go.uber.org/mock/gomock"
	17	+	)
	18	+
	19	+	// MockPhase is a mock of Phase interface.
	20	+	type MockPhase struct {
	21	+	ctrl *gomock.Controller
	22	+	recorder *MockPhaseMockRecorder
	23	+	isgomock struct{}
	24	+	}
	25	+
	26	+	// MockPhaseMockRecorder is the mock recorder for MockPhase.
	27	+	type MockPhaseMockRecorder struct {
	28	+	mock *MockPhase
	29	+	}
	30	+
	31	+	// NewMockPhase creates a new mock instance.
	32	+	func NewMockPhase(ctrl gomock.Controller) MockPhase {
	33	+	mock := &MockPhase{ctrl: ctrl}
	34	+	mock.recorder = &MockPhaseMockRecorder{mock}
	35	+	return mock
	36	+	}
	37	+
	38	+	// EXPECT returns an object that allows the caller to indicate expected use.
	39	+	func (m MockPhase) EXPECT() MockPhaseMockRecorder {
	40	+	return m.recorder
	41	+	}
	42	+
	43	+	// CanSkip mocks base method.
	44	+	func (m *MockPhase) CanSkip() bool {
	45	+	m.ctrl.T.Helper()
	46	+	ret := m.ctrl.Call(m, "CanSkip")
	47	+	ret0, _ := ret[0].(bool)
	48	+	return ret0
	49	+	}
	50	+
	51	+	// CanSkip indicates an expected call of CanSkip.
	52	+	func (mr MockPhaseMockRecorder) CanSkip() MockPhaseCanSkipCall {
	53	+	mr.mock.ctrl.T.Helper()
	54	+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CanSkip", reflect.TypeOf((*MockPhase)(nil).CanSkip))
	55	+	return &MockPhaseCanSkipCall{Call: call}
	56	+	}
	57	+
	58	+	// MockPhaseCanSkipCall wrap *gomock.Call
	59	+	type MockPhaseCanSkipCall struct {
	60	+	*gomock.Call
	61	+	}
	62	+
	63	+	// Return rewrite *gomock.Call.Return
	64	+	func (c MockPhaseCanSkipCall) Return(arg0 bool) MockPhaseCanSkipCall {
	65	+	c.Call = c.Call.Return(arg0)
	66	+	return c
	67	+	}
	68	+
	69	+	// Do rewrite *gomock.Call.Do
	70	+	func (c MockPhaseCanSkipCall) Do(f func() bool) MockPhaseCanSkipCall {
	71	+	c.Call = c.Call.Do(f)
	72	+	return c
	73	+	}
	74	+
	75	+	// DoAndReturn rewrite *gomock.Call.DoAndReturn
	76	+	func (c MockPhaseCanSkipCall) DoAndReturn(f func() bool) MockPhaseCanSkipCall {
	77	+	c.Call = c.Call.DoAndReturn(f)
	78	+	return c
	79	+	}
	80	+
	81	+	// Description mocks base method.
	82	+	func (m *MockPhase) Description() string {
	83	+	m.ctrl.T.Helper()
	84	+	ret := m.ctrl.Call(m, "Description")
	85	+	ret0, _ := ret[0].(string)
	86	+	return ret0
	87	+	}
	88	+
	89	+	// Description indicates an expected call of Description.
	90	+	func (mr MockPhaseMockRecorder) Description() MockPhaseDescriptionCall {
	91	+	mr.mock.ctrl.T.Helper()
	92	+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Description", reflect.TypeOf((*MockPhase)(nil).Description))
	93	+	return &MockPhaseDescriptionCall{Call: call}
	94	+	}
	95	+
	96	+	// MockPhaseDescriptionCall wrap *gomock.Call
	97	+	type MockPhaseDescriptionCall struct {
	98	+	*gomock.Call
	99	+	}
	100	+
	101	+	// Return rewrite *gomock.Call.Return
	102	+	func (c MockPhaseDescriptionCall) Return(arg0 string) MockPhaseDescriptionCall {
	103	+	c.Call = c.Call.Return(arg0)
	104	+	return c
	105	+	}
	106	+
	107	+	// Do rewrite *gomock.Call.Do
	108	+	func (c MockPhaseDescriptionCall) Do(f func() string) MockPhaseDescriptionCall {
	109	+	c.Call = c.Call.Do(f)
	110	+	return c
	111	+	}
	112	+
	113	+	// DoAndReturn rewrite *gomock.Call.DoAndReturn
	114	+	func (c MockPhaseDescriptionCall) DoAndReturn(f func() string) MockPhaseDescriptionCall {
	115	+	c.Call = c.Call.DoAndReturn(f)
	116	+	return c
	117	+	}
	118	+
	119	+	// Execute mocks base method.
	120	+	func (m *MockPhase) Execute(progressChan chan<- phases.ProgressUpdate) phases.PhaseResult {
	121	+	m.ctrl.T.Helper()
	122	+	ret := m.ctrl.Call(m, "Execute", progressChan)
	123	+	ret0, _ := ret[0].(phases.PhaseResult)
	124	+	return ret0
	125	+	}
	126	+
	127	+	// Execute indicates an expected call of Execute.
	128	+	func (mr MockPhaseMockRecorder) Execute(progressChan any) MockPhaseExecuteCall {
	129	+	mr.mock.ctrl.T.Helper()
	130	+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Execute", reflect.TypeOf((*MockPhase)(nil).Execute), progressChan)
	131	+	return &MockPhaseExecuteCall{Call: call}
	132	+	}
	133	+
	134	+	// MockPhaseExecuteCall wrap *gomock.Call
	135	+	type MockPhaseExecuteCall struct {
	136	+	*gomock.Call
	137	+	}
	138	+
	139	+	// Return rewrite *gomock.Call.Return
	140	+	func (c MockPhaseExecuteCall) Return(arg0 phases.PhaseResult) MockPhaseExecuteCall {
	141	+	c.Call = c.Call.Return(arg0)
	142	+	return c
	143	+	}
	144	+
	145	+	// Do rewrite *gomock.Call.Do
	146	+	func (c MockPhaseExecuteCall) Do(f func(chan<- phases.ProgressUpdate) phases.PhaseResult) MockPhaseExecuteCall {
	147	+	c.Call = c.Call.Do(f)
	148	+	return c
	149	+	}
	150	+
	151	+	// DoAndReturn rewrite *gomock.Call.DoAndReturn
	152	+	func (c MockPhaseExecuteCall) DoAndReturn(f func(chan<- phases.ProgressUpdate) phases.PhaseResult) MockPhaseExecuteCall {
	153	+	c.Call = c.Call.DoAndReturn(f)
	154	+	return c
	155	+	}
	156	+
	157	+	// Name mocks base method.
	158	+	func (m *MockPhase) Name() string {
	159	+	m.ctrl.T.Helper()
	160	+	ret := m.ctrl.Call(m, "Name")
	161	+	ret0, _ := ret[0].(string)
	162	+	return ret0
	163	+	}
	164	+
	165	+	// Name indicates an expected call of Name.
	166	+	func (mr MockPhaseMockRecorder) Name() MockPhaseNameCall {
	167	+	mr.mock.ctrl.T.Helper()
	168	+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockPhase)(nil).Name))
	169	+	return &MockPhaseNameCall{Call: call}
	170	+	}
	171	+
	172	+	// MockPhaseNameCall wrap *gomock.Call
	173	+	type MockPhaseNameCall struct {
	174	+	*gomock.Call
	175	+	}
	176	+
	177	+	// Return rewrite *gomock.Call.Return
	178	+	func (c MockPhaseNameCall) Return(arg0 string) MockPhaseNameCall {
	179	+	c.Call = c.Call.Return(arg0)
	180	+	return c
	181	+	}
	182	+
	183	+	// Do rewrite *gomock.Call.Do
	184	+	func (c MockPhaseNameCall) Do(f func() string) MockPhaseNameCall {
	185	+	c.Call = c.Call.Do(f)
	186	+	return c
	187	+	}
	188	+
	189	+	// DoAndReturn rewrite *gomock.Call.DoAndReturn
	190	+	func (c MockPhaseNameCall) DoAndReturn(f func() string) MockPhaseNameCall {
	191	+	c.Call = c.Call.DoAndReturn(f)
	192	+	return c
	193	+	}
	194	+
	195	+	// PostCheck mocks base method.
	196	+	func (m *MockPhase) PostCheck() error {
	197	+	m.ctrl.T.Helper()
	198	+	ret := m.ctrl.Call(m, "PostCheck")
	199	+	ret0, _ := ret[0].(error)
	200	+	return ret0
	201	+	}
	202	+
	203	+	// PostCheck indicates an expected call of PostCheck.
	204	+	func (mr MockPhaseMockRecorder) PostCheck() MockPhasePostCheckCall {
	205	+	mr.mock.ctrl.T.Helper()
	206	+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostCheck", reflect.TypeOf((*MockPhase)(nil).PostCheck))
	207	+	return &MockPhasePostCheckCall{Call: call}
	208	+	}
	209	+
	210	+	// MockPhasePostCheckCall wrap *gomock.Call
	211	+	type MockPhasePostCheckCall struct {
	212	+	*gomock.Call
	213	+	}
	214	+
	215	+	// Return rewrite *gomock.Call.Return
	216	+	func (c MockPhasePostCheckCall) Return(arg0 error) MockPhasePostCheckCall {
	217	+	c.Call = c.Call.Return(arg0)
	218	+	return c
	219	+	}
	220	+
	221	+	// Do rewrite *gomock.Call.Do
	222	+	func (c MockPhasePostCheckCall) Do(f func() error) MockPhasePostCheckCall {
	223	+	c.Call = c.Call.Do(f)
	224	+	return c
	225	+	}
	226	+
	227	+	// DoAndReturn rewrite *gomock.Call.DoAndReturn
	228	+	func (c MockPhasePostCheckCall) DoAndReturn(f func() error) MockPhasePostCheckCall {
	229	+	c.Call = c.Call.DoAndReturn(f)
	230	+	return c
	231	+	}
	232	+
	233	+	// PreCheck mocks base method.
	234	+	func (m *MockPhase) PreCheck() error {
	235	+	m.ctrl.T.Helper()
	236	+	ret := m.ctrl.Call(m, "PreCheck")
	237	+	ret0, _ := ret[0].(error)
	238	+	return ret0
	239	+	}
	240	+
	241	+	// PreCheck indicates an expected call of PreCheck.
	242	+	func (mr MockPhaseMockRecorder) PreCheck() MockPhasePreCheckCall {
	243	+	mr.mock.ctrl.T.Helper()
	244	+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreCheck", reflect.TypeOf((*MockPhase)(nil).PreCheck))
	245	+	return &MockPhasePreCheckCall{Call: call}
	246	+	}
	247	+
	248	+	// MockPhasePreCheckCall wrap *gomock.Call
	249	+	type MockPhasePreCheckCall struct {
	250	+	*gomock.Call
	251	+	}
	252	+
	253	+	// Return rewrite *gomock.Call.Return
	254	+	func (c MockPhasePreCheckCall) Return(arg0 error) MockPhasePreCheckCall {
	255	+	c.Call = c.Call.Return(arg0)
	256	+	return c
	257	+	}
	258	+
	259	+	// Do rewrite *gomock.Call.Do
	260	+	func (c MockPhasePreCheckCall) Do(f func() error) MockPhasePreCheckCall {
	261	+	c.Call = c.Call.Do(f)
	262	+	return c
	263	+	}
	264	+
	265	+	// DoAndReturn rewrite *gomock.Call.DoAndReturn
	266	+	func (c MockPhasePreCheckCall) DoAndReturn(f func() error) MockPhasePreCheckCall {
	267	+	c.Call = c.Call.DoAndReturn(f)
	268	+	return c
	269	+	}
	270	+
	271	+	// Rollback mocks base method.
	272	+	func (m *MockPhase) Rollback() error {
	273	+	m.ctrl.T.Helper()
	274	+	ret := m.ctrl.Call(m, "Rollback")
	275	+	ret0, _ := ret[0].(error)
	276	+	return ret0
	277	+	}
	278	+
	279	+	// Rollback indicates an expected call of Rollback.
	280	+	func (mr MockPhaseMockRecorder) Rollback() MockPhaseRollbackCall {
	281	+	mr.mock.ctrl.T.Helper()
	282	+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rollback", reflect.TypeOf((*MockPhase)(nil).Rollback))
	283	+	return &MockPhaseRollbackCall{Call: call}
	284	+	}
	285	+
	286	+	// MockPhaseRollbackCall wrap *gomock.Call
	287	+	type MockPhaseRollbackCall struct {
	288	+	*gomock.Call
	289	+	}
	290	+
	291	+	// Return rewrite *gomock.Call.Return
	292	+	func (c MockPhaseRollbackCall) Return(arg0 error) MockPhaseRollbackCall {
	293	+	c.Call = c.Call.Return(arg0)
	294	+	return c
	295	+	}
	296	+
	297	+	// Do rewrite *gomock.Call.Do
	298	+	func (c MockPhaseRollbackCall) Do(f func() error) MockPhaseRollbackCall {
	299	+	c.Call = c.Call.Do(f)
	300	+	return c
	301	+	}
	302	+
	303	+	// DoAndReturn rewrite *gomock.Call.DoAndReturn
	304	+	func (c MockPhaseRollbackCall) DoAndReturn(f func() error) MockPhaseRollbackCall {
	305	+	c.Call = c.Call.DoAndReturn(f)
	306	+	return c
	307	+	}
	308	+
	309	+	// SetStatus mocks base method.
	310	+	func (m *MockPhase) SetStatus(status phases.PhaseStatus) {
	311	+	m.ctrl.T.Helper()
	312	+	m.ctrl.Call(m, "SetStatus", status)
	313	+	}
	314	+
	315	+	// SetStatus indicates an expected call of SetStatus.
	316	+	func (mr MockPhaseMockRecorder) SetStatus(status any) MockPhaseSetStatusCall {
	317	+	mr.mock.ctrl.T.Helper()
	318	+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStatus", reflect.TypeOf((*MockPhase)(nil).SetStatus), status)
	319	+	return &MockPhaseSetStatusCall{Call: call}
	320	+	}
	321	+
	322	+	// MockPhaseSetStatusCall wrap *gomock.Call
	323	+	type MockPhaseSetStatusCall struct {
	324	+	*gomock.Call
	325	+	}
	326	+
	327	+	// Return rewrite *gomock.Call.Return
	328	+	func (c MockPhaseSetStatusCall) Return() MockPhaseSetStatusCall {
	329	+	c.Call = c.Call.Return()
	330	+	return c
	331	+	}
	332	+
	333	+	// Do rewrite *gomock.Call.Do
	334	+	func (c MockPhaseSetStatusCall) Do(f func(phases.PhaseStatus)) MockPhaseSetStatusCall {
	335	+	c.Call = c.Call.Do(f)
	336	+	return c
	337	+	}
	338	+
	339	+	// DoAndReturn rewrite *gomock.Call.DoAndReturn
	340	+	func (c MockPhaseSetStatusCall) DoAndReturn(f func(phases.PhaseStatus)) MockPhaseSetStatusCall {
	341	+	c.Call = c.Call.DoAndReturn(f)
	342	+	return c
	343	+	}
	344	+
	345	+	// Status mocks base method.
	346	+	func (m *MockPhase) Status() phases.PhaseStatus {
	347	+	m.ctrl.T.Helper()
	348	+	ret := m.ctrl.Call(m, "Status")
	349	+	ret0, _ := ret[0].(phases.PhaseStatus)
	350	+	return ret0
	351	+	}
	352	+
	353	+	// Status indicates an expected call of Status.
	354	+	func (mr MockPhaseMockRecorder) Status() Mockphases.PhaseStatusCall {
	355	+	mr.mock.ctrl.T.Helper()
	356	+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockPhase)(nil).Status))
	357	+	return &Mockphases.PhaseStatusCall{Call: call}
	358	+	}
	359	+
	360	+	// Mockphases.PhaseStatusCall wrap *gomock.Call
	361	+	type Mockphases.PhaseStatusCall struct {
	362	+	*gomock.Call
	363	+	}
	364	+
	365	+	// Return rewrite *gomock.Call.Return
	366	+	func (c Mockphases.PhaseStatusCall) Return(arg0 phases.PhaseStatus) Mockphases.PhaseStatusCall {
	367	+	c.Call = c.Call.Return(arg0)
	368	+	return c
	369	+	}
	370	+
	371	+	// Do rewrite *gomock.Call.Do
	372	+	func (c Mockphases.PhaseStatusCall) Do(f func() phases.PhaseStatus) Mockphases.PhaseStatusCall {
	373	+	c.Call = c.Call.Do(f)
	374	+	return c
	375	+	}
	376	+
	377	+	// DoAndReturn rewrite *gomock.Call.DoAndReturn
	378	+	func (c Mockphases.PhaseStatusCall) DoAndReturn(f func() phases.PhaseStatus) Mockphases.PhaseStatusCall {
	379	+	c.Call = c.Call.DoAndReturn(f)
	380	+	return c
	381	+	}

A internal/phases/orchestrator_test.go +545 -0

@@ -0,0 +1,545 @@
	1	+	package phases
	2	+
	3	+	import (
	4	+	"fmt"
	5	+	"testing"
	6	+
	7	+	"github.com/bnema/archup/internal/config"
	8	+	)
	9	+
	10	+	// testPhase is a simple Phase implementation for testing orchestrator
	11	+	type testPhase struct {
	12	+	*BasePhase
	13	+	preCheckErr error
	14	+	executeErr error
	15	+	postCheckErr error
	16	+	rollbackErr error
	17	+	canSkip bool
	18	+	}
	19	+
	20	+	func newTestPhase(name string, cfg config.Config) testPhase {
	21	+	return &testPhase{
	22	+	BasePhase: NewBasePhase(name, "Test "+name, cfg, nil),
	23	+	canSkip: false,
	24	+	}
	25	+	}
	26	+
	27	+	func (p *testPhase) PreCheck() error {
	28	+	return p.preCheckErr
	29	+	}
	30	+
	31	+	func (p *testPhase) Execute(progressChan chan<- ProgressUpdate) PhaseResult {
	32	+	if p.executeErr != nil {
	33	+	return PhaseResult{
	34	+	Success: false,
	35	+	Error: p.executeErr,
	36	+	}
	37	+	}
	38	+	return PhaseResult{
	39	+	Success: true,
	40	+	Message: "completed",
	41	+	}
	42	+	}
	43	+
	44	+	func (p *testPhase) PostCheck() error {
	45	+	return p.postCheckErr
	46	+	}
	47	+
	48	+	func (p *testPhase) Rollback() error {
	49	+	return p.rollbackErr
	50	+	}
	51	+
	52	+	func (p *testPhase) CanSkip() bool {
	53	+	return p.canSkip
	54	+	}
	55	+
	56	+	// TestOrchestratorRegistration tests phase registration
	57	+	func TestOrchestratorRegistration(t *testing.T) {
	58	+	cfg := config.NewConfig("test")
	59	+	orch := NewOrchestrator(cfg, "test.log")
	60	+
	61	+	t.Run("register valid phase", func(t *testing.T) {
	62	+	phase := newTestPhase("test-phase", cfg)
	63	+	err := orch.RegisterPhase(phase)
	64	+	if err != nil {
	65	+	t.Errorf("Failed to register valid phase: %v", err)
	66	+	}
	67	+
	68	+	phases := orch.Phases()
	69	+	if len(phases) != 1 {
	70	+	t.Errorf("Expected 1 phase, got %d", len(phases))
	71	+	}
	72	+	})
	73	+
	74	+	t.Run("register nil phase", func(t *testing.T) {
	75	+	orch2 := NewOrchestrator(cfg, "test.log")
	76	+	err := orch2.RegisterPhase(nil)
	77	+	if err == nil {
	78	+	t.Error("Expected error for nil phase, got nil")
	79	+	}
	80	+	})
	81	+
	82	+	t.Run("register duplicate phase name", func(t *testing.T) {
	83	+	orch2 := NewOrchestrator(cfg, "test.log")
	84	+	phase1 := newTestPhase("duplicate", cfg)
	85	+	phase2 := newTestPhase("duplicate", cfg)
	86	+
	87	+	orch2.RegisterPhase(phase1)
	88	+	err := orch2.RegisterPhase(phase2)
	89	+	if err == nil {
	90	+	t.Error("Expected error for duplicate phase name, got nil")
	91	+	}
	92	+	})
	93	+	}
	94	+
	95	+	// TestOrchestratorCurrentPhase tests CurrentPhase navigation
	96	+	func TestOrchestratorCurrentPhase(t *testing.T) {
	97	+	cfg := config.NewConfig("test")
	98	+	orch := NewOrchestrator(cfg, "test.log")
	99	+
	100	+	phase := newTestPhase("test", cfg)
	101	+	orch.RegisterPhase(phase)
	102	+
	103	+	// Before execution, current should be nil
	104	+	if orch.CurrentPhase() != nil {
	105	+	t.Error("CurrentPhase should be nil before execution")
	106	+	}
	107	+
	108	+	// After executing, current should be set
	109	+	orch.ExecutePhase(phase)
	110	+	current := orch.CurrentPhase()
	111	+	if current == nil {
	112	+	t.Error("CurrentPhase should not be nil after execution")
	113	+	}
	114	+	if current.Name() != "test" {
	115	+	t.Errorf("CurrentPhase name = %q, want %q", current.Name(), "test")
	116	+	}
	117	+	}
	118	+
	119	+	// TestOrchestratorNextPhase tests NextPhase logic
	120	+	func TestOrchestratorNextPhase(t *testing.T) {
	121	+	cfg := config.NewConfig("test")
	122	+	orch := NewOrchestrator(cfg, "test.log")
	123	+
	124	+	phase1 := newTestPhase("phase-1", cfg)
	125	+	phase2 := newTestPhase("phase-2", cfg)
	126	+	phase3 := newTestPhase("phase-3", cfg)
	127	+
	128	+	orch.RegisterPhase(phase1)
	129	+	orch.RegisterPhase(phase2)
	130	+	orch.RegisterPhase(phase3)
	131	+
	132	+	// Next should be phase-1
	133	+	next := orch.NextPhase()
	134	+	if next == nil \|\| next.Name() != "phase-1" {
	135	+	t.Errorf("NextPhase = %v, want phase-1", next)
	136	+	}
	137	+
	138	+	// Mark phase-1 completed
	139	+	phase1.SetStatus(StatusCompleted)
	140	+
	141	+	// Next should be phase-2
	142	+	next = orch.NextPhase()
	143	+	if next == nil \|\| next.Name() != "phase-2" {
	144	+	t.Errorf("NextPhase = %v, want phase-2", next)
	145	+	}
	146	+
	147	+	// Mark phase-2 skipped
	148	+	phase2.SetStatus(StatusSkipped)
	149	+
	150	+	// Next should be phase-3
	151	+	next = orch.NextPhase()
	152	+	if next == nil \|\| next.Name() != "phase-3" {
	153	+	t.Errorf("NextPhase = %v, want phase-3", next)
	154	+	}
	155	+
	156	+	// Mark all done
	157	+	phase3.SetStatus(StatusCompleted)
	158	+
	159	+	// Next should be nil
	160	+	next = orch.NextPhase()
	161	+	if next != nil {
	162	+	t.Errorf("NextPhase = %v, want nil when all done", next)
	163	+	}
	164	+	}
	165	+
	166	+	// TestOrchestratorExecutePhaseSuccess tests successful phase execution
	167	+	func TestOrchestratorExecutePhaseSuccess(t *testing.T) {
	168	+	cfg := config.NewConfig("test")
	169	+	orch := NewOrchestrator(cfg, "test.log")
	170	+
	171	+	phase := newTestPhase("test", cfg)
	172	+	orch.RegisterPhase(phase)
	173	+
	174	+	err := orch.ExecutePhase(phase)
	175	+	if err != nil {
	176	+	t.Errorf("ExecutePhase failed: %v", err)
	177	+	}
	178	+
	179	+	if phase.Status() != StatusCompleted {
	180	+	t.Errorf("Status = %v, want %v", phase.Status(), StatusCompleted)
	181	+	}
	182	+	}
	183	+
	184	+	// TestOrchestratorExecutePhasePreCheckFails tests PreCheck failure
	185	+	func TestOrchestratorExecutePhasePreCheckFails(t *testing.T) {
	186	+	cfg := config.NewConfig("test")
	187	+	orch := NewOrchestrator(cfg, "test.log")
	188	+
	189	+	phase := newTestPhase("test", cfg)
	190	+	phase.preCheckErr = fmt.Errorf("precondition failed")
	191	+	orch.RegisterPhase(phase)
	192	+
	193	+	err := orch.ExecutePhase(phase)
	194	+	if err == nil {
	195	+	t.Error("Expected error from failed PreCheck")
	196	+	}
	197	+
	198	+	if phase.Status() != StatusFailed {
	199	+	t.Errorf("Status = %v, want %v", phase.Status(), StatusFailed)
	200	+	}
	201	+	}
	202	+
	203	+	// TestOrchestratorExecutePhaseExecuteFails tests Execute failure with Rollback
	204	+	func TestOrchestratorExecutePhaseExecuteFails(t *testing.T) {
	205	+	cfg := config.NewConfig("test")
	206	+	orch := NewOrchestrator(cfg, "test.log")
	207	+
	208	+	phase := newTestPhase("test", cfg)
	209	+	phase.executeErr = fmt.Errorf("execution failed")
	210	+	orch.RegisterPhase(phase)
	211	+
	212	+	err := orch.ExecutePhase(phase)
	213	+	if err == nil {
	214	+	t.Error("Expected error from failed Execute")
	215	+	}
	216	+
	217	+	if phase.Status() != StatusFailed {
	218	+	t.Errorf("Status = %v, want %v", phase.Status(), StatusFailed)
	219	+	}
	220	+	}
	221	+
	222	+	// TestOrchestratorExecutePhaseRollbackFails tests Rollback failure
	223	+	func TestOrchestratorExecutePhaseRollbackFails(t *testing.T) {
	224	+	cfg := config.NewConfig("test")
	225	+	orch := NewOrchestrator(cfg, "test.log")
	226	+
	227	+	phase := newTestPhase("test", cfg)
	228	+	phase.executeErr = fmt.Errorf("execution failed")
	229	+	phase.rollbackErr = fmt.Errorf("rollback also failed")
	230	+	orch.RegisterPhase(phase)
	231	+
	232	+	err := orch.ExecutePhase(phase)
	233	+	if err == nil {
	234	+	t.Error("Expected error from failed Rollback")
	235	+	}
	236	+
	237	+	if phase.Status() != StatusFailed {
	238	+	t.Errorf("Status = %v, want %v", phase.Status(), StatusFailed)
	239	+	}
	240	+	}
	241	+
	242	+	// TestOrchestratorExecutePhasePostCheckFails tests PostCheck failure
	243	+	func TestOrchestratorExecutePhasePostCheckFails(t *testing.T) {
	244	+	cfg := config.NewConfig("test")
	245	+	orch := NewOrchestrator(cfg, "test.log")
	246	+
	247	+	phase := newTestPhase("test", cfg)
	248	+	phase.postCheckErr = fmt.Errorf("validation failed")
	249	+	orch.RegisterPhase(phase)
	250	+
	251	+	err := orch.ExecutePhase(phase)
	252	+	if err == nil {
	253	+	t.Error("Expected error from failed PostCheck")
	254	+	}
	255	+
	256	+	if phase.Status() != StatusFailed {
	257	+	t.Errorf("Status = %v, want %v", phase.Status(), StatusFailed)
	258	+	}
	259	+	}
	260	+
	261	+	// TestOrchestratorSkipPhase tests skipping phases
	262	+	func TestOrchestratorSkipPhase(t *testing.T) {
	263	+	cfg := config.NewConfig("test")
	264	+	orch := NewOrchestrator(cfg, "test.log")
	265	+
	266	+	t.Run("skip skippable phase", func(t *testing.T) {
	267	+	phase := newTestPhase("skippable", cfg)
	268	+	phase.canSkip = true
	269	+	orch.RegisterPhase(phase)
	270	+
	271	+	err := orch.SkipPhase(phase)
	272	+	if err != nil {
	273	+	t.Errorf("SkipPhase failed: %v", err)
	274	+	}
	275	+
	276	+	if phase.Status() != StatusSkipped {
	277	+	t.Errorf("Status = %v, want %v", phase.Status(), StatusSkipped)
	278	+	}
	279	+	})
	280	+
	281	+	t.Run("skip non-skippable phase", func(t *testing.T) {
	282	+	orch2 := NewOrchestrator(cfg, "test.log")
	283	+	phase := newTestPhase("non-skippable", cfg)
	284	+	phase.canSkip = false
	285	+	orch2.RegisterPhase(phase)
	286	+
	287	+	err := orch2.SkipPhase(phase)
	288	+	if err == nil {
	289	+	t.Error("Expected error when skipping non-skippable phase")
	290	+	}
	291	+	})
	292	+	}
	293	+
	294	+	// TestOrchestratorProgress tests progress calculation
	295	+	func TestOrchestratorProgress(t *testing.T) {
	296	+	cfg := config.NewConfig("test")
	297	+	orch := NewOrchestrator(cfg, "test.log")
	298	+
	299	+	phase1 := newTestPhase("phase-1", cfg)
	300	+	phase2 := newTestPhase("phase-2", cfg)
	301	+	phase3 := newTestPhase("phase-3", cfg)
	302	+
	303	+	orch.RegisterPhase(phase1)
	304	+	orch.RegisterPhase(phase2)
	305	+	orch.RegisterPhase(phase3)
	306	+
	307	+	// Initially all pending
	308	+	completed, total := orch.Progress()
	309	+	if total != 3 {
	310	+	t.Errorf("Total = %d, want 3", total)
	311	+	}
	312	+	if completed != 0 {
	313	+	t.Errorf("Completed = %d, want 0", completed)
	314	+	}
	315	+
	316	+	// Mark one completed, one skipped
	317	+	phase1.SetStatus(StatusCompleted)
	318	+	phase2.SetStatus(StatusSkipped)
	319	+
	320	+	completed, total = orch.Progress()
	321	+	if completed != 2 {
	322	+	t.Errorf("Completed = %d, want 2 (completed + skipped)", completed)
	323	+	}
	324	+	}
	325	+
	326	+	// TestOrchestratorIsComplete tests completion detection
	327	+	func TestOrchestratorIsComplete(t *testing.T) {
	328	+	cfg := config.NewConfig("test")
	329	+
	330	+	t.Run("all completed", func(t *testing.T) {
	331	+	orch := NewOrchestrator(cfg, "test.log")
	332	+	phase := newTestPhase("test", cfg)
	333	+	phase.SetStatus(StatusCompleted)
	334	+	orch.RegisterPhase(phase)
	335	+
	336	+	if !orch.IsComplete() {
	337	+	t.Error("IsComplete should be true when all phases completed")
	338	+	}
	339	+	})
	340	+
	341	+	t.Run("with skipped", func(t *testing.T) {
	342	+	orch := NewOrchestrator(cfg, "test.log")
	343	+	phase := newTestPhase("test", cfg)
	344	+	phase.SetStatus(StatusSkipped)
	345	+	orch.RegisterPhase(phase)
	346	+
	347	+	if !orch.IsComplete() {
	348	+	t.Error("IsComplete should be true when all phases skipped")
	349	+	}
	350	+	})
	351	+
	352	+	t.Run("with pending", func(t *testing.T) {
	353	+	orch := NewOrchestrator(cfg, "test.log")
	354	+	phase := newTestPhase("test", cfg)
	355	+	orch.RegisterPhase(phase)
	356	+
	357	+	if orch.IsComplete() {
	358	+	t.Error("IsComplete should be false with pending phases")
	359	+	}
	360	+	})
	361	+	}
	362	+
	363	+	// TestOrchestratorHasFailed tests failure detection
	364	+	func TestOrchestratorHasFailed(t *testing.T) {
	365	+	cfg := config.NewConfig("test")
	366	+
	367	+	t.Run("no failures", func(t *testing.T) {
	368	+	orch := NewOrchestrator(cfg, "test.log")
	369	+	phase := newTestPhase("test", cfg)
	370	+	phase.SetStatus(StatusCompleted)
	371	+	orch.RegisterPhase(phase)
	372	+
	373	+	if orch.HasFailed() {
	374	+	t.Error("HasFailed should be false when no phases failed")
	375	+	}
	376	+	})
	377	+
	378	+	t.Run("with failure", func(t *testing.T) {
	379	+	orch := NewOrchestrator(cfg, "test.log")
	380	+	phase := newTestPhase("test", cfg)
	381	+	phase.SetStatus(StatusFailed)
	382	+	orch.RegisterPhase(phase)
	383	+
	384	+	if !orch.HasFailed() {
	385	+	t.Error("HasFailed should be true when phase failed")
	386	+	}
	387	+	})
	388	+	}
	389	+
	390	+	// TestOrchestratorReset tests Reset functionality
	391	+	func TestOrchestratorReset(t *testing.T) {
	392	+	cfg := config.NewConfig("test")
	393	+	orch := NewOrchestrator(cfg, "test.log")
	394	+
	395	+	phase1 := newTestPhase("phase-1", cfg)
	396	+	phase2 := newTestPhase("phase-2", cfg)
	397	+
	398	+	phase1.SetStatus(StatusCompleted)
	399	+	phase2.SetStatus(StatusFailed)
	400	+
	401	+	orch.RegisterPhase(phase1)
	402	+	orch.RegisterPhase(phase2)
	403	+
	404	+	// Execute to set currentIdx
	405	+	orch.ExecutePhase(phase1)
	406	+
	407	+	// Reset
	408	+	orch.Reset()
	409	+
	410	+	// Verify currentIdx reset
	411	+	if orch.CurrentPhase() != nil {
	412	+	t.Error("CurrentPhase should be nil after Reset")
	413	+	}
	414	+
	415	+	// Verify statuses reset
	416	+	if phase1.Status() != StatusPending {
	417	+	t.Errorf("phase1 Status = %v, want %v", phase1.Status(), StatusPending)
	418	+	}
	419	+	if phase2.Status() != StatusPending {
	420	+	t.Errorf("phase2 Status = %v, want %v", phase2.Status(), StatusPending)
	421	+	}
	422	+	}
	423	+
	424	+	// TestOrchestratorExecuteAll tests full sequence execution
	425	+	func TestOrchestratorExecuteAll(t *testing.T) {
	426	+	cfg := config.NewConfig("test")
	427	+	orch := NewOrchestrator(cfg, "test.log")
	428	+
	429	+	phase1 := newTestPhase("phase-1", cfg)
	430	+	phase2 := newTestPhase("phase-2", cfg)
	431	+	phase3 := newTestPhase("phase-3", cfg)
	432	+
	433	+	orch.RegisterPhase(phase1)
	434	+	orch.RegisterPhase(phase2)
	435	+	orch.RegisterPhase(phase3)
	436	+
	437	+	err := orch.ExecuteAll()
	438	+	if err != nil {
	439	+	t.Errorf("ExecuteAll failed: %v", err)
	440	+	}
	441	+
	442	+	// Verify all completed
	443	+	if phase1.Status() != StatusCompleted {
	444	+	t.Errorf("phase1 Status = %v, want %v", phase1.Status(), StatusCompleted)
	445	+	}
	446	+	if phase2.Status() != StatusCompleted {
	447	+	t.Errorf("phase2 Status = %v, want %v", phase2.Status(), StatusCompleted)
	448	+	}
	449	+	if phase3.Status() != StatusCompleted {
	450	+	t.Errorf("phase3 Status = %v, want %v", phase3.Status(), StatusCompleted)
	451	+	}
	452	+	}
	453	+
	454	+	// TestOrchestratorExecuteAllStopsOnFailure tests that ExecuteAll stops on first failure
	455	+	func TestOrchestratorExecuteAllStopsOnFailure(t *testing.T) {
	456	+	cfg := config.NewConfig("test")
	457	+	orch := NewOrchestrator(cfg, "test.log")
	458	+
	459	+	phase1 := newTestPhase("phase-1", cfg)
	460	+	phase2 := newTestPhase("phase-2", cfg)
	461	+	phase3 := newTestPhase("phase-3", cfg)
	462	+
	463	+	// Make phase-2 fail
	464	+	phase2.executeErr = fmt.Errorf("execution failed")
	465	+
	466	+	orch.RegisterPhase(phase1)
	467	+	orch.RegisterPhase(phase2)
	468	+	orch.RegisterPhase(phase3)
	469	+
	470	+	err := orch.ExecuteAll()
	471	+	if err == nil {
	472	+	t.Error("Expected error from ExecuteAll when phase-2 fails")
	473	+	}
	474	+
	475	+	// Verify phase-1 completed
	476	+	if phase1.Status() != StatusCompleted {
	477	+	t.Errorf("phase1 Status = %v, want %v", phase1.Status(), StatusCompleted)
	478	+	}
	479	+
	480	+	// Verify phase-2 failed
	481	+	if phase2.Status() != StatusFailed {
	482	+	t.Errorf("phase2 Status = %v, want %v", phase2.Status(), StatusFailed)
	483	+	}
	484	+
	485	+	// Verify phase-3 never executed
	486	+	if phase3.Status() != StatusPending {
	487	+	t.Errorf("phase3 Status = %v, want %v (should not execute)", phase3.Status(), StatusPending)
	488	+	}
	489	+	}
	490	+
	491	+	// TestOrchestratorExecuteNext tests ExecuteNext
	492	+	func TestOrchestratorExecuteNext(t *testing.T) {
	493	+	cfg := config.NewConfig("test")
	494	+	orch := NewOrchestrator(cfg, "test.log")
	495	+
	496	+	phase := newTestPhase("test", cfg)
	497	+	orch.RegisterPhase(phase)
	498	+
	499	+	err := orch.ExecuteNext()
	500	+	if err != nil {
	501	+	t.Errorf("ExecuteNext failed: %v", err)
	502	+	}
	503	+
	504	+	if phase.Status() != StatusCompleted {
	505	+	t.Errorf("Status = %v, want %v", phase.Status(), StatusCompleted)
	506	+	}
	507	+	}
	508	+
	509	+	// TestOrchestratorExecuteNextNoPending tests ExecuteNext with no pending phases
	510	+	func TestOrchestratorExecuteNextNoPending(t *testing.T) {
	511	+	cfg := config.NewConfig("test")
	512	+	orch := NewOrchestrator(cfg, "test.log")
	513	+
	514	+	phase := newTestPhase("test", cfg)
	515	+	phase.SetStatus(StatusCompleted)
	516	+	orch.RegisterPhase(phase)
	517	+
	518	+	err := orch.ExecuteNext()
	519	+	if err == nil {
	520	+	t.Error("Expected error when no pending phases")
	521	+	}
	522	+	}
	523	+
	524	+	// TestOrchestratorPhaseDurations tests duration tracking
	525	+	func TestOrchestratorPhaseDurations(t *testing.T) {
	526	+	cfg := config.NewConfig("test")
	527	+	orch := NewOrchestrator(cfg, "test.log")
	528	+
	529	+	phase := newTestPhase("test", cfg)
	530	+	orch.RegisterPhase(phase)
	531	+
	532	+	err := orch.ExecutePhase(phase)
	533	+	if err != nil {
	534	+	t.Fatalf("ExecutePhase failed: %v", err)
	535	+	}
	536	+
	537	+	durations := orch.GetPhaseDurations()
	538	+	duration, exists := durations["test"]
	539	+	if !exists {
	540	+	t.Error("Expected duration for 'test' phase")
	541	+	}
	542	+	if duration == 0 {
	543	+	t.Error("Duration should be greater than 0")
	544	+	}
	545	+	}

M internal/phases/partitioning.go +13 -11

 	"strings"
 	"github.com/bnema/archup/internal/config"
+	"github.com/bnema/archup/internal/interfaces"
 	"github.com/bnema/archup/internal/logger"
-	"github.com/bnema/archup/internal/system"
 )
 // PartitioningPhase handles disk partitioning, formatting, and mounting
 type PartitioningPhase struct {
 	*BasePhase
+	sysExec interfaces.SystemExecutor
 }
 // NewPartitioningPhase creates a new partitioning phase
-func NewPartitioningPhase(cfg *config.Config, log *logger.Logger) *PartitioningPhase {
+func NewPartitioningPhase(cfg *config.Config, log *logger.Logger, sysExec interfaces.SystemExecutor) *PartitioningPhase {
 	return &PartitioningPhase{
 		BasePhase: NewBasePhase("partitioning", "Disk Partitioning", cfg, log),
+		sysExec:   sysExec,
 	}
 }
 	// Note: In real implementation, pipe password securely via stdin
 	// For now, documenting the approach
-	result = system.RunSimple("sh", "-c",
+	result = p.sysExec.RunSimple("sh", "-c",
 		fmt.Sprintf("printf '%%s' '%s' | cryptsetup luksFormat --type luks2 --batch-mode --pbkdf argon2id --iter-time 2000 --label ARCHUP_LUKS --key-file - %s",
 			password, p.config.RootPartition))
 	}
 	// Open LUKS container
-	result = system.RunSimple("sh", "-c",
+	result = p.sysExec.RunSimple("sh", "-c",
 		fmt.Sprintf("printf '%%s' '%s' | cryptsetup open --key-file=- %s cryptroot",
 			password, p.config.RootPartition))
 	result = p.logger.ExecCommand("btrfs", "subvolume", "create", "/mnt/@")
 	switch {
 	case result.ExitCode != 0:
-		system.RunSimple("umount", "/mnt") // Cleanup
+		p.sysExec.RunSimple("umount", "/mnt") // Cleanup
 		return fmt.Errorf("@ subvolume creation failed: %w", result.Error)
 	}
 	result = p.logger.ExecCommand("btrfs", "subvolume", "create", "/mnt/@home")
 	switch {
 	case result.ExitCode != 0:
-		system.RunSimple("umount", "/mnt") // Cleanup
+		p.sysExec.RunSimple("umount", "/mnt") // Cleanup
 		return fmt.Errorf("@home subvolume creation failed: %w", result.Error)
 	}
 // PostCheck validates mounts
 func (p *PartitioningPhase) PostCheck() error {
 	// Verify /mnt is mounted
-	result := system.RunSimple("mountpoint", "-q", "/mnt")
+	result := p.sysExec.RunSimple("mountpoint", "-q", "/mnt")
 	switch {
 	case result.ExitCode != 0:
 		return fmt.Errorf("/mnt is not mounted")
 // Rollback unmounts filesystems
 func (p *PartitioningPhase) Rollback() error {
 	// Unmount in reverse order
-	system.RunSimple("umount", "/mnt/boot")
+	p.sysExec.RunSimple("umount", "/mnt/boot")
-	system.RunSimple("umount", "/mnt/home")
+	p.sysExec.RunSimple("umount", "/mnt/home")
-	system.RunSimple("umount", "/mnt")
+	p.sysExec.RunSimple("umount", "/mnt")
 	// Close LUKS if encrypted
 	switch p.config.EncryptionType {
 	case config.EncryptionLUKS, config.EncryptionLUKSLVM:
 		switch {
 		case p.config.CryptDevice != "":
-			system.RunSimple("cryptsetup", "close", "cryptroot")
+			p.sysExec.RunSimple("cryptsetup", "close", "cryptroot")
 		}
 	}

A internal/phases/partitioning_test.go +523 -0

@@ -0,0 +1,523 @@
	1	+	package phases
	2	+
	3	+	import (
	4	+	"fmt"
	5	+	"path/filepath"
	6	+	"reflect"
	7	+	"testing"
	8	+
	9	+	"github.com/bnema/archup/internal/config"
	10	+	"github.com/bnema/archup/internal/interfaces/mocks"
	11	+	"github.com/bnema/archup/internal/logger"
	12	+	"github.com/bnema/archup/internal/system"
	13	+	"go.uber.org/mock/gomock"
	14	+	)
	15	+
	16	+	// TestPartitioningPhasePreCheck tests partitioning prerequisites
	17	+	func TestPartitioningPhasePreCheck(t *testing.T) {
	18	+	tests := []struct {
	19	+	name string
	20	+	targetDisk string
	21	+	wantErr bool
	22	+	errContains string
	23	+	}{
	24	+	{
	25	+	name: "Valid target disk",
	26	+	targetDisk: "/dev/sda",
	27	+	wantErr: false,
	28	+	errContains: "",
	29	+	},
	30	+	{
	31	+	name: "Missing target disk",
	32	+	targetDisk: "",
	33	+	wantErr: true,
	34	+	errContains: "target disk not selected",
	35	+	},
	36	+	{
	37	+	name: "NVMe target disk",
	38	+	targetDisk: "/dev/nvme0n1",
	39	+	wantErr: false,
	40	+	errContains: "",
	41	+	},
	42	+	}
	43	+
	44	+	for _, tt := range tests {
	45	+	t.Run(tt.name, func(t *testing.T) {
	46	+	ctrl := gomock.NewController(t)
	47	+	defer ctrl.Finish()
	48	+
	49	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	50	+
	51	+	tmpDir := t.TempDir()
	52	+	logPath := filepath.Join(tmpDir, "test.log")
	53	+	log, err := logger.New(logPath, false)
	54	+	if err != nil {
	55	+	t.Fatalf("Failed to create logger: %v", err)
	56	+	}
	57	+	defer log.Close()
	58	+
	59	+	cfg := config.NewConfig("test")
	60	+	cfg.TargetDisk = tt.targetDisk
	61	+
	62	+	phase := NewPartitioningPhase(cfg, log, mockSysExec)
	63	+
	64	+	err = phase.PreCheck()
	65	+	if (err != nil) != tt.wantErr {
	66	+	t.Errorf("PreCheck() error = %v, wantErr %v", err, tt.wantErr)
	67	+	return
	68	+	}
	69	+	if tt.wantErr && err != nil {
	70	+	if errMsg := err.Error(); tt.errContains != "" && !containsSubstring(errMsg, tt.errContains) {
	71	+	t.Errorf("PreCheck() error = %q, should contain %q", errMsg, tt.errContains)
	72	+	}
	73	+	}
	74	+	})
	75	+	}
	76	+	}
	77	+
	78	+	// TestPartitioningPhasePartitionNaming tests partition naming logic
	79	+	func TestPartitioningPhasePartitionNaming(t *testing.T) {
	80	+	tests := []struct {
	81	+	name string
	82	+	targetDisk string
	83	+	expectedEFI string
	84	+	expectedRoot string
	85	+	}{
	86	+	{
	87	+	name: "NVMe disk naming",
	88	+	targetDisk: "/dev/nvme0n1",
	89	+	expectedEFI: "/dev/nvme0n1p1",
	90	+	expectedRoot: "/dev/nvme0n1p2",
	91	+	},
	92	+	{
	93	+	name: "SATA disk naming",
	94	+	targetDisk: "/dev/sda",
	95	+	expectedEFI: "/dev/sda1",
	96	+	expectedRoot: "/dev/sda2",
	97	+	},
	98	+	{
	99	+	name: "VirtIO disk naming",
	100	+	targetDisk: "/dev/vda",
	101	+	expectedEFI: "/dev/vda1",
	102	+	expectedRoot: "/dev/vda2",
	103	+	},
	104	+	}
	105	+
	106	+	for _, tt := range tests {
	107	+	t.Run(tt.name, func(t *testing.T) {
	108	+	ctrl := gomock.NewController(t)
	109	+	defer ctrl.Finish()
	110	+
	111	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	112	+
	113	+	tmpDir := t.TempDir()
	114	+	logPath := filepath.Join(tmpDir, "test.log")
	115	+	log, err := logger.New(logPath, false)
	116	+	if err != nil {
	117	+	t.Fatalf("Failed to create logger: %v", err)
	118	+	}
	119	+	defer log.Close()
	120	+
	121	+	cfg := config.NewConfig("test")
	122	+	cfg.TargetDisk = tt.targetDisk
	123	+
	124	+	phase := NewPartitioningPhase(cfg, log, mockSysExec)
	125	+
	126	+	// Verify partition names are set correctly in createPartitions logic
	127	+	// This is done by checking the naming convention
	128	+	phase.config.EFIPartition = tt.expectedEFI
	129	+	phase.config.RootPartition = tt.expectedRoot
	130	+
	131	+	if phase.config.EFIPartition != tt.expectedEFI {
	132	+	t.Errorf("EFI partition = %q, want %q", phase.config.EFIPartition, tt.expectedEFI)
	133	+	}
	134	+	if phase.config.RootPartition != tt.expectedRoot {
	135	+	t.Errorf("Root partition = %q, want %q", phase.config.RootPartition, tt.expectedRoot)
	136	+	}
	137	+	})
	138	+	}
	139	+	}
	140	+
	141	+	// TestPartitioningPhaseFormatRoot tests format method branching
	142	+	func TestPartitioningPhaseFormatRoot(t *testing.T) {
	143	+	tests := []struct {
	144	+	name string
	145	+	encryptionType string
	146	+	expectedCallType string // "LUKS" or "Plain"
	147	+	}{
	148	+	{
	149	+	name: "Unencrypted root",
	150	+	encryptionType: config.EncryptionNone,
	151	+	expectedCallType: "Plain",
	152	+	},
	153	+	{
	154	+	name: "LUKS encrypted root",
	155	+	encryptionType: config.EncryptionLUKS,
	156	+	expectedCallType: "LUKS",
	157	+	},
	158	+	{
	159	+	name: "LUKS with LVM",
	160	+	encryptionType: config.EncryptionLUKSLVM,
	161	+	expectedCallType: "LUKS",
	162	+	},
	163	+	}
	164	+
	165	+	for _, tt := range tests {
	166	+	t.Run(tt.name, func(t *testing.T) {
	167	+	ctrl := gomock.NewController(t)
	168	+	defer ctrl.Finish()
	169	+
	170	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	171	+
	172	+	tmpDir := t.TempDir()
	173	+	logPath := filepath.Join(tmpDir, "test.log")
	174	+	log, err := logger.New(logPath, false)
	175	+	if err != nil {
	176	+	t.Fatalf("Failed to create logger: %v", err)
	177	+	}
	178	+	defer log.Close()
	179	+
	180	+	cfg := config.NewConfig("test")
	181	+	cfg.TargetDisk = "/dev/sda"
	182	+	cfg.EFIPartition = "/dev/sda1"
	183	+	cfg.RootPartition = "/dev/sda2"
	184	+	cfg.EncryptionType = tt.encryptionType
	185	+	cfg.UserPassword = "password123"
	186	+
	187	+	phase := NewPartitioningPhase(cfg, log, mockSysExec)
	188	+
	189	+	// Verify encryption type branching
	190	+	if phase.config.EncryptionType != tt.encryptionType {
	191	+	t.Errorf("Encryption type = %q, want %q", phase.config.EncryptionType, tt.encryptionType)
	192	+	}
	193	+	})
	194	+	}
	195	+	}
	196	+
	197	+	// TestPartitioningPhaseEncryptionValidation tests encryption password requirement
	198	+	func TestPartitioningPhaseEncryptionValidation(t *testing.T) {
	199	+	tests := []struct {
	200	+	name string
	201	+	encryptionType string
	202	+	password string
	203	+	shouldRequire bool
	204	+	}{
	205	+	{
	206	+	name: "Unencrypted doesn't require password",
	207	+	encryptionType: config.EncryptionNone,
	208	+	password: "",
	209	+	shouldRequire: false,
	210	+	},
	211	+	{
	212	+	name: "LUKS requires password",
	213	+	encryptionType: config.EncryptionLUKS,
	214	+	password: "secure123",
	215	+	shouldRequire: true,
	216	+	},
	217	+	{
	218	+	name: "LUKS with empty password fails validation",
	219	+	encryptionType: config.EncryptionLUKS,
	220	+	password: "",
	221	+	shouldRequire: true, // Should have required one
	222	+	},
	223	+	}
	224	+
	225	+	for _, tt := range tests {
	226	+	t.Run(tt.name, func(t *testing.T) {
	227	+	ctrl := gomock.NewController(t)
	228	+	defer ctrl.Finish()
	229	+
	230	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	231	+
	232	+	tmpDir := t.TempDir()
	233	+	logPath := filepath.Join(tmpDir, "test.log")
	234	+	log, err := logger.New(logPath, false)
	235	+	if err != nil {
	236	+	t.Fatalf("Failed to create logger: %v", err)
	237	+	}
	238	+	defer log.Close()
	239	+
	240	+	cfg := config.NewConfig("test")
	241	+	cfg.TargetDisk = "/dev/sda"
	242	+	cfg.EFIPartition = "/dev/sda1"
	243	+	cfg.RootPartition = "/dev/sda2"
	244	+	cfg.EncryptionType = tt.encryptionType
	245	+	cfg.UserPassword = tt.password
	246	+
	247	+	phase := NewPartitioningPhase(cfg, log, mockSysExec)
	248	+
	249	+	// Validate password requirement
	250	+	if tt.shouldRequire && tt.encryptionType != config.EncryptionNone {
	251	+	if phase.config.UserPassword == "" && tt.password == "" {
	252	+	// Empty password for encryption - should fail in actual execution
	253	+	if phase.config.EncryptionType != config.EncryptionNone {
	254	+	// Password is required for encryption
	255	+	}
	256	+	}
	257	+	}
	258	+	})
	259	+	}
	260	+	}
	261	+
	262	+	// TestPartitioningPhasePostCheck tests mount point validation
	263	+	func TestPartitioningPhasePostCheck(t *testing.T) {
	264	+	tests := []struct {
	265	+	name string
	266	+	setupMocks func(*mocks.MockSystemExecutor)
	267	+	wantErr bool
	268	+	errContains string
	269	+	}{
	270	+	{
	271	+	name: "/mnt is mounted - postcheck passes",
	272	+	setupMocks: func(mockSysExec *mocks.MockSystemExecutor) {
	273	+	mockSysExec.EXPECT().RunSimple("mountpoint", "-q", "/mnt").Return(system.CommandResult{ExitCode: 0}).Times(1)
	274	+	},
	275	+	wantErr: false,
	276	+	},
	277	+	{
	278	+	name: "/mnt not mounted - postcheck fails",
	279	+	setupMocks: func(mockSysExec *mocks.MockSystemExecutor) {
	280	+	mockSysExec.EXPECT().RunSimple("mountpoint", "-q", "/mnt").Return(system.CommandResult{ExitCode: 32}).Times(1)
	281	+	},
	282	+	wantErr: true,
	283	+	errContains: "is not mounted",
	284	+	},
	285	+	}
	286	+
	287	+	for _, tt := range tests {
	288	+	t.Run(tt.name, func(t *testing.T) {
	289	+	ctrl := gomock.NewController(t)
	290	+	defer ctrl.Finish()
	291	+
	292	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	293	+
	294	+	tt.setupMocks(mockSysExec)
	295	+
	296	+	tmpDir := t.TempDir()
	297	+	logPath := filepath.Join(tmpDir, "test.log")
	298	+	log, err := logger.New(logPath, false)
	299	+	if err != nil {
	300	+	t.Fatalf("Failed to create logger: %v", err)
	301	+	}
	302	+	defer log.Close()
	303	+
	304	+	cfg := config.NewConfig("test")
	305	+	cfg.ConfigPath = filepath.Join(tmpDir, "config")
	306	+
	307	+	phase := NewPartitioningPhase(cfg, log, mockSysExec)
	308	+
	309	+	err = phase.PostCheck()
	310	+	if (err != nil) != tt.wantErr {
	311	+	t.Errorf("PostCheck() error = %v, wantErr %v", err, tt.wantErr)
	312	+	return
	313	+	}
	314	+	if tt.wantErr && err != nil {
	315	+	if errMsg := err.Error(); tt.errContains != "" && !containsSubstring(errMsg, tt.errContains) {
	316	+	t.Errorf("PostCheck() error = %q, should contain %q", errMsg, tt.errContains)
	317	+	}
	318	+	}
	319	+	})
	320	+	}
	321	+	}
	322	+
	323	+	// TestPartitioningPhaseRollback tests rollback cleanup
	324	+	func TestPartitioningPhaseRollback(t *testing.T) {
	325	+	tests := []struct {
	326	+	name string
	327	+	setupMocks func(*mocks.MockSystemExecutor)
	328	+	encryption string
	329	+	cryptDevice string
	330	+	wantErr bool
	331	+	}{
	332	+	{
	333	+	name: "Rollback unencrypted - success",
	334	+	setupMocks: func(mockSysExec *mocks.MockSystemExecutor) {
	335	+	mockSysExec.EXPECT().RunSimple("umount", "/mnt/boot").Return(system.CommandResult{}).Times(1)
	336	+	mockSysExec.EXPECT().RunSimple("umount", "/mnt/home").Return(system.CommandResult{}).Times(1)
	337	+	mockSysExec.EXPECT().RunSimple("umount", "/mnt").Return(system.CommandResult{}).Times(1)
	338	+	},
	339	+	encryption: config.EncryptionNone,
	340	+	cryptDevice: "",
	341	+	wantErr: false,
	342	+	},
	343	+	{
	344	+	name: "Rollback encrypted - closes LUKS",
	345	+	setupMocks: func(mockSysExec *mocks.MockSystemExecutor) {
	346	+	mockSysExec.EXPECT().RunSimple("umount", "/mnt/boot").Return(system.CommandResult{}).Times(1)
	347	+	mockSysExec.EXPECT().RunSimple("umount", "/mnt/home").Return(system.CommandResult{}).Times(1)
	348	+	mockSysExec.EXPECT().RunSimple("umount", "/mnt").Return(system.CommandResult{}).Times(1)
	349	+	mockSysExec.EXPECT().RunSimple("cryptsetup", "close", "cryptroot").Return(system.CommandResult{}).Times(1)
	350	+	},
	351	+	encryption: config.EncryptionLUKS,
	352	+	cryptDevice: "/dev/mapper/cryptroot",
	353	+	wantErr: false,
	354	+	},
	355	+	{
	356	+	name: "Rollback umount failure - continues anyway",
	357	+	setupMocks: func(mockSysExec *mocks.MockSystemExecutor) {
	358	+	mockSysExec.EXPECT().RunSimple("umount", "/mnt/boot").Return(system.CommandResult{ExitCode: 32, Error: fmt.Errorf("not mounted")}).Times(1)
	359	+	mockSysExec.EXPECT().RunSimple("umount", "/mnt/home").Return(system.CommandResult{ExitCode: 32}).Times(1)
	360	+	mockSysExec.EXPECT().RunSimple("umount", "/mnt").Return(system.CommandResult{ExitCode: 32}).Times(1)
	361	+	},
	362	+	encryption: config.EncryptionNone,
	363	+	cryptDevice: "",
	364	+	wantErr: false, // Rollback doesn't fail on umount errors
	365	+	},
	366	+	}
	367	+
	368	+	for _, tt := range tests {
	369	+	t.Run(tt.name, func(t *testing.T) {
	370	+	ctrl := gomock.NewController(t)
	371	+	defer ctrl.Finish()
	372	+
	373	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	374	+
	375	+	tt.setupMocks(mockSysExec)
	376	+
	377	+	tmpDir := t.TempDir()
	378	+	logPath := filepath.Join(tmpDir, "test.log")
	379	+	log, err := logger.New(logPath, false)
	380	+	if err != nil {
	381	+	t.Fatalf("Failed to create logger: %v", err)
	382	+	}
	383	+	defer log.Close()
	384	+
	385	+	cfg := config.NewConfig("test")
	386	+	cfg.EncryptionType = tt.encryption
	387	+	cfg.CryptDevice = tt.cryptDevice
	388	+
	389	+	phase := NewPartitioningPhase(cfg, log, mockSysExec)
	390	+
	391	+	err = phase.Rollback()
	392	+	if (err != nil) != tt.wantErr {
	393	+	t.Errorf("Rollback() error = %v, wantErr %v", err, tt.wantErr)
	394	+	}
	395	+	})
	396	+	}
	397	+	}
	398	+
	399	+	// TestPartitioningPhaseCanSkip tests the CanSkip method
	400	+	func TestPartitioningPhaseCanSkip(t *testing.T) {
	401	+	ctrl := gomock.NewController(t)
	402	+	defer ctrl.Finish()
	403	+
	404	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	405	+
	406	+	tmpDir := t.TempDir()
	407	+	logPath := filepath.Join(tmpDir, "test.log")
	408	+	log, err := logger.New(logPath, false)
	409	+	if err != nil {
	410	+	t.Fatalf("Failed to create logger: %v", err)
	411	+	}
	412	+	defer log.Close()
	413	+
	414	+	cfg := config.NewConfig("test")
	415	+	phase := NewPartitioningPhase(cfg, log, mockSysExec)
	416	+
	417	+	if phase.CanSkip() {
	418	+	t.Error("CanSkip() = true, want false")
	419	+	}
	420	+	}
	421	+
	422	+	// TestPartitioningPhaseExecute tests the Execute method structure
	423	+	func TestPartitioningPhaseExecute(t *testing.T) {
	424	+	ctrl := gomock.NewController(t)
	425	+	defer ctrl.Finish()
	426	+
	427	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	428	+
	429	+	tmpDir := t.TempDir()
	430	+	logPath := filepath.Join(tmpDir, "test.log")
	431	+	log, err := logger.New(logPath, false)
	432	+	if err != nil {
	433	+	t.Fatalf("Failed to create logger: %v", err)
	434	+	}
	435	+	defer log.Close()
	436	+
	437	+	cfg := config.NewConfig("test")
	438	+	cfg.TargetDisk = "/dev/sda"
	439	+
	440	+	phase := NewPartitioningPhase(cfg, log, mockSysExec)
	441	+
	442	+	progressChan := make(chan ProgressUpdate, 100)
	443	+
	444	+	// Verify phase can be created and Execute returns a PhaseResult
	445	+	// Note: Full Execute testing is complex due to logger.ExecCommand() calls
	446	+	// The return type and structure are validated here
	447	+	result := phase.Execute(progressChan)
	448	+
	449	+	// Verify result has the expected type
	450	+	if reflect.TypeOf(result) != reflect.TypeOf(PhaseResult{}) {
	451	+	t.Errorf("Execute() returned unexpected type: %T", result)
	452	+	}
	453	+	}
	454	+
	455	+	// TestPartitioningPhaseDeviceHandling tests both encrypted and unencrypted device handling
	456	+	func TestPartitioningPhaseDeviceHandling(t *testing.T) {
	457	+	tests := []struct {
	458	+	name string
	459	+	encryptionType string
	460	+	cryptDevice string
	461	+	rootPartition string
	462	+	expectedDevice string
	463	+	}{
	464	+	{
	465	+	name: "Unencrypted uses root partition",
	466	+	encryptionType: config.EncryptionNone,
	467	+	cryptDevice: "",
	468	+	rootPartition: "/dev/sda2",
	469	+	expectedDevice: "/dev/sda2",
	470	+	},
	471	+	{
	472	+	name: "Encrypted uses crypt device",
	473	+	encryptionType: config.EncryptionLUKS,
	474	+	cryptDevice: "/dev/mapper/cryptroot",
	475	+	rootPartition: "/dev/sda2",
	476	+	expectedDevice: "/dev/mapper/cryptroot",
	477	+	},
	478	+	{
	479	+	name: "LUKS+LVM uses crypt device",
	480	+	encryptionType: config.EncryptionLUKSLVM,
	481	+	cryptDevice: "/dev/mapper/cryptroot",
	482	+	rootPartition: "/dev/sda2",
	483	+	expectedDevice: "/dev/mapper/cryptroot",
	484	+	},
	485	+	}
	486	+
	487	+	for _, tt := range tests {
	488	+	t.Run(tt.name, func(t *testing.T) {
	489	+	ctrl := gomock.NewController(t)
	490	+	defer ctrl.Finish()
	491	+
	492	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	493	+
	494	+	tmpDir := t.TempDir()
	495	+	logPath := filepath.Join(tmpDir, "test.log")
	496	+	log, err := logger.New(logPath, false)
	497	+	if err != nil {
	498	+	t.Fatalf("Failed to create logger: %v", err)
	499	+	}
	500	+	defer log.Close()
	501	+
	502	+	cfg := config.NewConfig("test")
	503	+	cfg.EncryptionType = tt.encryptionType
	504	+	cfg.CryptDevice = tt.cryptDevice
	505	+	cfg.RootPartition = tt.rootPartition
	506	+
	507	+	phase := NewPartitioningPhase(cfg, log, mockSysExec)
	508	+
	509	+	// Determine which device would be used
	510	+	var device string
	511	+	switch phase.config.EncryptionType {
	512	+	case config.EncryptionLUKS, config.EncryptionLUKSLVM:
	513	+	device = phase.config.CryptDevice
	514	+	default:
	515	+	device = phase.config.RootPartition
	516	+	}
	517	+
	518	+	if device != tt.expectedDevice {
	519	+	t.Errorf("Device selection = %q, want %q", device, tt.expectedDevice)
	520	+	}
	521	+	})
	522	+	}
	523	+	}

A internal/phases/phase_test.go +328 -0

@@ -0,0 +1,328 @@
	1	+	package phases
	2	+
	3	+	import (
	4	+	"fmt"
	5	+	"path/filepath"
	6	+	"testing"
	7	+
	8	+	"github.com/bnema/archup/internal/config"
	9	+	"github.com/bnema/archup/internal/logger"
	10	+	)
	11	+
	12	+	// TestPhaseStatusString tests the String() method of PhaseStatus enum
	13	+	func TestPhaseStatusString(t *testing.T) {
	14	+	tests := []struct {
	15	+	status PhaseStatus
	16	+	expected string
	17	+	}{
	18	+	{StatusPending, "pending"},
	19	+	{StatusRunning, "running"},
	20	+	{StatusCompleted, "completed"},
	21	+	{StatusFailed, "failed"},
	22	+	{StatusSkipped, "skipped"},
	23	+	{PhaseStatus(999), "unknown"},
	24	+	}
	25	+
	26	+	for _, tt := range tests {
	27	+	t.Run(tt.expected, func(t *testing.T) {
	28	+	got := tt.status.String()
	29	+	if got != tt.expected {
	30	+	t.Errorf("PhaseStatus.String() = %q, want %q", got, tt.expected)
	31	+	}
	32	+	})
	33	+	}
	34	+	}
	35	+
	36	+	// TestNewBasePhase verifies BasePhase initialization
	37	+	func TestNewBasePhase(t *testing.T) {
	38	+	tmpDir := t.TempDir()
	39	+	logPath := filepath.Join(tmpDir, "test.log")
	40	+
	41	+	log, err := logger.New(logPath, false)
	42	+	if err != nil {
	43	+	t.Fatalf("Failed to create logger: %v", err)
	44	+	}
	45	+	defer log.Close()
	46	+
	47	+	cfg := config.NewConfig("test")
	48	+
	49	+	phase := NewBasePhase("test-phase", "Test phase description", cfg, log)
	50	+
	51	+	if phase.Name() != "test-phase" {
	52	+	t.Errorf("Name() = %q, want %q", phase.Name(), "test-phase")
	53	+	}
	54	+
	55	+	if phase.Description() != "Test phase description" {
	56	+	t.Errorf("Description() = %q, want %q", phase.Description(), "Test phase description")
	57	+	}
	58	+
	59	+	if phase.Status() != StatusPending {
	60	+	t.Errorf("Status() = %v, want %v", phase.Status(), StatusPending)
	61	+	}
	62	+
	63	+	if phase.Config() != cfg {
	64	+	t.Errorf("Config() returned different instance")
	65	+	}
	66	+
	67	+	if phase.Logger() != log {
	68	+	t.Errorf("Logger() returned different instance")
	69	+	}
	70	+	}
	71	+
	72	+	// TestBasePhaseSetStatus verifies status updates
	73	+	func TestBasePhaseSetStatus(t *testing.T) {
	74	+	tmpDir := t.TempDir()
	75	+	logPath := filepath.Join(tmpDir, "test.log")
	76	+
	77	+	log, _ := logger.New(logPath, false)
	78	+	defer log.Close()
	79	+
	80	+	cfg := config.NewConfig("test")
	81	+	phase := NewBasePhase("test", "test", cfg, log)
	82	+
	83	+	statuses := []PhaseStatus{
	84	+	StatusPending,
	85	+	StatusRunning,
	86	+	StatusCompleted,
	87	+	StatusFailed,
	88	+	StatusSkipped,
	89	+	}
	90	+
	91	+	for _, status := range statuses {
	92	+	t.Run(status.String(), func(t *testing.T) {
	93	+	phase.SetStatus(status)
	94	+	if phase.Status() != status {
	95	+	t.Errorf("Status() = %v, want %v", phase.Status(), status)
	96	+	}
	97	+	})
	98	+	}
	99	+	}
	100	+
	101	+	// TestBasePhaseDefaultPreCheck verifies default PreCheck implementation
	102	+	func TestBasePhaseDefaultPreCheck(t *testing.T) {
	103	+	tmpDir := t.TempDir()
	104	+	logPath := filepath.Join(tmpDir, "test.log")
	105	+
	106	+	log, _ := logger.New(logPath, false)
	107	+	defer log.Close()
	108	+
	109	+	tests := []struct {
	110	+	name string
	111	+	cfg *config.Config
	112	+	wantError bool
	113	+	}{
	114	+	{
	115	+	name: "with valid config",
	116	+	cfg: config.NewConfig("test"),
	117	+	wantError: false,
	118	+	},
	119	+	{
	120	+	name: "with nil config",
	121	+	cfg: nil,
	122	+	wantError: true,
	123	+	},
	124	+	}
	125	+
	126	+	for _, tt := range tests {
	127	+	t.Run(tt.name, func(t *testing.T) {
	128	+	phase := NewBasePhase("test", "test", tt.cfg, log)
	129	+	err := phase.PreCheck()
	130	+
	131	+	if (err != nil) != tt.wantError {
	132	+	t.Errorf("PreCheck() error = %v, wantError %v", err, tt.wantError)
	133	+	}
	134	+	})
	135	+	}
	136	+	}
	137	+
	138	+	// TestBasePhaseDefaultPostCheck verifies default PostCheck (always succeeds)
	139	+	func TestBasePhaseDefaultPostCheck(t *testing.T) {
	140	+	tmpDir := t.TempDir()
	141	+	logPath := filepath.Join(tmpDir, "test.log")
	142	+
	143	+	log, _ := logger.New(logPath, false)
	144	+	defer log.Close()
	145	+
	146	+	cfg := config.NewConfig("test")
	147	+	phase := NewBasePhase("test", "test", cfg, log)
	148	+
	149	+	err := phase.PostCheck()
	150	+	if err != nil {
	151	+	t.Errorf("PostCheck() error = %v, want nil", err)
	152	+	}
	153	+	}
	154	+
	155	+	// TestBasePhaseDefaultRollback verifies default Rollback returns error
	156	+	func TestBasePhaseDefaultRollback(t *testing.T) {
	157	+	tmpDir := t.TempDir()
	158	+	logPath := filepath.Join(tmpDir, "test.log")
	159	+
	160	+	log, _ := logger.New(logPath, false)
	161	+	defer log.Close()
	162	+
	163	+	cfg := config.NewConfig("test")
	164	+	phase := NewBasePhase("my-phase", "test", cfg, log)
	165	+
	166	+	err := phase.Rollback()
	167	+	if err == nil {
	168	+	t.Error("Rollback() error = nil, want error")
	169	+	}
	170	+
	171	+	expectedMsg := "rollback not implemented for phase: my-phase"
	172	+	if err.Error() != expectedMsg {
	173	+	t.Errorf("Rollback() error = %q, want %q", err.Error(), expectedMsg)
	174	+	}
	175	+	}
	176	+
	177	+	// TestBasePhaseDefaultCanSkip verifies default CanSkip returns false
	178	+	func TestBasePhaseDefaultCanSkip(t *testing.T) {
	179	+	tmpDir := t.TempDir()
	180	+	logPath := filepath.Join(tmpDir, "test.log")
	181	+
	182	+	log, _ := logger.New(logPath, false)
	183	+	defer log.Close()
	184	+
	185	+	cfg := config.NewConfig("test")
	186	+	phase := NewBasePhase("test", "test", cfg, log)
	187	+
	188	+	if phase.CanSkip() {
	189	+	t.Error("CanSkip() = true, want false")
	190	+	}
	191	+	}
	192	+
	193	+	// TestSendProgress verifies progress updates sent to channel
	194	+	func TestSendProgress(t *testing.T) {
	195	+	tmpDir := t.TempDir()
	196	+	logPath := filepath.Join(tmpDir, "test.log")
	197	+
	198	+	log, _ := logger.New(logPath, false)
	199	+	defer log.Close()
	200	+
	201	+	cfg := config.NewConfig("test")
	202	+	phase := NewBasePhase("test-phase", "test", cfg, log)
	203	+
	204	+	progressChan := make(chan ProgressUpdate, 5)
	205	+
	206	+	phase.SendProgress(progressChan, "step-1", 1, 3)
	207	+	phase.SendProgress(progressChan, "step-2", 2, 3)
	208	+
	209	+	// Verify first update
	210	+	update1 := <-progressChan
	211	+	if update1.PhaseName != "test-phase" {
	212	+	t.Errorf("PhaseName = %q, want %q", update1.PhaseName, "test-phase")
	213	+	}
	214	+	if update1.Step != "step-1" {
	215	+	t.Errorf("Step = %q, want %q", update1.Step, "step-1")
	216	+	}
	217	+	if update1.Current != 1 \|\| update1.Total != 3 {
	218	+	t.Errorf("Progress = %d/%d, want 1/3", update1.Current, update1.Total)
	219	+	}
	220	+	if update1.IsComplete \|\| update1.IsError {
	221	+	t.Error("Flags should be false for regular progress update")
	222	+	}
	223	+
	224	+	// Verify second update
	225	+	update2 := <-progressChan
	226	+	if update2.Step != "step-2" {
	227	+	t.Errorf("Step = %q, want %q", update2.Step, "step-2")
	228	+	}
	229	+	if update2.Current != 2 {
	230	+	t.Errorf("Current = %d, want 2", update2.Current)
	231	+	}
	232	+	}
	233	+
	234	+	// TestSendProgressWithNilChannel verifies no panic with nil channel
	235	+	func TestSendProgressWithNilChannel(t *testing.T) {
	236	+	tmpDir := t.TempDir()
	237	+	logPath := filepath.Join(tmpDir, "test.log")
	238	+
	239	+	log, _ := logger.New(logPath, false)
	240	+	defer log.Close()
	241	+
	242	+	cfg := config.NewConfig("test")
	243	+	phase := NewBasePhase("test", "test", cfg, log)
	244	+
	245	+	// Should not panic with nil channel
	246	+	phase.SendProgress(nil, "step", 1, 2)
	247	+	}
	248	+
	249	+	// TestSendComplete verifies completion signal
	250	+	func TestSendComplete(t *testing.T) {
	251	+	tmpDir := t.TempDir()
	252	+	logPath := filepath.Join(tmpDir, "test.log")
	253	+
	254	+	log, _ := logger.New(logPath, false)
	255	+	defer log.Close()
	256	+
	257	+	cfg := config.NewConfig("test")
	258	+	phase := NewBasePhase("test-phase", "test", cfg, log)
	259	+
	260	+	progressChan := make(chan ProgressUpdate, 1)
	261	+
	262	+	phase.SendComplete(progressChan, "Installation complete")
	263	+
	264	+	update := <-progressChan
	265	+	if !update.IsComplete {
	266	+	t.Error("IsComplete = false, want true")
	267	+	}
	268	+	if update.IsError {
	269	+	t.Error("IsError = true, want false")
	270	+	}
	271	+	if update.Step != "Installation complete" {
	272	+	t.Errorf("Step = %q, want %q", update.Step, "Installation complete")
	273	+	}
	274	+	}
	275	+
	276	+	// TestSendError verifies error signal
	277	+	func TestSendError(t *testing.T) {
	278	+	tmpDir := t.TempDir()
	279	+	logPath := filepath.Join(tmpDir, "test.log")
	280	+
	281	+	log, _ := logger.New(logPath, false)
	282	+	defer log.Close()
	283	+
	284	+	cfg := config.NewConfig("test")
	285	+	phase := NewBasePhase("test-phase", "test", cfg, log)
	286	+
	287	+	progressChan := make(chan ProgressUpdate, 1)
	288	+
	289	+	testErr := "test error message"
	290	+	err := fmt.Errorf("%s", testErr)
	291	+	phase.SendError(progressChan, err)
	292	+
	293	+	update := <-progressChan
	294	+	if !update.IsComplete {
	295	+	t.Error("IsComplete = false, want true")
	296	+	}
	297	+	if !update.IsError {
	298	+	t.Error("IsError = false, want true")
	299	+	}
	300	+	if update.ErrorMsg != testErr {
	301	+	t.Errorf("ErrorMsg = %q, want %q", update.ErrorMsg, testErr)
	302	+	}
	303	+	}
	304	+
	305	+	// TestSendOutput verifies output line sending
	306	+	func TestSendOutput(t *testing.T) {
	307	+	tmpDir := t.TempDir()
	308	+	logPath := filepath.Join(tmpDir, "test.log")
	309	+
	310	+	log, _ := logger.New(logPath, false)
	311	+	defer log.Close()
	312	+
	313	+	cfg := config.NewConfig("test")
	314	+	phase := NewBasePhase("test-phase", "test", cfg, log)
	315	+
	316	+	progressChan := make(chan ProgressUpdate, 1)
	317	+
	318	+	outputLine := "output from command"
	319	+	phase.SendOutput(progressChan, outputLine)
	320	+
	321	+	update := <-progressChan
	322	+	if update.OutputLine != outputLine {
	323	+	t.Errorf("OutputLine = %q, want %q", update.OutputLine, outputLine)
	324	+	}
	325	+	if update.IsComplete \|\| update.IsError {
	326	+	t.Error("Completion/Error flags should be false for output update")
	327	+	}
	328	+	}

M internal/phases/postinstall.go +54 -45

 	"strings"
 	"github.com/bnema/archup/internal/config"
+	"github.com/bnema/archup/internal/interfaces"
 	"github.com/bnema/archup/internal/logger"
 	"github.com/bnema/archup/internal/system"
 )
 // PostInstallPhase handles post-installation tasks
 type PostInstallPhase struct {
 	*BasePhase
+	fs      interfaces.FileSystem
+	http    interfaces.HTTPClient
+	sysExec interfaces.SystemExecutor
+	chrExec interfaces.ChrootExecutor
 }
 // NewPostInstallPhase creates a new post-install phase
-func NewPostInstallPhase(cfg *config.Config, log *logger.Logger) *PostInstallPhase {
+func NewPostInstallPhase(cfg *config.Config, log *logger.Logger, fs interfaces.FileSystem, http interfaces.HTTPClient, sysExec interfaces.SystemExecutor, chrExec interfaces.ChrootExecutor) *PostInstallPhase {
 	return &PostInstallPhase{
 		BasePhase: NewBasePhase("postinstall", "Post-Installation", cfg, log),
+		fs:        fs,
+		http:      http,
+		sysExec:   sysExec,
+		chrExec:   chrExec,
 	}
 }
 // PreCheck validates post-install prerequisites
 func (p *PostInstallPhase) PreCheck() error {
 	// Verify /mnt is mounted
-	result := system.RunSimple("mountpoint", "-q", config.PathMnt)
+	result := p.sysExec.RunSimple("mountpoint", "-q", config.PathMnt)
 	switch {
 	case result.ExitCode != 0:
 		return fmt.Errorf("%s is not mounted", config.PathMnt)
 	}
 	// Verify boot directory exists
-	switch _, err := os.Stat(config.PathMntBoot); {
+	switch _, err := p.fs.Stat(config.PathMntBoot); {
-	case os.IsNotExist(err):
+	case p.fs.IsNotExist(err):
 		return fmt.Errorf("boot directory not found")
 	}
 	// Build logo URL from config
 	logoURL := fmt.Sprintf("%s/%s", p.config.RawURL, config.ArchLogoURL)
-	resp, err := http.Get(logoURL)
+	resp, err := p.http.Get(logoURL)
 	switch {
 	case err != nil:
 		return fmt.Errorf("failed to download logo: %w", err)
 	}
 	// Save to boot partition
-	logoFile, err := os.Create(config.PathMntBootLogo)
+	logoFile, err := p.fs.Create(config.PathMntBootLogo)
 	switch {
 	case err != nil:
 		return fmt.Errorf("failed to create logo file: %w", err)
 	// Update Limine config
 	limineConf := filepath.Join(config.PathMntBootEFILimine, config.FileLimineConfig)
-	content, err := os.ReadFile(limineConf)
+	content, err := p.fs.ReadFile(limineConf)
 	switch {
 	case err != nil:
 		return fmt.Errorf("failed to read limine.conf: %w", err)
 		wallpaperSettings := "\nwallpaper: boot():/arch-logo.png\nwallpaper_style: centered\nbackdrop: 000000"
 		contentStr = graphicsRegex.ReplaceAllString(contentStr, "graphics: yes"+wallpaperSettings)
-		switch err := os.WriteFile(limineConf, []byte(contentStr), 0644); {
+		switch err := p.fs.WriteFile(limineConf, []byte(contentStr), 0644); {
 		case err != nil:
 			return fmt.Errorf("failed to update limine.conf: %w", err)
 		}
 	// Create theme directory
 	themeDir := filepath.Join(config.PathMntPlymouthThemes, config.PlymouthThemeName)
-	switch err := os.MkdirAll(themeDir, 0755); {
+	switch err := p.fs.MkdirAll(themeDir, 0755); {
 	case err != nil:
 		return fmt.Errorf("failed to create theme directory: %w", err)
 	}
 		p.SendOutput(progressChan, fmt.Sprintf("Downloading %s...", filename))
 		fileURL := fmt.Sprintf("%s/assets/plymouth/%s", p.config.RawURL, filename)
-		resp, err := http.Get(fileURL)
+		resp, err := p.http.Get(fileURL)
 		switch {
 		case err != nil:
 			return fmt.Errorf("failed to download %s: %w", filename, err)
 		// Save file
 		destPath := filepath.Join(themeDir, filename)
-		destFile, err := os.Create(destPath)
+		destFile, err := p.fs.Create(destPath)
 		switch {
 		case err != nil:
 			resp.Body.Close()
 		}
 		// Set permissions
-		switch err := os.Chmod(destPath, 0644); {
+		switch err := p.fs.Chmod(destPath, 0644); {
 		case err != nil:
 			return fmt.Errorf("failed to set permissions on %s: %w", filename, err)
 		}
 	// Set as default theme
 	setThemeCmd := fmt.Sprintf("plymouth-set-default-theme %s", config.PlymouthThemeName)
-	switch err := system.ChrootExec(p.logger.LogPath(),config.PathMnt, setThemeCmd); {
+	switch err := p.chrExec.ChrootExec(p.logger.LogPath(),config.PathMnt, setThemeCmd); {
 	case err != nil:
 		return fmt.Errorf("failed to set Plymouth theme: %w", err)
 	}
 	// Regenerate initramfs
 	p.SendOutput(progressChan, "Regenerating initramfs with Plymouth...")
-	switch err := system.ChrootExec(p.logger.LogPath(),config.PathMnt, "mkinitcpio -P"); {
+	switch err := p.chrExec.ChrootExec(p.logger.LogPath(),config.PathMnt, "mkinitcpio -P"); {
 	case err != nil:
 		return fmt.Errorf("failed to regenerate initramfs: %w", err)
 	}
 	p.SendOutput(progressChan, "Installing limine-snapper-sync...")
 	// Install limine-snapper-sync
-	switch err := system.ChrootPacman(p.logger.LogPath(),config.PathMnt, "-S", "--needed", "limine-snapper-sync"); {
+	switch err := p.chrExec.ChrootPacman(p.logger.LogPath(),config.PathMnt, "-S", "--needed", "limine-snapper-sync"); {
 	case err != nil:
 		return fmt.Errorf("failed to install limine-snapper-sync: %w", err)
 	}
 	// Get kernel cmdline from existing Limine config
 	limineConf := filepath.Join(config.PathMntBootEFILimine, config.FileLimineConfig)
-	content, err := os.ReadFile(limineConf)
+	content, err := p.fs.ReadFile(limineConf)
 	switch {
 	case err != nil:
 		return fmt.Errorf("failed to read limine.conf: %w", err)
 SNAPSHOT_FORMAT_CHOICE=5
 `, cmdline)
-	switch err := os.WriteFile(config.PathMntEtcDefaultLimine, []byte(limineDefaultConfig), 0644); {
+	switch err := p.fs.WriteFile(config.PathMntEtcDefaultLimine, []byte(limineDefaultConfig), 0644); {
 	case err != nil:
 		return fmt.Errorf("failed to write limine config: %w", err)
 	}
 	p.SendOutput(progressChan, "[OK] Limine snapper config created")
 	// Enable service
-	switch err := system.ChrootSystemctl(p.logger.LogPath(), config.PathMnt, "enable", "limine-snapper-sync.service"); {
+	switch err := p.chrExec.ChrootSystemctl(p.logger.LogPath(), config.PathMnt, "enable", "limine-snapper-sync.service"); {
 	case err != nil:
 		return fmt.Errorf("failed to enable limine-snapper-sync: %w", err)
 	}
 func (p *PostInstallPhase) configurePacman(progressChan chan<- ProgressUpdate) error {
 	p.SendOutput(progressChan, "Configuring pacman UX...")
-	content, err := os.ReadFile(config.PathMntEtcPacmanConf)
+	content, err := p.fs.ReadFile(config.PathMntEtcPacmanConf)
 	switch {
 	case err != nil:
 		return fmt.Errorf("failed to read pacman.conf: %w", err)
 		contentStr = colorLineRegex.ReplaceAllString(contentStr, "Color\nILoveCandy")
 	}
-	switch err := os.WriteFile(config.PathMntEtcPacmanConf, []byte(contentStr), 0644); {
+	switch err := p.fs.WriteFile(config.PathMntEtcPacmanConf, []byte(contentStr), 0644); {
 	case err != nil:
 		return fmt.Errorf("failed to write pacman.conf: %w", err)
 	}
 	p.SendOutput(progressChan, "Installing pacman hooks...")
 	// Create hooks directory
-	switch err := os.MkdirAll(config.PathMntEtcPacmanDHooks, 0755); {
+	switch err := p.fs.MkdirAll(config.PathMntEtcPacmanDHooks, 0755); {
 	case err != nil:
 		return fmt.Errorf("failed to create hooks directory: %w", err)
 	}
 `
 	hookPath := filepath.Join(config.PathMntEtcPacmanDHooks, "99-limine.hook")
-	switch err := os.WriteFile(hookPath, []byte(limineHook), 0644); {
+	switch err := p.fs.WriteFile(hookPath, []byte(limineHook), 0644); {
 	case err != nil:
 		return fmt.Errorf("failed to write limine hook: %w", err)
 	}
 	p.SendOutput(progressChan, fmt.Sprintf("Configuring shell for user: %s", username))
 	// Create directory structure
-	switch err := os.MkdirAll(archupDefaultBash, 0755); {
+	switch err := p.fs.MkdirAll(archupDefaultBash, 0755); {
 	case err != nil:
 		return fmt.Errorf("failed to create shell config directory: %w", err)
 	}
 	}
 	bashrcPath := filepath.Join(userHome, ".bashrc")
-	switch err := os.WriteFile(bashrcPath, bashrcContent, 0644); {
+	switch err := p.fs.WriteFile(bashrcPath, bashrcContent, 0644); {
 	case err != nil:
 		return fmt.Errorf("failed to write .bashrc: %w", err)
 	}
 	}
 	for _, gitCmd := range gitCommands {
-		switch err := system.ChrootExec(p.logger.LogPath(),config.PathMnt, gitCmd); {
+		switch err := p.chrExec.ChrootExec(p.logger.LogPath(),config.PathMnt, gitCmd); {
 		case err != nil:
 			// Non-fatal
 			p.SendOutput(progressChan, "[WARN] Failed to configure git delta")
 			return fmt.Errorf("failed to read template %s: %w", template, err)
 		}
-		switch err := os.WriteFile(dest, content, 0644); {
+		switch err := p.fs.WriteFile(dest, content, 0644); {
 		case err != nil:
 			return fmt.Errorf("failed to write %s: %w", dest, err)
 		}
 func (p *PostInstallPhase) readTemplate(filename string) ([]byte, error) {
 	// Use DefaultInstallDir directly to match where bootstrap downloads files
 	templatePath := filepath.Join(config.DefaultInstallDir, filename)
-	return os.ReadFile(templatePath)
+	return p.fs.ReadFile(templatePath)
 }
 // setShellOwnership sets ownership of shell config files to user
 	relativeHome := strings.TrimPrefix(userHome, config.PathMnt)
 	chownCmd := fmt.Sprintf("chown -R %s:%s %s/.local %s/.bashrc",
 		username, username, relativeHome, relativeHome)
-	return system.ChrootExec(p.logger.LogPath(),config.PathMnt, chownCmd)
+	return p.chrExec.ChrootExec(p.logger.LogPath(),config.PathMnt, chownCmd)
 }
 // verifyInstallation performs comprehensive verification
 	// Verify kernel
 	kernelName := p.config.KernelChoice
 	kernelPath := filepath.Join(config.PathMntBoot, fmt.Sprintf("vmlinuz-%s", kernelName))
-	switch _, err := os.Stat(kernelPath); {
+	switch _, err := p.fs.Stat(kernelPath); {
-	case os.IsNotExist(err):
+	case p.fs.IsNotExist(err):
 		p.SendOutput(progressChan, fmt.Sprintf("[ERROR] Kernel missing: %s", kernelPath))
 		verificationFailed = true
 	default:
 	// Verify initramfs
 	initramfsPath := filepath.Join(config.PathMntBoot, fmt.Sprintf("initramfs-%s.img", kernelName))
-	switch _, err := os.Stat(initramfsPath); {
+	switch _, err := p.fs.Stat(initramfsPath); {
-	case os.IsNotExist(err):
+	case p.fs.IsNotExist(err):
 		p.SendOutput(progressChan, fmt.Sprintf("[ERROR] Initramfs missing: %s", initramfsPath))
 		verificationFailed = true
 	default:
 	// Verify bootloader
 	bootloaderPath := filepath.Join(config.PathMntBootEFILimine, config.FileLimineBootloader)
-	switch _, err := os.Stat(bootloaderPath); {
+	switch _, err := p.fs.Stat(bootloaderPath); {
-	case os.IsNotExist(err):
+	case p.fs.IsNotExist(err):
 		p.SendOutput(progressChan, "[ERROR] Bootloader missing")
 		verificationFailed = true
 	default:
 	// Verify Limine config
 	limineConfPath := filepath.Join(config.PathMntBootEFILimine, config.FileLimineConfig)
-	switch content, err := os.ReadFile(limineConfPath); {
+	switch content, err := p.fs.ReadFile(limineConfPath); {
 	case err != nil:
 		p.SendOutput(progressChan, "[ERROR] Limine config missing")
 		verificationFailed = true
 	}
 	// Verify NetworkManager is enabled
-	result := system.RunSimple("arch-chroot", config.PathMnt, "systemctl", "is-enabled", "NetworkManager")
+	result := p.sysExec.RunSimple("arch-chroot", config.PathMnt, "systemctl", "is-enabled", "NetworkManager")
 	switch {
 	case result.ExitCode != 0:
 		p.SendOutput(progressChan, "[ERROR] NetworkManager not enabled")
 func (p *PostInstallPhase) setupPostBoot(progressChan chan<- ProgressUpdate) error {
 	p.SendOutput(progressChan, "Configuring first-boot service...")
-	switch err := os.MkdirAll(config.PathMntPostBoot, 0755); {
+	switch err := p.fs.MkdirAll(config.PathMntPostBoot, 0755); {
 	case err != nil:
 		return fmt.Errorf("failed to create post-boot directory: %w", err)
 	}
 	// Download logo.txt
 	p.SendOutput(progressChan, "Downloading logo.txt...")
 	logoURL := fmt.Sprintf("%s/logo.txt", p.config.RawURL)
-	resp, err := http.Get(logoURL)
+	resp, err := p.http.Get(logoURL)
 	switch {
 	case err != nil:
 		return fmt.Errorf("failed to download logo.txt: %w", err)
 	}
 	logoPath := filepath.Join(config.PathMntPostBoot, "logo.txt")
-	logoFile, err := os.Create(logoPath)
+	logoFile, err := p.fs.Create(logoPath)
 	switch {
 	case err != nil:
 		resp.Body.Close()
 		p.SendOutput(progressChan, fmt.Sprintf("Downloading %s...", script))
 		scriptURL := fmt.Sprintf("%s/install/post-boot/%s", p.config.RawURL, script)
-		resp, err := http.Get(scriptURL)
+		resp, err := p.http.Get(scriptURL)
 		switch {
 		case err != nil:
 			return fmt.Errorf("failed to download %s: %w", script, err)
 		}
 		scriptPath := filepath.Join(config.PathMntPostBoot, script)
-		scriptFile, err := os.Create(scriptPath)
+		scriptFile, err := p.fs.Create(scriptPath)
 		switch {
 		case err != nil:
 			resp.Body.Close()
 			return fmt.Errorf("failed to save %s: %w", script, err)
 		}
-		switch err := os.Chmod(scriptPath, 0755); {
+		switch err := p.fs.Chmod(scriptPath, 0755); {
 		case err != nil:
 			return fmt.Errorf("failed to set permissions on %s: %w", script, err)
 		}
 	// Download service template
 	p.SendOutput(progressChan, "Creating systemd service...")
 	serviceURL := fmt.Sprintf("%s/%s", p.config.RawURL, config.PostBootServiceTemplate)
-	resp, err = http.Get(serviceURL)
+	resp, err = p.http.Get(serviceURL)
 	switch {
 	case err != nil:
 		return fmt.Errorf("failed to download service template: %w", err)
 	serviceContent = strings.ReplaceAll(serviceContent, "__ARCHUP_USERNAME__", p.config.Username)
 	servicePath := filepath.Join(config.PathMntSystemdSystem, config.PostBootServiceName)
-	switch err := os.WriteFile(servicePath, []byte(serviceContent), 0644); {
+	switch err := p.fs.WriteFile(servicePath, []byte(serviceContent), 0644); {
 	case err != nil:
 		return fmt.Errorf("failed to write service file: %w", err)
 	}
 	p.SendOutput(progressChan, "[OK] Service file created")
 	p.SendOutput(progressChan, "Enabling first-boot service...")
-	switch err := system.ChrootSystemctl(p.logger.LogPath(), config.PathMnt, "enable", config.PostBootServiceName); {
+	switch err := p.chrExec.ChrootSystemctl(p.logger.LogPath(), config.PathMnt, "enable", config.PostBootServiceName); {
 	case err != nil:
 		return fmt.Errorf("failed to enable service: %w", err)
 	}

A internal/phases/postinstall_test.go +465 -0

@@ -0,0 +1,465 @@
	1	+	package phases
	2	+
	3	+	import (
	4	+	"fmt"
	5	+	"path/filepath"
	6	+	"testing"
	7	+
	8	+	"github.com/bnema/archup/internal/config"
	9	+	"github.com/bnema/archup/internal/interfaces/mocks"
	10	+	"github.com/bnema/archup/internal/logger"
	11	+	"github.com/bnema/archup/internal/system"
	12	+	"go.uber.org/mock/gomock"
	13	+	)
	14	+
	15	+	// TestPostInstallPhasePreCheck tests post-install prerequisites
	16	+	func TestPostInstallPhasePreCheck(t *testing.T) {
	17	+	tests := []struct {
	18	+	name string
	19	+	setupMocks func(mocks.MockFileSystem, mocks.MockSystemExecutor)
	20	+	wantErr bool
	21	+	errContains string
	22	+	}{
	23	+	{
	24	+	name: "/mnt mounted and boot directory exists",
	25	+	setupMocks: func(mockFS mocks.MockFileSystem, mockSysExec mocks.MockSystemExecutor) {
	26	+	mockSysExec.EXPECT().RunSimple("mountpoint", "-q", config.PathMnt).Return(system.CommandResult{ExitCode: 0}).Times(1)
	27	+	mockFS.EXPECT().Stat(config.PathMntBoot).Return(mockFileInfo{}, nil).Times(1)
	28	+	mockFS.EXPECT().IsNotExist(gomock.Any()).Return(false).Times(1)
	29	+	},
	30	+	wantErr: false,
	31	+	},
	32	+	{
	33	+	name: "/mnt not mounted",
	34	+	setupMocks: func(mockFS mocks.MockFileSystem, mockSysExec mocks.MockSystemExecutor) {
	35	+	mockSysExec.EXPECT().RunSimple("mountpoint", "-q", config.PathMnt).Return(system.CommandResult{ExitCode: 32}).Times(1)
	36	+	},
	37	+	wantErr: true,
	38	+	errContains: "is not mounted",
	39	+	},
	40	+	{
	41	+	name: "boot directory not found",
	42	+	setupMocks: func(mockFS mocks.MockFileSystem, mockSysExec mocks.MockSystemExecutor) {
	43	+	mockSysExec.EXPECT().RunSimple("mountpoint", "-q", config.PathMnt).Return(system.CommandResult{ExitCode: 0}).Times(1)
	44	+	mockFS.EXPECT().Stat(config.PathMntBoot).Return(nil, fmt.Errorf("not found")).Times(1)
	45	+	mockFS.EXPECT().IsNotExist(gomock.Any()).Return(true).Times(1)
	46	+	},
	47	+	wantErr: true,
	48	+	errContains: "boot directory not found",
	49	+	},
	50	+	}
	51	+
	52	+	for _, tt := range tests {
	53	+	t.Run(tt.name, func(t *testing.T) {
	54	+	ctrl := gomock.NewController(t)
	55	+	defer ctrl.Finish()
	56	+
	57	+	mockFS := mocks.NewMockFileSystem(ctrl)
	58	+	mockHTTP := mocks.NewMockHTTPClient(ctrl)
	59	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	60	+	mockChrExec := mocks.NewMockChrootExecutor(ctrl)
	61	+
	62	+	tt.setupMocks(mockFS, mockSysExec)
	63	+
	64	+	tmpDir := t.TempDir()
	65	+	logPath := filepath.Join(tmpDir, "test.log")
	66	+	log, err := logger.New(logPath, false)
	67	+	if err != nil {
	68	+	t.Fatalf("Failed to create logger: %v", err)
	69	+	}
	70	+	defer log.Close()
	71	+
	72	+	cfg := config.NewConfig("test")
	73	+	phase := NewPostInstallPhase(cfg, log, mockFS, mockHTTP, mockSysExec, mockChrExec)
	74	+
	75	+	err = phase.PreCheck()
	76	+	if (err != nil) != tt.wantErr {
	77	+	t.Errorf("PreCheck() error = %v, wantErr %v", err, tt.wantErr)
	78	+	return
	79	+	}
	80	+	if tt.wantErr && err != nil {
	81	+	if errMsg := err.Error(); tt.errContains != "" && !containsSubstring(errMsg, tt.errContains) {
	82	+	t.Errorf("PreCheck() error = %q, should contain %q", errMsg, tt.errContains)
	83	+	}
	84	+	}
	85	+	})
	86	+	}
	87	+	}
	88	+
	89	+	// TestPostInstallPhaseTemplateReading tests template file reading
	90	+	func TestPostInstallPhaseTemplateReading(t *testing.T) {
	91	+	tests := []struct {
	92	+	name string
	93	+	templateFile string
	94	+	setupMocks func(*mocks.MockFileSystem)
	95	+	wantErr bool
	96	+	errContains string
	97	+	}{
	98	+	{
	99	+	name: "Successfully read bashrc template",
	100	+	templateFile: "bashrc",
	101	+	setupMocks: func(mockFS *mocks.MockFileSystem) {
	102	+	mockFS.EXPECT().ReadFile(gomock.Any()).Return([]byte("bashrc content"), nil).Times(1)
	103	+	},
	104	+	wantErr: false,
	105	+	},
	106	+	{
	107	+	name: "Template file not found",
	108	+	templateFile: "missing.conf",
	109	+	setupMocks: func(mockFS *mocks.MockFileSystem) {
	110	+	mockFS.EXPECT().ReadFile(gomock.Any()).Return(nil, fmt.Errorf("file not found")).Times(1)
	111	+	},
	112	+	wantErr: true,
	113	+	errContains: "failed to read",
	114	+	},
	115	+	}
	116	+
	117	+	for _, tt := range tests {
	118	+	t.Run(tt.name, func(t *testing.T) {
	119	+	ctrl := gomock.NewController(t)
	120	+	defer ctrl.Finish()
	121	+
	122	+	mockFS := mocks.NewMockFileSystem(ctrl)
	123	+	mockHTTP := mocks.NewMockHTTPClient(ctrl)
	124	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	125	+	mockChrExec := mocks.NewMockChrootExecutor(ctrl)
	126	+
	127	+	tt.setupMocks(mockFS)
	128	+
	129	+	tmpDir := t.TempDir()
	130	+	logPath := filepath.Join(tmpDir, "test.log")
	131	+	log, err := logger.New(logPath, false)
	132	+	if err != nil {
	133	+	t.Fatalf("Failed to create logger: %v", err)
	134	+	}
	135	+	defer log.Close()
	136	+
	137	+	cfg := config.NewConfig("test")
	138	+	phase := NewPostInstallPhase(cfg, log, mockFS, mockHTTP, mockSysExec, mockChrExec)
	139	+
	140	+	_, err = phase.readTemplate(tt.templateFile)
	141	+	if (err != nil) != tt.wantErr {
	142	+	t.Errorf("readTemplate() error = %v, wantErr %v", err, tt.wantErr)
	143	+	return
	144	+	}
	145	+	})
	146	+	}
	147	+	}
	148	+
	149	+	// TestPostInstallPhasePostCheck tests post-install validation
	150	+	func TestPostInstallPhasePostCheck(t *testing.T) {
	151	+	ctrl := gomock.NewController(t)
	152	+	defer ctrl.Finish()
	153	+
	154	+	mockFS := mocks.NewMockFileSystem(ctrl)
	155	+	mockHTTP := mocks.NewMockHTTPClient(ctrl)
	156	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	157	+	mockChrExec := mocks.NewMockChrootExecutor(ctrl)
	158	+
	159	+	tmpDir := t.TempDir()
	160	+	logPath := filepath.Join(tmpDir, "test.log")
	161	+	log, err := logger.New(logPath, false)
	162	+	if err != nil {
	163	+	t.Fatalf("Failed to create logger: %v", err)
	164	+	}
	165	+	defer log.Close()
	166	+
	167	+	cfg := config.NewConfig("test")
	168	+	cfg.ConfigPath = filepath.Join(tmpDir, "config")
	169	+
	170	+	phase := NewPostInstallPhase(cfg, log, mockFS, mockHTTP, mockSysExec, mockChrExec)
	171	+
	172	+	err = phase.PostCheck()
	173	+	// PostCheck should succeed as it just saves the config
	174	+	if err != nil {
	175	+	t.Errorf("PostCheck() error = %v, want nil", err)
	176	+	}
	177	+	}
	178	+
	179	+	// TestPostInstallPhaseRollback tests post-install rollback
	180	+	func TestPostInstallPhaseRollback(t *testing.T) {
	181	+	ctrl := gomock.NewController(t)
	182	+	defer ctrl.Finish()
	183	+
	184	+	mockFS := mocks.NewMockFileSystem(ctrl)
	185	+	mockHTTP := mocks.NewMockHTTPClient(ctrl)
	186	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	187	+	mockChrExec := mocks.NewMockChrootExecutor(ctrl)
	188	+
	189	+	tmpDir := t.TempDir()
	190	+	logPath := filepath.Join(tmpDir, "test.log")
	191	+	log, err := logger.New(logPath, false)
	192	+	if err != nil {
	193	+	t.Fatalf("Failed to create logger: %v", err)
	194	+	}
	195	+	defer log.Close()
	196	+
	197	+	cfg := config.NewConfig("test")
	198	+	phase := NewPostInstallPhase(cfg, log, mockFS, mockHTTP, mockSysExec, mockChrExec)
	199	+
	200	+	// Rollback should always succeed (it's a cleanup operation)
	201	+	err = phase.Rollback()
	202	+	if err != nil {
	203	+	t.Errorf("Rollback() error = %v, want nil", err)
	204	+	}
	205	+	}
	206	+
	207	+	// TestPostInstallPhaseCanSkip tests the CanSkip method
	208	+	func TestPostInstallPhaseCanSkip(t *testing.T) {
	209	+	ctrl := gomock.NewController(t)
	210	+	defer ctrl.Finish()
	211	+
	212	+	mockFS := mocks.NewMockFileSystem(ctrl)
	213	+	mockHTTP := mocks.NewMockHTTPClient(ctrl)
	214	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	215	+	mockChrExec := mocks.NewMockChrootExecutor(ctrl)
	216	+
	217	+	tmpDir := t.TempDir()
	218	+	logPath := filepath.Join(tmpDir, "test.log")
	219	+	log, err := logger.New(logPath, false)
	220	+	if err != nil {
	221	+	t.Fatalf("Failed to create logger: %v", err)
	222	+	}
	223	+	defer log.Close()
	224	+
	225	+	cfg := config.NewConfig("test")
	226	+	phase := NewPostInstallPhase(cfg, log, mockFS, mockHTTP, mockSysExec, mockChrExec)
	227	+
	228	+	if phase.CanSkip() {
	229	+	t.Error("CanSkip() = true, want false")
	230	+	}
	231	+	}
	232	+
	233	+	// TestPostInstallPhaseExecute tests the Execute method
	234	+	func TestPostInstallPhaseExecute(t *testing.T) {
	235	+	ctrl := gomock.NewController(t)
	236	+	defer ctrl.Finish()
	237	+
	238	+	mockFS := mocks.NewMockFileSystem(ctrl)
	239	+	mockHTTP := mocks.NewMockHTTPClient(ctrl)
	240	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	241	+	mockChrExec := mocks.NewMockChrootExecutor(ctrl)
	242	+
	243	+	// Allow any file system and executor operations
	244	+	mockFS.EXPECT().ReadFile(gomock.Any()).Return([]byte{}, nil).AnyTimes()
	245	+	mockFS.EXPECT().WriteFile(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
	246	+	mockFS.EXPECT().MkdirAll(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
	247	+	mockFS.EXPECT().Create(gomock.Any()).Return(&MockWriteCloser{}, nil).AnyTimes()
	248	+	mockFS.EXPECT().Stat(gomock.Any()).Return(mockFileInfo{}, nil).AnyTimes()
	249	+	mockFS.EXPECT().IsNotExist(gomock.Any()).Return(false).AnyTimes()
	250	+	mockFS.EXPECT().Chmod(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
	251	+	mockHTTP.EXPECT().Get(gomock.Any()).Return(nil, fmt.Errorf("skip http")).AnyTimes()
	252	+	mockChrExec.EXPECT().ChrootExec(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
	253	+	mockChrExec.EXPECT().ChrootPacman(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
	254	+	mockChrExec.EXPECT().ChrootSystemctl(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
	255	+	mockSysExec.EXPECT().RunSimple(gomock.Any(), gomock.Any()).Return(system.CommandResult{ExitCode: 0}).AnyTimes()
	256	+
	257	+	tmpDir := t.TempDir()
	258	+	logPath := filepath.Join(tmpDir, "test.log")
	259	+	log, err := logger.New(logPath, false)
	260	+	if err != nil {
	261	+	t.Fatalf("Failed to create logger: %v", err)
	262	+	}
	263	+	defer log.Close()
	264	+
	265	+	cfg := config.NewConfig("test")
	266	+	cfg.KernelChoice = "linux"
	267	+	cfg.RawURL = "https://example.com"
	268	+
	269	+	phase := NewPostInstallPhase(cfg, log, mockFS, mockHTTP, mockSysExec, mockChrExec)
	270	+
	271	+	progressChan := make(chan ProgressUpdate, 100)
	272	+
	273	+	// Note: Full Execute testing is complex due to multiple async operations
	274	+	result := phase.Execute(progressChan)
	275	+
	276	+	// Verify result structure is valid
	277	+	_ = result // If we got here, Execute returned a valid result structure
	278	+	}
	279	+
	280	+	// TestPostInstallPhaseEncryptionHandling tests encryption-aware operations
	281	+	func TestPostInstallPhaseEncryptionHandling(t *testing.T) {
	282	+	tests := []struct {
	283	+	name string
	284	+	encryptionType string
	285	+	expectedClosing bool
	286	+	}{
	287	+	{
	288	+	name: "Unencrypted - no closing needed",
	289	+	encryptionType: config.EncryptionNone,
	290	+	expectedClosing: false,
	291	+	},
	292	+	{
	293	+	name: "LUKS encrypted - closing needed",
	294	+	encryptionType: config.EncryptionLUKS,
	295	+	expectedClosing: true,
	296	+	},
	297	+	{
	298	+	name: "LUKS+LVM - closing needed",
	299	+	encryptionType: config.EncryptionLUKSLVM,
	300	+	expectedClosing: true,
	301	+	},
	302	+	}
	303	+
	304	+	for _, tt := range tests {
	305	+	t.Run(tt.name, func(t *testing.T) {
	306	+	ctrl := gomock.NewController(t)
	307	+	defer ctrl.Finish()
	308	+
	309	+	mockFS := mocks.NewMockFileSystem(ctrl)
	310	+	mockHTTP := mocks.NewMockHTTPClient(ctrl)
	311	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	312	+	mockChrExec := mocks.NewMockChrootExecutor(ctrl)
	313	+
	314	+	tmpDir := t.TempDir()
	315	+	logPath := filepath.Join(tmpDir, "test.log")
	316	+	log, err := logger.New(logPath, false)
	317	+	if err != nil {
	318	+	t.Fatalf("Failed to create logger: %v", err)
	319	+	}
	320	+	defer log.Close()
	321	+
	322	+	cfg := config.NewConfig("test")
	323	+	cfg.EncryptionType = tt.encryptionType
	324	+
	325	+	phase := NewPostInstallPhase(cfg, log, mockFS, mockHTTP, mockSysExec, mockChrExec)
	326	+
	327	+	// Verify encryption type is stored correctly
	328	+	if phase.config.EncryptionType != tt.encryptionType {
	329	+	t.Errorf("Encryption type = %q, want %q", phase.config.EncryptionType, tt.encryptionType)
	330	+	}
	331	+
	332	+	// Verify closing would be needed based on encryption
	333	+	needsClosing := tt.encryptionType == config.EncryptionLUKS \|\| tt.encryptionType == config.EncryptionLUKSLVM
	334	+	if needsClosing != tt.expectedClosing {
	335	+	t.Errorf("Closing needed = %v, want %v", needsClosing, tt.expectedClosing)
	336	+	}
	337	+	})
	338	+	}
	339	+	}
	340	+
	341	+	// TestPostInstallPhaseFileSystemOperations tests file system interaction patterns
	342	+	func TestPostInstallPhaseFileSystemOperations(t *testing.T) {
	343	+	tests := []struct {
	344	+	name string
	345	+	operation string // "read", "write", "mkdir", "create"
	346	+	}{
	347	+	{
	348	+	name: "Read pacman.conf",
	349	+	operation: "read",
	350	+	},
	351	+	{
	352	+	name: "Write pacman.conf",
	353	+	operation: "write",
	354	+	},
	355	+	{
	356	+	name: "Create hook directory",
	357	+	operation: "mkdir",
	358	+	},
	359	+	{
	360	+	name: "Create hook file",
	361	+	operation: "create",
	362	+	},
	363	+	}
	364	+
	365	+	for _, tt := range tests {
	366	+	t.Run(tt.name, func(t *testing.T) {
	367	+	ctrl := gomock.NewController(t)
	368	+	defer ctrl.Finish()
	369	+
	370	+	mockFS := mocks.NewMockFileSystem(ctrl)
	371	+	mockHTTP := mocks.NewMockHTTPClient(ctrl)
	372	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	373	+	mockChrExec := mocks.NewMockChrootExecutor(ctrl)
	374	+
	375	+	// Setup basic expectations based on operation
	376	+	switch tt.operation {
	377	+	case "read":
	378	+	mockFS.EXPECT().ReadFile(gomock.Any()).Return([]byte("content"), nil).AnyTimes()
	379	+	case "write":
	380	+	mockFS.EXPECT().WriteFile(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
	381	+	case "mkdir":
	382	+	mockFS.EXPECT().MkdirAll(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
	383	+	case "create":
	384	+	mockFS.EXPECT().Create(gomock.Any()).Return(&MockWriteCloser{}, nil).AnyTimes()
	385	+	}
	386	+
	387	+	tmpDir := t.TempDir()
	388	+	logPath := filepath.Join(tmpDir, "test.log")
	389	+	log, err := logger.New(logPath, false)
	390	+	if err != nil {
	391	+	t.Fatalf("Failed to create logger: %v", err)
	392	+	}
	393	+	defer log.Close()
	394	+
	395	+	cfg := config.NewConfig("test")
	396	+	phase := NewPostInstallPhase(cfg, log, mockFS, mockHTTP, mockSysExec, mockChrExec)
	397	+
	398	+	// Verify phase can be created
	399	+	if phase == nil {
	400	+	t.Error("PostInstallPhase is nil")
	401	+	}
	402	+	})
	403	+	}
	404	+	}
	405	+
	406	+	// TestPostInstallPhaseKernelVerification tests kernel verification logic
	407	+	func TestPostInstallPhaseKernelVerification(t *testing.T) {
	408	+	tests := []struct {
	409	+	name string
	410	+	kernelChoice string
	411	+	expectedFormat string
	412	+	}{
	413	+	{
	414	+	name: "Linux kernel",
	415	+	kernelChoice: "linux",
	416	+	expectedFormat: "vmlinuz-linux",
	417	+	},
	418	+	{
	419	+	name: "Linux LTS kernel",
	420	+	kernelChoice: "linux-lts",
	421	+	expectedFormat: "vmlinuz-linux-lts",
	422	+	},
	423	+	{
	424	+	name: "Linux Zen kernel",
	425	+	kernelChoice: "linux-zen",
	426	+	expectedFormat: "vmlinuz-linux-zen",
	427	+	},
	428	+	}
	429	+
	430	+	for _, tt := range tests {
	431	+	t.Run(tt.name, func(t *testing.T) {
	432	+	ctrl := gomock.NewController(t)
	433	+	defer ctrl.Finish()
	434	+
	435	+	mockFS := mocks.NewMockFileSystem(ctrl)
	436	+	mockHTTP := mocks.NewMockHTTPClient(ctrl)
	437	+	mockSysExec := mocks.NewMockSystemExecutor(ctrl)
	438	+	mockChrExec := mocks.NewMockChrootExecutor(ctrl)
	439	+
	440	+	tmpDir := t.TempDir()
	441	+	logPath := filepath.Join(tmpDir, "test.log")
	442	+	log, err := logger.New(logPath, false)
	443	+	if err != nil {
	444	+	t.Fatalf("Failed to create logger: %v", err)
	445	+	}
	446	+	defer log.Close()
	447	+
	448	+	cfg := config.NewConfig("test")
	449	+	cfg.KernelChoice = tt.kernelChoice
	450	+
	451	+	phase := NewPostInstallPhase(cfg, log, mockFS, mockHTTP, mockSysExec, mockChrExec)
	452	+
	453	+	// Verify kernel choice is stored
	454	+	if phase.config.KernelChoice != tt.kernelChoice {
	455	+	t.Errorf("Kernel choice = %q, want %q", phase.config.KernelChoice, tt.kernelChoice)
	456	+	}
	457	+
	458	+	// Verify expected kernel name format
	459	+	expectedKernelName := fmt.Sprintf("vmlinuz-%s", tt.kernelChoice)
	460	+	if !containsSubstring(expectedKernelName, "vmlinuz") {
	461	+	t.Errorf("Expected kernel name format %q doesn't contain 'vmlinuz'", expectedKernelName)
	462	+	}
	463	+	})
	464	+	}
	465	+	}

M internal/phases/preflight.go +11 -8

 import (
 	"fmt"
-	"os"
-	"os/exec"
 	"strings"
 	"github.com/bnema/archup/internal/config"
+	"github.com/bnema/archup/internal/interfaces"
 	"github.com/bnema/archup/internal/logger"
 )
 // PreflightPhase handles system validation and initial configuration
 type PreflightPhase struct {
 	*BasePhase
+	fs      interfaces.FileSystem
+	cmdExec interfaces.CommandExecutor
 }
 // NewPreflightPhase creates a new preflight phase
-func NewPreflightPhase(cfg *config.Config, log *logger.Logger) *PreflightPhase {
+func NewPreflightPhase(cfg *config.Config, log *logger.Logger, fs interfaces.FileSystem, cmdExec interfaces.CommandExecutor) *PreflightPhase {
 	return &PreflightPhase{
 		BasePhase: NewBasePhase("preflight", "Preflight Checks", cfg, log),
+		fs:        fs,
+		cmdExec:   cmdExec,
 	}
 }
 // PreCheck validates system requirements
 func (p *PreflightPhase) PreCheck() error {
 	// Check for Arch Linux
-	if _, err := os.Stat("/etc/arch-release"); os.IsNotExist(err) {
+	if _, err := p.fs.Stat("/etc/arch-release"); p.fs.IsNotExist(err) {
 		return fmt.Errorf("must be running on Arch Linux or Arch ISO")
 	}
 	}
 	for marker, name := range derivatives {
-		if _, err := os.Stat(marker); err == nil {
+		if _, err := p.fs.Stat(marker); err == nil {
 			return fmt.Errorf("must be vanilla Arch (detected %s)", name)
 		}
 	}
 	// Check architecture
-	out, err := exec.Command("uname", "-m").Output()
+	out, err := p.cmdExec.Execute("uname", "-m")
 	arch := strings.TrimSpace(string(out))
 	switch {
 	}
 	// Check UEFI
-	if _, err := os.Stat("/sys/firmware/efi/efivars"); os.IsNotExist(err) {
+	if _, err := p.fs.Stat("/sys/firmware/efi/efivars"); p.fs.IsNotExist(err) {
 		return fmt.Errorf("must be UEFI boot mode (legacy BIOS not supported)")
 	}
 	// Check Secure Boot
-	out, err = exec.Command("bootctl", "status").Output()
+	out, err = p.cmdExec.Execute("bootctl", "status")
 	switch {
 	case err == nil && strings.Contains(string(out), "Secure Boot: enabled"):
 		return fmt.Errorf("Secure Boot must be disabled")

M internal/phases/repos.go +37 -44

 import (
 	"bufio"
 	"fmt"
-	"os"
 	"path/filepath"
 	"strings"
 	"github.com/bnema/archup/internal/config"
+	"github.com/bnema/archup/internal/interfaces"
 	"github.com/bnema/archup/internal/logger"
-	"github.com/bnema/archup/internal/system"
 )
 // Pacman configuration constants
 // ReposPhase handles repository configuration
 type ReposPhase struct {
 	*BasePhase
+	fs            interfaces.FileSystem
+	sysExec       interfaces.SystemExecutor
+	chrExec       interfaces.ChrootExecutor
 	chaoticConfig map[string]string
 }
 // NewReposPhase creates a new repos phase
-func NewReposPhase(cfg *config.Config, log *logger.Logger) *ReposPhase {
+func NewReposPhase(cfg *config.Config, log *logger.Logger, fs interfaces.FileSystem, sysExec interfaces.SystemExecutor, chrExec interfaces.ChrootExecutor) *ReposPhase {
 	return &ReposPhase{
 		BasePhase:     NewBasePhase("repos", "Repository Configuration", cfg, log),
+		fs:            fs,
+		sysExec:       sysExec,
+		chrExec:       chrExec,
 		chaoticConfig: make(map[string]string),
 	}
 }
 	}
 	// Verify /mnt is mounted
-	result := system.RunSimple("mountpoint", "-q", config.PathMnt)
+	result := p.sysExec.RunSimple("mountpoint", "-q", config.PathMnt)
 	switch {
 	case result.ExitCode != 0:
 		return fmt.Errorf("%s is not mounted", config.PathMnt)
 	}
 	// Verify pacman.conf exists
-	switch _, err := os.Stat(config.PathMntEtcPacmanConf); {
+	switch _, err := p.fs.Stat(config.PathMntEtcPacmanConf); {
-	case os.IsNotExist(err):
+	case p.fs.IsNotExist(err):
 		return fmt.Errorf("pacman.conf not found")
 	}
 func (p *ReposPhase) syncDatabases(progressChan chan<- ProgressUpdate) error {
 	p.SendOutput(progressChan, "Syncing package databases...")
-	switch err := system.ChrootExec(p.logger.LogPath(), config.PathMnt, "pacman -Sy --noconfirm"); {
+	switch err := p.chrExec.ChrootExec(p.logger.LogPath(), config.PathMnt, "pacman -Sy --noconfirm"); {
 	case err != nil:
 		return fmt.Errorf("failed to sync databases: %w", err)
 	}
 	p.SendOutput(progressChan, "Enabling multilib repository...")
 	// Read pacman.conf
-	content, err := os.ReadFile(config.PathMntEtcPacmanConf)
+	content, err := p.fs.ReadFile(config.PathMntEtcPacmanConf)
 	switch {
 	case err != nil:
 		return fmt.Errorf("failed to read pacman.conf: %w", err)
 	contentStr = strings.Join(lines, "\n")
 	// Write updated config
-	switch err := os.WriteFile(config.PathMntEtcPacmanConf, []byte(contentStr), 0644); {
+	switch err := p.fs.WriteFile(config.PathMntEtcPacmanConf, []byte(contentStr), 0644); {
 	case err != nil:
 		return fmt.Errorf("failed to write pacman.conf: %w", err)
 	}
 func (p *ReposPhase) loadChaoticConfig() error {
 	configPath := p.getInstallPath(config.ChaoticConfigFile)
-	file, err := os.Open(configPath)
+	file, err := p.fs.Open(configPath)
 	switch {
 	case err != nil:
 		return fmt.Errorf("failed to open chaotic config: %w", err)
 	// Import GPG key
 	recvKeyCmd := fmt.Sprintf("pacman-key --recv-key %s --keyserver %s", keyID, keyserver)
-	switch err := system.ChrootExec(p.logger.LogPath(), config.PathMnt, recvKeyCmd); {
+	switch err := p.chrExec.ChrootExec(p.logger.LogPath(), config.PathMnt, recvKeyCmd); {
 	case err != nil:
 		p.logger.Warn("Failed to receive Chaotic GPG key, skipping Chaotic-AUR", "error", err)
 		p.SendOutput(progressChan, "[WARN] Chaotic-AUR unavailable (GPG key fetch failed)")
 	// Locally sign the key
 	lsignKeyCmd := fmt.Sprintf("pacman-key --lsign-key %s", keyID)
-	switch err := system.ChrootExec(p.logger.LogPath(), config.PathMnt, lsignKeyCmd); {
+	switch err := p.chrExec.ChrootExec(p.logger.LogPath(), config.PathMnt, lsignKeyCmd); {
 	case err != nil:
 		p.logger.Warn("Failed to sign Chaotic GPG key, skipping Chaotic-AUR", "error", err)
 		p.SendOutput(progressChan, "[WARN] Chaotic-AUR unavailable (GPG key signing failed)")
 	// Download and install chaotic-keyring and chaotic-mirrorlist
 	p.SendOutput(progressChan, "Downloading Chaotic-AUR packages...")
-	switch err := system.DownloadAndInstallPackages(p.logger.LogPath(), config.PathMnt, keyringURL, mirrorlistURL); {
+	switch err := p.chrExec.DownloadAndInstallPackages(p.logger.LogPath(), config.PathMnt, keyringURL, mirrorlistURL); {
 	case err != nil:
 		p.logger.Warn("Chaotic-AUR packages unavailable, skipping", "error", err)
 		p.SendOutput(progressChan, "[WARN] Chaotic-AUR unavailable, skipping (AUR helper will be built from source)")
 	p.SendOutput(progressChan, "[OK] Chaotic packages installed")
 	// Add Chaotic-AUR to pacman.conf
-	content, err := os.ReadFile(config.PathMntEtcPacmanConf)
+	content, err := p.fs.ReadFile(config.PathMntEtcPacmanConf)
 	switch {
 	case err != nil:
 		return fmt.Errorf("failed to read pacman.conf: %w", err)
 		chaoticSection := fmt.Sprintf("\n# Chaotic-AUR repository\n[%s]\nInclude = %s\n", repoName, mirrorlistPath)
 		contentStr += chaoticSection
-		switch err := os.WriteFile(config.PathMntEtcPacmanConf, []byte(contentStr), 0644); {
+		switch err := p.fs.WriteFile(config.PathMntEtcPacmanConf, []byte(contentStr), 0644); {
 		case err != nil:
 			return fmt.Errorf("failed to write pacman.conf: %w", err)
 		}
 	}
 	// Update package databases
-	switch err := system.ChrootExec(p.logger.LogPath(),config.PathMnt, "pacman -Sy --noconfirm"); {
+	switch err := p.chrExec.ChrootExec(p.logger.LogPath(),config.PathMnt, "pacman -Sy --noconfirm"); {
 	case err != nil:
 		return fmt.Errorf("failed to update package databases: %w", err)
 	}
 	// Verify Chaotic-AUR is working
 	verifyCmd := fmt.Sprintf("pacman -Sl %s", repoName)
-	result := system.RunSimple("arch-chroot", config.PathMnt, "sh", "-c", verifyCmd)
+	result := p.sysExec.RunSimple("arch-chroot", config.PathMnt, "sh", "-c", verifyCmd)
 	switch {
 	case result.ExitCode != 0:
 		p.SendOutput(progressChan, "[WARN] Chaotic-AUR verification failed")
 	for _, pkg := range packages {
 		individualCmd := fmt.Sprintf("pacman -S --noconfirm --needed %s", pkg)
-		switch err := system.ChrootExec(p.logger.LogPath(), config.PathMnt, individualCmd); {
+		switch err := p.chrExec.ChrootExec(p.logger.LogPath(), config.PathMnt, individualCmd); {
 		case err != nil:
 			p.logger.Warn("Failed to install package", "package", pkg, "error", err)
 			failedPkgs = append(failedPkgs, pkg)
 	// Try batch installation first
 	installCmd := fmt.Sprintf("pacman -S --noconfirm --needed %s", strings.Join(packages, " "))
-	switch err := system.ChrootExec(p.logger.LogPath(), config.PathMnt, installCmd); {
+	switch err := p.chrExec.ChrootExec(p.logger.LogPath(), config.PathMnt, installCmd); {
 	case err == nil:
 		p.logger.Info("Extra packages installed successfully", "count", len(packages))
 		p.SendOutput(progressChan, fmt.Sprintf("[OK] Installed %d extra packages", len(packages)))
 func (p *ReposPhase) loadExtraPackages() ([]string, error) {
 	packageFile := p.getInstallPath(config.ExtraPackagesFile)
-	file, err := os.Open(packageFile)
+	file, err := p.fs.Open(packageFile)
 	switch {
 	case err != nil:
 		return nil, fmt.Errorf("failed to open %s: %w", packageFile, err)
 	// Ensure build dependencies are installed
 	p.SendOutput(progressChan, "Verifying build dependencies...")
 	depsCmd := "pacman -S --needed --noconfirm base-devel git"
-	switch err := system.ChrootExec(p.logger.LogPath(), config.PathMnt, depsCmd); {
+	switch err := p.chrExec.ChrootExec(p.logger.LogPath(), config.PathMnt, depsCmd); {
 	case err != nil:
 		p.logger.Warn("Failed to install build dependencies", "error", err)
 		// Don't fail, they might already be installed
 	}
-	// Build AUR helper from source
+	// Build AUR helper from source as configured user, then install as root
 	buildCmd := fmt.Sprintf(`
-		su - %s -c '
+		set -e
-			set -e
-			cd /tmp || exit 1
-			# Clean up any previous build
+		# Build as user (clone, build, etc.)
-			rm -rf %s
+		su - %s -c 'cd /tmp && rm -rf %s && git clone https://aur.archlinux.org/%s.git && cd %s && makepkg -s --noconfirm' || exit 1
-			# Clone AUR repository
+		# Install built package as root
-			git clone https://aur.archlinux.org/%s.git || exit 1
+		pacman -U --noconfirm /tmp/%s/*.pkg.tar.zst || exit 1
-			cd %s || exit 1
-			# Build and install
+		# Clean up build directory
-			makepkg -si --noconfirm || exit 1
+		rm -rf /tmp/%s
-		'
+	`, p.config.Username, p.config.AURHelper, p.config.AURHelper, p.config.AURHelper, p.config.AURHelper, p.config.AURHelper)
-	`, p.config.Username, p.config.AURHelper, p.config.AURHelper, p.config.AURHelper)
-	switch err := system.ChrootExec(p.logger.LogPath(), config.PathMnt, buildCmd); {
+	switch err := p.chrExec.ChrootExec(p.logger.LogPath(), config.PathMnt, buildCmd); {
 	case err != nil:
 		return fmt.Errorf("failed to build %s: %w", p.config.AURHelper, err)
 	}
-	// Cleanup build directory
-	cleanupCmd := fmt.Sprintf("rm -rf /tmp/%s", p.config.AURHelper)
-	switch err := system.ChrootExec(p.logger.LogPath(), config.PathMnt, cleanupCmd); {
-	case err != nil:
-		p.logger.Warn("Failed to cleanup AUR helper build directory", "error", err)
-		// Don't fail, just warn
-	}
 	p.SendOutput(progressChan, fmt.Sprintf("[OK] %s built and installed successfully", p.config.AURHelper))
 	return nil
 // PostCheck validates repository configuration
 func (p *ReposPhase) PostCheck() error {
 	// Verify pacman.conf was modified
-	content, err := os.ReadFile(config.PathMntEtcPacmanConf)
+	content, err := p.fs.ReadFile(config.PathMntEtcPacmanConf)
 	switch {
 	case err != nil:
 		return fmt.Errorf("failed to read pacman.conf: %w", err)

M internal/phases/repos_test.go +12 -3

 	"testing"
 	"github.com/bnema/archup/internal/config"
+	"github.com/bnema/archup/internal/interfaces/mocks"
 	"github.com/bnema/archup/internal/logger"
+	"github.com/bnema/archup/internal/system"
+	"go.uber.org/mock/gomock"
 )
 // TestEnableMultilibParsing tests the multilib section and Include line parsing
 			mockSysExec := mocks.NewMockSystemExecutor(ctrl)
 			mockChrExec := mocks.NewMockChrootExecutor(ctrl)
+			// Set up expected mock calls based on whether we'll pass AUR helper validation
+			// AUR helper validation happens first, so if invalid helper, we won't call RunSimple
+			if !tt.expectError || (tt.expectError && tt.errorMsg != "invalid AUR helper") {
+				mockSysExec.EXPECT().RunSimple("mountpoint", "-q", config.PathMnt).Return(system.CommandResult{ExitCode: 0}).Times(1)
+				mockFS.EXPECT().Stat(config.PathMntEtcPacmanConf).Return(mockFileInfo{}, nil).Times(1)
+				mockFS.EXPECT().IsNotExist(gomock.Any()).Return(false).Times(1)
+			}
 			// Create ReposPhase
 			phase := NewReposPhase(cfg, log, mockFS, mockSysExec, mockChrExec)
-			// Note: PreCheck also validates /mnt is mounted and pacman.conf exists
+			// Note: PreCheck validates AUR helper first, then /mnt is mounted, and pacman.conf exists
-			// In a real test environment, these would fail, so we're only testing
-			// the validation logic here by checking the error message
 			err := phase.PreCheck()
 			if tt.expectError {

M internal/phases/systemconfig.go +29 -24

 import (
 	"fmt"
-	"os"
 	"path/filepath"
 	"github.com/bnema/archup/internal/config"
+	"github.com/bnema/archup/internal/interfaces"
 	"github.com/bnema/archup/internal/logger"
-	"github.com/bnema/archup/internal/system"
 )
 // ConfigPhase handles system configuration
 type ConfigPhase struct {
 	*BasePhase
+	fs      interfaces.FileSystem
+	sysExec interfaces.SystemExecutor
+	chrExec interfaces.ChrootExecutor
 }
 // NewConfigPhase creates a new config phase
-func NewConfigPhase(cfg *config.Config, log *logger.Logger) *ConfigPhase {
+func NewConfigPhase(cfg *config.Config, log *logger.Logger, fs interfaces.FileSystem, sysExec interfaces.SystemExecutor, chrExec interfaces.ChrootExecutor) *ConfigPhase {
 	return &ConfigPhase{
 		BasePhase: NewBasePhase("config", "System Configuration", cfg, log),
+		fs:        fs,
+		sysExec:   sysExec,
+		chrExec:   chrExec,
 	}
 }
 // PreCheck validates configuration prerequisites
 func (p *ConfigPhase) PreCheck() error {
 	// Verify /mnt is mounted
-	result := system.RunSimple("mountpoint", "-q", config.PathMnt)
+	result := p.sysExec.RunSimple("mountpoint", "-q", config.PathMnt)
 	switch {
 	case result.ExitCode != 0:
 		return fmt.Errorf("%s is not mounted", config.PathMnt)
 	// Set timezone
 	timezonePath := filepath.Join(config.PathUsrShareZoneinfo, p.config.Timezone)
 	tzCmd := fmt.Sprintf("ln -sf %s %s", timezonePath, config.PathEtcLocaltime)
-	switch err := system.ChrootExec(p.logger.LogPath(),config.PathMnt, tzCmd); {
+	switch err := p.chrExec.ChrootExec(p.logger.LogPath(),config.PathMnt, tzCmd); {
 	case err != nil:
 		return fmt.Errorf("failed to set timezone: %w", err)
 	}
 	// Set hardware clock
-	switch err := system.ChrootExec(p.logger.LogPath(),config.PathMnt, "hwclock --systohc"); {
+	switch err := p.chrExec.ChrootExec(p.logger.LogPath(),config.PathMnt, "hwclock --systohc"); {
 	case err != nil:
 		return fmt.Errorf("failed to set hardware clock: %w", err)
 	}
 	// Set locale
 	localeGen := p.config.Locale + " UTF-8\n"
-	switch err := os.WriteFile(config.PathMntEtcLocaleGen, []byte(localeGen), 0644); {
+	switch err := p.fs.WriteFile(config.PathMntEtcLocaleGen, []byte(localeGen), 0644); {
 	case err != nil:
 		return fmt.Errorf("failed to write locale.gen: %w", err)
 	}
-	switch err := system.ChrootExec(p.logger.LogPath(),config.PathMnt, "locale-gen"); {
+	switch err := p.chrExec.ChrootExec(p.logger.LogPath(),config.PathMnt, "locale-gen"); {
 	case err != nil:
 		return fmt.Errorf("failed to generate locale: %w", err)
 	}
 	localeConf := fmt.Sprintf("LANG=%s\n", p.config.Locale)
-	switch err := os.WriteFile(config.PathMntEtcLocaleConf, []byte(localeConf), 0644); {
+	switch err := p.fs.WriteFile(config.PathMntEtcLocaleConf, []byte(localeConf), 0644); {
 	case err != nil:
 		return fmt.Errorf("failed to write locale.conf: %w", err)
 	}
 	switch {
 	case p.config.Keymap != "":
 		vconsoleConf := fmt.Sprintf("KEYMAP=%s\n", p.config.Keymap)
-		switch err := os.WriteFile(config.PathMntEtcVconsole, []byte(vconsoleConf), 0644); {
+		switch err := p.fs.WriteFile(config.PathMntEtcVconsole, []byte(vconsoleConf), 0644); {
 		case err != nil:
 			return fmt.Errorf("failed to write vconsole.conf: %w", err)
 		}
 	}
 	// Set hostname
-	switch err := os.WriteFile(config.PathMntEtcHostname, []byte(p.config.Hostname+"\n"), 0644); {
+	switch err := p.fs.WriteFile(config.PathMntEtcHostname, []byte(p.config.Hostname+"\n"), 0644); {
 	case err != nil:
 		return fmt.Errorf("failed to write hostname: %w", err)
 	}
 127.0.1.1   %s.localdomain %s
 `, p.config.Hostname, p.config.Hostname)
-	switch err := os.WriteFile(config.PathMntEtcHosts, []byte(hostsContent), 0644); {
+	switch err := p.fs.WriteFile(config.PathMntEtcHosts, []byte(hostsContent), 0644); {
 	case err != nil:
 		return fmt.Errorf("failed to write hosts file: %w", err)
 	}
 	p.SendOutput(progressChan, "Configuring network...")
 	// Enable NetworkManager service
-	switch err := system.ChrootSystemctl(p.logger.LogPath(),config.PathMnt, "enable", config.ServiceNetworkManager); {
+	switch err := p.chrExec.ChrootSystemctl(p.logger.LogPath(),config.PathMnt, "enable", config.ServiceNetworkManager); {
 	case err != nil:
 		return fmt.Errorf("failed to enable NetworkManager: %w", err)
 	}
 	// Create user with home directory
 	userAddCmd := fmt.Sprintf("useradd -m -G %s -s %s %s", config.GroupWheel, config.ShellBash, p.config.Username)
-	switch err := system.ChrootExec(p.logger.LogPath(),config.PathMnt, userAddCmd); {
+	switch err := p.chrExec.ChrootExec(p.logger.LogPath(),config.PathMnt, userAddCmd); {
 	case err != nil:
 		return fmt.Errorf("failed to create user: %w", err)
 	}
 	// Set user password using stdin (secure - not visible in process list)
 	userPassInput := fmt.Sprintf("%s:%s", p.config.Username, p.config.UserPassword)
-	switch err := system.ChrootExecWithStdin(p.logger.LogPath(), config.PathMnt, "chpasswd", userPassInput); {
+	switch err := p.chrExec.ChrootExecWithStdin(p.logger.LogPath(), config.PathMnt, "chpasswd", userPassInput); {
 	case err != nil:
 		return fmt.Errorf("failed to set user password: %w", err)
 	}
 	// Enable sudo for wheel group (passwordless for convenience)
-	switch err := os.WriteFile(config.PathMntEtcSudoersD, []byte(config.SudoersWheelContent), config.SudoersWheelPerms); {
+	switch err := p.fs.WriteFile(config.PathMntEtcSudoersD, []byte(config.SudoersWheelContent), config.SudoersWheelPerms); {
 	case err != nil:
 		return fmt.Errorf("failed to write sudoers config: %w", err)
 	}
 	// Create zram-generator config
 	zramConfigPath := filepath.Join(config.PathMntEtcSystemd, config.FileZramGenerator)
-	switch err := os.WriteFile(zramConfigPath, []byte(config.ZramConfigContent), 0644); {
+	switch err := p.fs.WriteFile(zramConfigPath, []byte(config.ZramConfigContent), 0644); {
 	case err != nil:
 		return fmt.Errorf("failed to write zram-generator.conf: %w", err)
 	}
 	// Create sysctl config for zram optimization
 	sysctlConfigPath := filepath.Join(config.PathMntEtcSysctlD, config.FileSysctlZramParams)
-	switch err := os.WriteFile(sysctlConfigPath, []byte(config.ZramSysctlContent), 0644); {
+	switch err := p.fs.WriteFile(sysctlConfigPath, []byte(config.ZramSysctlContent), 0644); {
 	case err != nil:
 		return fmt.Errorf("failed to write sysctl zram config: %w", err)
 	}
 // PostCheck validates configuration
 func (p *ConfigPhase) PostCheck() error {
 	// Verify hostname was set
-	switch _, err := os.Stat(config.PathMntEtcHostname); {
+	switch _, err := p.fs.Stat(config.PathMntEtcHostname); {
-	case os.IsNotExist(err):
+	case p.fs.IsNotExist(err):
 		return fmt.Errorf("hostname file was not created")
 	}
 	// Verify locale was set
-	switch _, err := os.Stat(config.PathMntEtcLocaleConf); {
+	switch _, err := p.fs.Stat(config.PathMntEtcLocaleConf); {
-	case os.IsNotExist(err):
+	case p.fs.IsNotExist(err):
 		return fmt.Errorf("locale.conf was not created")
 	}
 	// Verify zram config exists
 	zramConfigPath := filepath.Join(config.PathMntEtcSystemd, config.FileZramGenerator)
-	switch _, err := os.Stat(zramConfigPath); {
+	switch _, err := p.fs.Stat(zramConfigPath); {
-	case os.IsNotExist(err):
+	case p.fs.IsNotExist(err):
 		return fmt.Errorf("zram-generator.conf was not created")
 	}

A internal/ui/assets/assets.go +6 -0

@@ -0,0 +1,6 @@
	1	+	package assets
	2	+
	3	+	import _ "embed"
	4	+
	5	+	//go:embed logo.txt
	6	+	var LogoASCII string

A internal/ui/assets/logo.txt +6 -0

@@ -0,0 +1,6 @@
	1	+	░█████╗░██████╗░░█████╗░██╗░░██╗██╗░░░██╗██████╗░
	2	+	██╔══██╗██╔══██╗██╔══██╗██║░░██║██║░░░██║██╔══██╗
	3	+	███████║██████╔╝██║░░╚═╝███████║██║░░░██║██████╔╝
	4	+	██╔══██║██╔══██╗██║░░██╗██╔══██║██║░░░██║██╔═══╝░
	5	+	██║░░██║██║░░██║╚█████╔╝██║░░██║╚██████╔╝██║░░░░░
	6	+	╚═╝░░╚═╝╚═╝░░╚═╝░╚════╝░╚═╝░░╚═╝░╚═════╝░╚═╝░░░░░

D internal/ui/logo.go +0 -109

@@ -1,109 +0,0 @@
1	-	package ui
2	-
3	-	import (
4	-	"fmt"
5	-	"strings"
6	-
7	-	"github.com/charmbracelet/lipgloss"
8	-	"github.com/bnema/archup/internal/ui/styles"
9	-	)
10	-
11	-	const (
12	-	// Logo ASCII art (from logo.txt)
13	-	logoASCII = ` ░█████╗░██████╗░░█████╗░██╗░░██╗██╗░░░██╗██████╗░
14	-	██╔══██╗██╔══██╗██╔══██╗██║░░██║██║░░░██║██╔══██╗
15	-	███████║██████╔╝██║░░╚═╝███████║██║░░░██║██████╔╝
16	-	██╔══██║██╔══██╗██║░░██╗██╔══██║██║░░░██║██╔═══╝░
17	-	██║░░██║██║░░██║╚█████╔╝██║░░██║╚██████╔╝██║░░░░░
18	-	╚═╝░░╚═╝╚═╝░░╚═╝░╚════╝░╚═╝░░╚═╝░╚═════╝░╚═╝░░░░░`
19	-	)
20	-
21	-	// Logo represents the ArchUp logo display
22	-	type Logo struct {
23	-	width int
24	-	height int
25	-	version string
26	-	}
27	-
28	-	// NewLogo creates a new Logo instance
29	-	// version should be injected via ldflags: -ldflags "-X main.version=v1.0.0"
30	-	func NewLogo(version string) *Logo {
31	-	lines := strings.Split(logoASCII, "\n")
32	-	width := 0
33	-	for _, line := range lines {
34	-	if len(line) > width {
35	-	width = len(line)
36	-	}
37	-	}
38	-
39	-	if version == "" {
40	-	version = "dev"
41	-	}
42	-
43	-	return &Logo{
44	-	width: width,
45	-	height: len(lines),
46	-	version: version,
47	-	}
48	-	}
49	-
50	-	// Render renders the logo in full blue
51	-	func (l *Logo) Render() string {
52	-	lines := strings.Split(logoASCII, "\n")
53	-	var rendered strings.Builder
54	-
55	-	for _, line := range lines {
56	-	if len(line) == 0 {
57	-	rendered.WriteString("\n")
58	-	continue
59	-	}
60	-
61	-	// Render entire logo in blue
62	-	rendered.WriteString(styles.LogoCyanStyle.Render(line))
63	-	rendered.WriteString("\n")
64	-	}
65	-
66	-	// Add version below logo
67	-	rendered.WriteString("\n")
68	-	versionLine := " " + l.version
69	-	rendered.WriteString(styles.LogoCyanStyle.Render(versionLine))
70	-	rendered.WriteString("\n")
71	-
72	-	return rendered.String()
73	-	}
74	-
75	-	// RenderCentered renders the logo centered using lipgloss alignment
76	-	func (l *Logo) RenderCentered(termWidth int) string {
77	-	return l.Render()
78	-	}
79	-
80	-	// Width returns the logo width
81	-	func (l *Logo) Width() int {
82	-	return l.width
83	-	}
84	-
85	-	// Height returns the logo height (including version line)
86	-	func (l *Logo) Height() int {
87	-	return l.height + 2 // +2 for blank line and version
88	-	}
89	-
90	-	// ClearScreen clears the screen and displays the logo at the top
91	-	func ClearScreen(termWidth int, version string) string {
92	-	logo := NewLogo(version)
93	-	return fmt.Sprintf("\033[H\033[2J\n%s", logo.RenderCentered(termWidth))
94	-	}
95	-
96	-	// RenderWithMessage renders the logo with a message below it
97	-	func RenderWithMessage(termWidth int, version, message string) string {
98	-	logo := NewLogo(version)
99	-	logoStr := logo.RenderCentered(termWidth)
100	-
101	-	// Center the message
102	-	paddingLeft := (termWidth - lipgloss.Width(message)) / 2
103	-	if paddingLeft < 0 {
104	-	paddingLeft = 0
105	-	}
106	-	padding := strings.Repeat(" ", paddingLeft)
107	-
108	-	return fmt.Sprintf("%s\n%s%s\n", logoStr, padding, message)
109	-	}

M internal/ui/styles/theme.go +3 -0


@@ -163,6 +163,9 @@ var (
163	LogoWhiteStyle = lipgloss.NewStyle().	163		LogoWhiteStyle = lipgloss.NewStyle().
164	Foreground(ColorPureWhite)	164		Foreground(ColorPureWhite)
165		165
		166	+	LogoBlueStyle = lipgloss.NewStyle().
		167	+	Foreground(ColorSkyBlue)
		168	+
166	// Progress/Spinner styles	169		// Progress/Spinner styles
167	SpinnerStyle = lipgloss.NewStyle().	170		SpinnerStyle = lipgloss.NewStyle().
168	Foreground(ColorBrightCyan)	171		Foreground(ColorBrightCyan)

M internal/ui/views/helpers.go +20 -15

 package views
 import (
-	"fmt"
 	"strings"
+	"github.com/bnema/archup/internal/ui/assets"
 	"github.com/bnema/archup/internal/ui/styles"
 	"github.com/charmbracelet/lipgloss"
 )
 const (
 	WelcomeTagline = "A minimal, slightly opinionated Arch Linux installer."
-	logoASCII = `  ░█████╗░██████╗░░█████╗░██╗░░██╗██╗░░░██╗██████╗░
-  ██╔══██╗██╔══██╗██╔══██╗██║░░██║██║░░░██║██╔══██╗
-  ███████║██████╔╝██║░░╚═╝███████║██║░░░██║██████╔╝
-  ██╔══██║██╔══██╗██║░░██╗██╔══██║██║░░░██║██╔═══╝░
-  ██║░░██║██║░░██║╚█████╔╝██║░░██║╚██████╔╝██║░░░░░
-  ╚═╝░░╚═╝╚═╝░░╚═╝░╚════╝░╚═╝░░╚═╝░╚═════╝░╚═╝░░░░░`
 )
 // Logo represents the ArchUp logo display
 // NewLogo creates a new Logo instance
 func NewLogo(version string) *Logo {
-	lines := strings.Split(logoASCII, "\n")
+	lines := strings.Split(assets.LogoASCII, "\n")
 	width := 0
 	for _, line := range lines {
 		if len(line) > width {
 	return l.Render()
 }
-// Render renders the logo with theme colors
+// Render renders the logo with character-level styling
 func (l *Logo) Render() string {
-	lines := strings.Split(logoASCII, "\n")
+	lines := strings.Split(assets.LogoASCII, "\n")
 	var rendered strings.Builder
 	for _, line := range lines {
 			continue
 		}
-		// Apply bright cyan color to the logo
+		// Apply conditional styling based on character
-		rendered.WriteString(styles.LogoCyanStyle.Render(line))
+		var styledLine strings.Builder
+		for _, ch := range line {
+			if string(ch) == "░" {
+				// Use darker blue for border character
+				styledLine.WriteString(styles.LogoBlueStyle.Render(string(ch)))
+			} else {
+				// Use bright cyan for main logo
+				styledLine.WriteString(styles.LogoCyanStyle.Render(string(ch)))
+			}
+		}
+		rendered.WriteString(styledLine.String())
 		rendered.WriteString("\n")
 	}
+	// Add version below logo
+	rendered.WriteString("\n")
+	versionLine := "  " + l.version
+	rendered.WriteString(styles.HelpStyle.Render(versionLine))
 	rendered.WriteString("\n")
-	// Apply dimmed style to version
-	rendered.WriteString(styles.HelpStyle.Render(fmt.Sprintf("  %s\n", l.version)))
 	return rendered.String()
 }