aptly/cmd/mirror_update_test.go

package cmd

import (
	"errors"
	"fmt"
	"net/url"
	"os"
	"sync"
	"testing"

	"github.com/aptly-dev/aptly/aptly"
	"github.com/aptly-dev/aptly/deb"
	"github.com/aptly-dev/aptly/pgp"
	"github.com/aptly-dev/aptly/query"
	ctx "github.com/aptly-dev/aptly/context"
	"github.com/smira/commander"
	"github.com/smira/flag"
	. "gopkg.in/check.v1"
)

type MirrorUpdateSuite struct {
	cmd              *commander.Command
	originalContext  *ctx.AptlyContext
}

var _ = Suite(&MirrorUpdateSuite{})

func (s *MirrorUpdateSuite) SetUpTest(c *C) {
	s.originalContext = context
	s.cmd = makeCmdMirrorUpdate()
}

func (s *MirrorUpdateSuite) TearDownTest(c *C) {
	if context != nil && context != s.originalContext {
		context.Shutdown()
	}
	context = s.originalContext
}

func (s *MirrorUpdateSuite) setupMockContext(c *C) {
	// Create a mock context for testing
	flags := flag.NewFlagSet("test", flag.ContinueOnError)
	flags.Bool("force", false, "force update")
	flags.Bool("ignore-signatures", false, "ignore signatures")
	flags.Bool("ignore-checksums", false, "ignore checksums")
	flags.Bool("skip-existing-packages", false, "skip existing")
	
	err := InitContext(flags)
	c.Assert(err, IsNil)
}

func (s *MirrorUpdateSuite) TestMakeCmdMirrorUpdate(c *C) {
	// Test that makeCmdMirrorUpdate creates a proper command
	cmd := makeCmdMirrorUpdate()
	
	c.Check(cmd, NotNil)
	c.Check(cmd.Run, NotNil)
	c.Check(cmd.UsageLine, Equals, "update <name>")
	c.Check(cmd.Short, Equals, "update mirror")
	c.Check(cmd.Long, Not(Equals), "")
	
	// Check that all expected flags are present
	c.Check(cmd.Flag.Lookup("force"), NotNil)
	c.Check(cmd.Flag.Lookup("ignore-checksums"), NotNil)
	c.Check(cmd.Flag.Lookup("ignore-signatures"), NotNil)
	c.Check(cmd.Flag.Lookup("skip-existing-packages"), NotNil)
	c.Check(cmd.Flag.Lookup("download-limit"), NotNil)
	c.Check(cmd.Flag.Lookup("downloader"), NotNil)
	c.Check(cmd.Flag.Lookup("max-tries"), NotNil)
	c.Check(cmd.Flag.Lookup("keyring"), NotNil)
}

func (s *MirrorUpdateSuite) TestAptlyMirrorUpdateNoArgs(c *C) {
	// Test aptlyMirrorUpdate with no arguments
	s.setupMockContext(c)
	
	err := aptlyMirrorUpdate(s.cmd, []string{})
	c.Check(err, Equals, commander.ErrCommandError)
}

func (s *MirrorUpdateSuite) TestAptlyMirrorUpdateMultipleArgs(c *C) {
	// Test aptlyMirrorUpdate with multiple arguments
	s.setupMockContext(c)
	
	err := aptlyMirrorUpdate(s.cmd, []string{"mirror1", "mirror2"})
	c.Check(err, Equals, commander.ErrCommandError)
}

func (s *MirrorUpdateSuite) TestAptlyMirrorUpdateNonexistentMirror(c *C) {
	// Test aptlyMirrorUpdate with nonexistent mirror
	s.setupMockContext(c)
	
	err := aptlyMirrorUpdate(s.cmd, []string{"nonexistent-mirror"})
	c.Check(err, NotNil)
	c.Check(err.Error(), Matches, "unable to update:.*")
}

// Mock implementations for testing
type mockRemoteRepo struct {
	name          string
	filter        string
	shouldFailAt  string
	downloadTasks []deb.PackageDownloadTask
}

func (m *mockRemoteRepo) Name() string {
	return m.name
}

func (m *mockRemoteRepo) CheckLock() error {
	if m.shouldFailAt == "lock" {
		return errors.New("mirror is locked")
	}
	return nil
}

func (m *mockRemoteRepo) Fetch(downloader aptly.Downloader, verifier pgp.Verifier, ignoreSignatures bool) error {
	if m.shouldFailAt == "fetch" {
		return errors.New("fetch failed")
	}
	return nil
}

func (m *mockRemoteRepo) DownloadPackageIndexes(progress aptly.Progress, downloader aptly.Downloader, verifier pgp.Verifier, collectionFactory *deb.CollectionFactory, ignoreSignatures, ignoreChecksums bool) error {
	if m.shouldFailAt == "download_indexes" {
		return errors.New("download package indexes failed")
	}
	return nil
}

func (m *mockRemoteRepo) ApplyFilter(options int, filterQuery deb.PackageQuery, progress aptly.Progress) (int, int, error) {
	if m.shouldFailAt == "filter" {
		return 0, 0, errors.New("filter failed")
	}
	return 100, 50, nil
}

func (m *mockRemoteRepo) BuildDownloadQueue(pool aptly.PackagePool, packageCollection *deb.PackageCollection, checksumCollection *deb.ChecksumCollection, skipExisting bool) ([]deb.PackageDownloadTask, int64, error) {
	if m.shouldFailAt == "build_queue" {
		return nil, 0, errors.New("build download queue failed")
	}
	return m.downloadTasks, 1024, nil
}

func (m *mockRemoteRepo) MarkAsUpdating() {
	// Mock implementation
}

func (m *mockRemoteRepo) MarkAsIdle() {
	// Mock implementation
}

func (m *mockRemoteRepo) PackageURL(downloadURL string) *url.URL {
	// Mock implementation - return a simple URL
	u, _ := url.Parse("http://example.com/" + downloadURL)
	return u
}

func (m *mockRemoteRepo) FinalizeDownload(collectionFactory *deb.CollectionFactory, progress aptly.Progress) error {
	if m.shouldFailAt == "finalize" {
		return errors.New("finalize failed")
	}
	return nil
}

func (s *MirrorUpdateSuite) TestMirrorUpdateFlagParsing(c *C) {
	// Test that command flags are properly parsed and used
	cmd := makeCmdMirrorUpdate()
	
	// Test default flag values
	forceFlag := cmd.Flag.Lookup("force")
	c.Check(forceFlag, NotNil)
	c.Check(forceFlag.DefValue, Equals, "false")
	
	ignoreChecksumsFlag := cmd.Flag.Lookup("ignore-checksums")
	c.Check(ignoreChecksumsFlag, NotNil)
	c.Check(ignoreChecksumsFlag.DefValue, Equals, "false")
	
	ignoreSignaturesFlag := cmd.Flag.Lookup("ignore-signatures")
	c.Check(ignoreSignaturesFlag, NotNil)
	c.Check(ignoreSignaturesFlag.DefValue, Equals, "false")
	
	skipExistingFlag := cmd.Flag.Lookup("skip-existing-packages")
	c.Check(skipExistingFlag, NotNil)
	c.Check(skipExistingFlag.DefValue, Equals, "false")
	
	downloadLimitFlag := cmd.Flag.Lookup("download-limit")
	c.Check(downloadLimitFlag, NotNil)
	c.Check(downloadLimitFlag.DefValue, Equals, "0")
	
	downloaderFlag := cmd.Flag.Lookup("downloader")
	c.Check(downloaderFlag, NotNil)
	c.Check(downloaderFlag.DefValue, Equals, "default")
	
	maxTriesFlag := cmd.Flag.Lookup("max-tries")
	c.Check(maxTriesFlag, NotNil)
	c.Check(maxTriesFlag.DefValue, Equals, "1")
}

func (s *MirrorUpdateSuite) TestMirrorUpdateCommandUsage(c *C) {
	// Test command usage information
	cmd := makeCmdMirrorUpdate()
	
	c.Check(cmd.UsageLine, Equals, "update <name>")
	c.Check(cmd.Short, Equals, "update mirror")
	c.Check(cmd.Long, Matches, "(?s).*Updates remote mirror.*")
	c.Check(cmd.Long, Matches, "(?s).*Example:.*aptly mirror update.*")
}

func (s *MirrorUpdateSuite) TestMirrorUpdateErrorHandling(c *C) {
	// Test various error scenarios in aptlyMirrorUpdate
	testCases := []struct {
		name     string
		args     []string
		expected string
	}{
		{
			name:     "no arguments",
			args:     []string{},
			expected: commander.ErrCommandError.Error(),
		},
		{
			name:     "too many arguments", 
			args:     []string{"mirror1", "mirror2"},
			expected: commander.ErrCommandError.Error(),
		},
	}
	
	for _, tc := range testCases {
		s.setupMockContext(c)
		err := aptlyMirrorUpdate(s.cmd, tc.args)
		if tc.expected == commander.ErrCommandError.Error() {
			c.Check(err, Equals, commander.ErrCommandError, Commentf("Test case: %s", tc.name))
		} else {
			c.Check(err, NotNil, Commentf("Test case: %s", tc.name))
			c.Check(err.Error(), Matches, tc.expected, Commentf("Test case: %s", tc.name))
		}
	}
}

func (s *MirrorUpdateSuite) TestMirrorUpdateQueryParsing(c *C) {
	// Test that query parsing works correctly
	// This is an integration test for the query.Parse functionality used in the filter
	
	testCases := []struct {
		queryStr string
		valid    bool
	}{
		{"Name (% *source*)", true},
		{"Priority (required)", true},
		{"$Architecture (amd64)", true},
		{"invalid query syntax %%%", false},
		{"", false}, // empty query
	}
	
	for _, tc := range testCases {
		_, err := query.Parse(tc.queryStr)
		if tc.valid {
			c.Check(err, IsNil, Commentf("Query should be valid: %s", tc.queryStr))
		} else {
			c.Check(err, NotNil, Commentf("Query should be invalid: %s", tc.queryStr))
		}
	}
}

func (s *MirrorUpdateSuite) TestMirrorUpdateConcurrencyStructures(c *C) {
	// Test the concurrent download structures and patterns used in aptlyMirrorUpdate
	
	// Test that we can create channels and sync structures like in the function
	downloadQueue := make(chan int, 10)
	var wg sync.WaitGroup
	var errors []string
	var errLock sync.Mutex
	
	// Test the pushError function pattern
	pushError := func(err error) {
		errLock.Lock()
		errors = append(errors, err.Error())
		errLock.Unlock()
	}
	
	// Test concurrent error collection
	numGoroutines := 5
	for i := 0; i < numGoroutines; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			pushError(fmt.Errorf("error from goroutine %d", id))
		}(i)
	}
	
	wg.Wait()
	close(downloadQueue)
	
	// Verify error collection worked
	c.Check(len(errors), Equals, numGoroutines)
	for i, errMsg := range errors {
		c.Check(errMsg, Matches, "error from goroutine [0-9]+", Commentf("Error %d: %s", i, errMsg))
	}
}

func (s *MirrorUpdateSuite) TestMirrorUpdateTempFileHandling(c *C) {
	// Test temp file creation and cleanup patterns used in the download section
	
	// Test temporary file creation pattern
	tempFile, err := os.CreateTemp("", "test-download-file")
	c.Check(err, IsNil)
	tempPath := tempFile.Name()
	tempFile.Close()
	
	// Verify file exists
	_, err = os.Stat(tempPath)
	c.Check(err, IsNil)
	
	// Test cleanup pattern (like in the defer function)
	err = os.Remove(tempPath)
	c.Check(err, IsNil)
	
	// Verify file is gone
	_, err = os.Stat(tempPath)
	c.Check(os.IsNotExist(err), Equals, true)
	
	// Test cleanup of nonexistent file (should not error)
	err = os.Remove(tempPath)
	c.Check(os.IsNotExist(err), Equals, true)
}

func (s *MirrorUpdateSuite) TestMirrorUpdateDownloadTaskStructure(c *C) {
	// Test the download task structure and patterns
	
	// Mock the PackageDownloadTask structure that would be used
	tasks := []struct {
		Done         bool
		TempDownPath string
		File         struct {
			Filename    string
			DownloadURL string
			PoolPath    string
		}
		Additional []interface{}
	}{
		{
			Done:         false,
			TempDownPath: "/tmp/package1.deb",
			Additional:   []interface{}{},
		},
		{
			Done:         true,
			TempDownPath: "/tmp/package2.deb", 
			Additional:   []interface{}{},
		},
	}
	
	// Test processing pattern similar to the import loop
	completedTasks := 0
	for _, task := range tasks {
		if task.Done {
			completedTasks++
		}
	}
	
	c.Check(completedTasks, Equals, 1)
	c.Check(len(tasks), Equals, 2)
}

func (s *MirrorUpdateSuite) TestMirrorUpdateProgressReporting(c *C) {
	// Test progress reporting patterns used in the function
	
	// Test that we can create progress reporting structures
	type mockProgress struct {
		messages []string
		barInit  bool
		barShut  bool
	}
	
	progress := &mockProgress{}
	
	// Test progress methods that would be called
	progress.messages = append(progress.messages, "Downloading & parsing package files...")
	progress.messages = append(progress.messages, "Applying filter...")
	progress.messages = append(progress.messages, "Building download queue...")
	progress.barInit = true
	progress.barShut = true
	
	c.Check(len(progress.messages), Equals, 3)
	c.Check(progress.barInit, Equals, true)
	c.Check(progress.barShut, Equals, true)
	c.Check(progress.messages[0], Equals, "Downloading & parsing package files...")
	c.Check(progress.messages[1], Equals, "Applying filter...")
	c.Check(progress.messages[2], Equals, "Building download queue...")
}

func (s *MirrorUpdateSuite) TestMirrorUpdateDeferPatterns(c *C) {
	// Test defer patterns used in the function
	
	var cleanupCalled bool
	var databaseReopened bool
	
	func() {
		defer func() {
			// Simulate the cleanup defer
			cleanupCalled = true
		}()
		
		defer func() {
			// Simulate the database reopen defer
			databaseReopened = true
		}()
		
		// Simulate function execution
	}()
	
	c.Check(cleanupCalled, Equals, true)
	c.Check(databaseReopened, Equals, true)
}

func (s *MirrorUpdateSuite) TestMirrorUpdateContextCancellation(c *C) {
	// Test context cancellation patterns used in the goroutines
	
	// Create a simple context-like structure
	done := make(chan struct{})
	queue := make(chan int, 5)
	
	// Put some items in queue
	for i := 0; i < 3; i++ {
		queue <- i
	}
	close(queue)
	
	// Test the select pattern used in the download goroutines
	processed := 0
	cancelled := false
	
	for {
		select {
		case item, ok := <-queue:
			if !ok {
				goto finished
			}
			processed++
			c.Check(item, Matches, "[0-2]")
		case <-done:
			cancelled = true
			goto finished
		}
	}
	
finished:
	c.Check(processed, Equals, 3)
	c.Check(cancelled, Equals, false)
	
	// Test early cancellation
	done2 := make(chan struct{})
	close(done2) // Cancel immediately
	
	select {
	case <-done2:
		cancelled = true
	default:
		cancelled = false
	}
	
	c.Check(cancelled, Equals, true)
}