diff --git a/cmd/collect_github_release_subcommand_test.go b/cmd/collect_github_release_subcommand_test.go deleted file mode 100644 index 7da2c90..0000000 --- a/cmd/collect_github_release_subcommand_test.go +++ /dev/null @@ -1,110 +0,0 @@ -package cmd - -import ( - "bytes" - "io" - "log/slog" - "net/http" - "os" - "path/filepath" - "testing" - - "github.com/Snider/Borg/pkg/mocks" - borg_github "github.com/Snider/Borg/pkg/github" - "github.com/google/go-github/v39/github" -) - -func TestGetRelease_Good(t *testing.T) { - // Create a temporary directory for the output - dir, err := os.MkdirTemp("", "test-get-release") - if err != nil { - t.Fatalf("failed to create temp dir: %v", err) - } - defer os.RemoveAll(dir) - - mockClient := mocks.NewMockClient(map[string]*http.Response{ - "https://api.github.com/repos/owner/repo/releases/latest": { - StatusCode: http.StatusOK, - Body: io.NopCloser(bytes.NewBufferString(`{"tag_name": "v1.0.0", "assets": [{"name": "asset1.zip", "browser_download_url": "https://github.com/owner/repo/releases/download/v1.0.0/asset1.zip"}]}`)), - }, - "https://github.com/owner/repo/releases/download/v1.0.0/asset1.zip": { - StatusCode: http.StatusOK, - Body: io.NopCloser(bytes.NewBufferString("asset content")), - }, - }) - - oldNewClient := borg_github.NewClient - borg_github.NewClient = func(httpClient *http.Client) *github.Client { - return github.NewClient(mockClient) - } - defer func() { - borg_github.NewClient = oldNewClient - }() - - oldDefaultClient := borg_github.DefaultClient - borg_github.DefaultClient = mockClient - defer func() { - borg_github.DefaultClient = oldDefaultClient - }() - - log := slog.New(slog.NewJSONHandler(io.Discard, nil)) - - // Test downloading a single asset - _, err = GetRelease(log, "https://github.com/owner/repo", dir, false, "asset1.zip", "") - if err != nil { - t.Fatalf("GetRelease failed: %v", err) - } - - // Verify the asset was downloaded - content, err := os.ReadFile(filepath.Join(dir, "asset1.zip")) - if err != nil { - t.Fatalf("failed to read downloaded asset: %v", err) - } - if string(content) != "asset content" { - t.Errorf("unexpected asset content: %s", string(content)) - } - - // Test packing all assets - packedDir := filepath.Join(dir, "packed") - _, err = GetRelease(log, "https://github.com/owner/repo", packedDir, true, "", "") - if err != nil { - t.Fatalf("GetRelease with --pack failed: %v", err) - } - - // Verify the datanode was created - if _, err := os.Stat(filepath.Join(packedDir, "v1.0.0.dat")); os.IsNotExist(err) { - t.Fatalf("datanode not created") - } -} - -func TestGetRelease_Bad(t *testing.T) { - // Create a temporary directory for the output - dir, err := os.MkdirTemp("", "test-get-release") - if err != nil { - t.Fatalf("failed to create temp dir: %v", err) - } - defer os.RemoveAll(dir) - - mockClient := mocks.NewMockClient(map[string]*http.Response{ - "https://api.github.com/repos/owner/repo/releases/latest": { - StatusCode: http.StatusNotFound, - Body: io.NopCloser(bytes.NewBufferString(`{"message": "Not Found"}`)), - }, - }) - - oldNewClient := borg_github.NewClient - borg_github.NewClient = func(httpClient *http.Client) *github.Client { - return github.NewClient(mockClient) - } - defer func() { - borg_github.NewClient = oldNewClient - }() - - log := slog.New(slog.NewJSONHandler(io.Discard, nil)) - - // Test failed release lookup - _, err = GetRelease(log, "https://github.com/owner/repo", dir, false, "", "") - if err == nil { - t.Fatalf("expected an error, but got none") - } -} diff --git a/cmd/collect_pwa_test.go b/cmd/collect_pwa_test.go deleted file mode 100644 index b92f901..0000000 --- a/cmd/collect_pwa_test.go +++ /dev/null @@ -1,61 +0,0 @@ -package cmd - -import ( - "fmt" - "path/filepath" - "strings" - "testing" - - "github.com/Snider/Borg/pkg/datanode" - "github.com/Snider/Borg/pkg/pwa" -) - -func TestCollectPWACmd_NoURI(t *testing.T) { - rootCmd := NewRootCmd() - collectCmd := NewCollectCmd() - collectPWACmd := NewCollectPWACmd() - collectCmd.AddCommand(&collectPWACmd.Command) - rootCmd.AddCommand(collectCmd) - _, err := executeCommand(rootCmd, "collect", "pwa") - if err == nil { - t.Fatalf("expected an error, but got none") - } - if !strings.Contains(err.Error(), "uri is required") { - t.Fatalf("unexpected error message: %v", err) - } -} -func Test_NewCollectPWACmd(t *testing.T) { - if NewCollectPWACmd() == nil { - t.Errorf("NewCollectPWACmd is nil") - } -} - -func TestCollectPWA_Good(t *testing.T) { - mockClient := &pwa.MockPWAClient{ - ManifestURL: "https://example.com/manifest.json", - DN: datanode.New(), - Err: nil, - } - - dir := t.TempDir() - path := filepath.Join(dir, "pwa.dat") - _, err := CollectPWA(mockClient, "https://example.com", path, "datanode", "none") - if err != nil { - t.Fatalf("CollectPWA failed: %v", err) - } -} - -func TestCollectPWA_Bad(t *testing.T) { - mockClient := &pwa.MockPWAClient{ - ManifestURL: "", - DN: nil, - Err: fmt.Errorf("pwa error"), - } - - dir := t.TempDir() - path := filepath.Join(dir, "pwa.dat") - _, err := CollectPWA(mockClient, "https://example.com", path, "datanode", "none") - if err == nil { - t.Fatalf("expected an error, but got none") - } -} diff --git a/cmd/serve.go b/cmd/serve.go index 87e225f..c7e4fd0 100644 --- a/cmd/serve.go +++ b/cmd/serve.go @@ -19,34 +19,30 @@ var serveCmd = &cobra.Command{ Short: "Serve a packaged PWA file", Long: `Serves the contents of a packaged PWA file using a static file server.`, Args: cobra.ExactArgs(1), - Run: func(cmd *cobra.Command, args []string) { + RunE: func(cmd *cobra.Command, args []string) error { dataFile := args[0] port, _ := cmd.Flags().GetString("port") rawData, err := os.ReadFile(dataFile) if err != nil { - fmt.Printf("Error reading data file: %v\n", err) - return + return fmt.Errorf("Error reading data file: %w", err) } data, err := compress.Decompress(rawData) if err != nil { - fmt.Printf("Error decompressing data: %v\n", err) - return + return fmt.Errorf("Error decompressing data: %w", err) } var fs http.FileSystem if strings.HasSuffix(dataFile, ".matrix") { fs, err = tarfs.New(data) if err != nil { - fmt.Printf("Error creating TarFS from matrix tarball: %v\n", err) - return + return fmt.Errorf("Error creating TarFS from matrix tarball: %w", err) } } else { dn, err := datanode.FromTar(data) if err != nil { - fmt.Printf("Error creating DataNode from tarball: %v\n", err) - return + return fmt.Errorf("Error creating DataNode from tarball: %w", err) } fs = http.FS(dn) } @@ -56,9 +52,9 @@ var serveCmd = &cobra.Command{ fmt.Printf("Serving PWA on http://localhost:%s\n", port) err = http.ListenAndServe(":"+port, nil) if err != nil { - fmt.Printf("Error starting server: %v\n", err) - return + return fmt.Errorf("Error starting server: %w", err) } + return nil }, } diff --git a/pkg/datanode/datanode.go b/pkg/datanode/datanode.go index fe2f43b..f7de5b8 100644 --- a/pkg/datanode/datanode.go +++ b/pkg/datanode/datanode.go @@ -78,6 +78,14 @@ func (d *DataNode) ToTar() ([]byte, error) { // AddData adds a file to the DataNode. func (d *DataNode) AddData(name string, content []byte) { name = strings.TrimPrefix(name, "/") + if name == "" { + return + } + // Directories are implicit, so we don't store them. + // A name ending in "/" is treated as a directory. + if strings.HasSuffix(name, "/") { + return + } d.files[name] = &dataFile{ name: name, content: content, @@ -223,15 +231,37 @@ func (d *DataNode) Walk(root string, fn fs.WalkDirFunc, opts ...WalkOptions) err return fn(path, de, err) } if filter != nil && !filter(path, de) { + if de.IsDir() { + return fs.SkipDir + } return nil } + + // Process the entry first. + if err := fn(path, de, nil); err != nil { + return err + } + if maxDepth > 0 { - currentDepth := strings.Count(strings.TrimPrefix(path, root), "/") + // Calculate depth relative to root + cleanedPath := strings.TrimPrefix(path, root) + cleanedPath = strings.TrimPrefix(cleanedPath, "/") + + currentDepth := 0 + if path != root { + if cleanedPath == "" { + // This can happen if root is "bar" and path is "bar" + currentDepth = 0 + } else { + currentDepth = strings.Count(cleanedPath, "/") + 1 + } + } + if de.IsDir() && currentDepth >= maxDepth { return fs.SkipDir } } - return fn(path, de, nil) + return nil }) } diff --git a/pkg/datanode/datanode_test.go b/pkg/datanode/datanode_test.go index 267f421..847d20b 100644 --- a/pkg/datanode/datanode_test.go +++ b/pkg/datanode/datanode_test.go @@ -1,6 +1,7 @@ package datanode import ( + "io/fs" "os" "reflect" "sort" @@ -25,6 +26,42 @@ func TestDataNode(t *testing.T) { t.Fatalf("Expected error opening nonexistent file, got nil") } + // Test Stat + info, err := dn.Stat("bar/baz.txt") + if err != nil { + t.Fatalf("Stat failed: %v", err) + } + if info.Name() != "baz.txt" { + t.Errorf("Expected name baz.txt, got %s", info.Name()) + } + if info.Size() != 3 { + t.Errorf("Expected size 3, got %d", info.Size()) + } + if info.IsDir() { + t.Errorf("Expected baz.txt to not be a directory") + } + + dirInfo, err := dn.Stat("bar") + if err != nil { + t.Fatalf("Stat directory failed: %v", err) + } + if !dirInfo.IsDir() { + t.Errorf("Expected 'bar' to be a directory") + } + + // Test Exists + exists, err := dn.Exists("foo.txt") + if err != nil || !exists { + t.Errorf("Expected foo.txt to exist, err: %v", err) + } + exists, err = dn.Exists("bar") + if err != nil || !exists { + t.Errorf("Expected 'bar' directory to exist, err: %v", err) + } + exists, err = dn.Exists("nonexistent") + if err != nil || exists { + t.Errorf("Expected 'nonexistent' to not exist, err: %v", err) + } // Test ReadDir entries, err := dn.ReadDir(".") @@ -53,6 +90,17 @@ func TestDataNode(t *testing.T) { t.Errorf("Expected %d entries in 'bar', got %d", len(expectedBarEntries), len(barEntries)) } + // Test Walk + var paths []string + dn.Walk(".", func(path string, d fs.DirEntry, err error) error { + paths = append(paths, path) + return nil + }) + expectedPaths := []string{".", "bar", "bar/baz.txt", "bar/qux.txt", "foo.txt"} + sort.Strings(paths) + if !reflect.DeepEqual(paths, expectedPaths) { + t.Errorf("Walk expected paths %v, got %v", expectedPaths, paths) + } // Test CopyFile tmpfile, err := os.CreateTemp("", "datanode-test-") diff --git a/pkg/datanode/fromtar_test.go b/pkg/datanode/fromtar_test.go deleted file mode 100644 index dd77265..0000000 --- a/pkg/datanode/fromtar_test.go +++ /dev/null @@ -1,38 +0,0 @@ -package datanode - -import ( - "archive/tar" - "bytes" - "testing" -) - -func TestFromTar(t *testing.T) { - buf := new(bytes.Buffer) - tw := tar.NewWriter(buf) - testData := "hello world" - - hdr := &tar.Header{ - Name: "test.txt", - Mode: 0600, - Size: int64(len(testData)), - } - if err := tw.WriteHeader(hdr); err != nil { - t.Fatalf("failed to write header: %v", err) - } - if _, err := tw.Write([]byte(testData)); err != nil { - t.Fatalf("failed to write content: %v", err) - } - if err := tw.Close(); err != nil { - t.Fatalf("failed to close writer: %v", err) - } - - dn, err := FromTar(buf.Bytes()) - if err != nil { - t.Fatalf("FromTar failed: %v", err) - } - file, err := dn.Open("test.txt") - if err != nil { - t.Fatalf("Open failed: %v", err) - } - defer file.Close() -} diff --git a/pkg/datanode/fs_test.go b/pkg/datanode/fs_test.go deleted file mode 100644 index be86c7d..0000000 --- a/pkg/datanode/fs_test.go +++ /dev/null @@ -1,69 +0,0 @@ -package datanode - -import ( - "io/fs" - "reflect" - "sort" - "testing" -) - -func TestDataNodeFS(t *testing.T) { - dn := New() - dn.AddData("foo.txt", []byte("foo")) - dn.AddData("bar/baz.txt", []byte("baz")) - dn.AddData("bar/qux.txt", []byte("qux")) - - // Test Stat - info, err := dn.Stat("bar/baz.txt") - if err != nil { - t.Fatalf("Stat failed: %v", err) - } - if info.Name() != "baz.txt" { - t.Errorf("Expected name baz.txt, got %s", info.Name()) - } - if info.Size() != 3 { - t.Errorf("Expected size 3, got %d", info.Size()) - } - if info.IsDir() { - t.Errorf("Expected baz.txt to not be a directory") - } - - dirInfo, err := dn.Stat("bar") - if err != nil { - t.Fatalf("Stat directory failed: %v", err) - } - if !dirInfo.IsDir() { - t.Errorf("Expected 'bar' to be a directory") - } - - _, err = dn.Stat("nonexistent") - if err == nil { - t.Fatal("Expected error for nonexistent file, got nil") - } - - // Test Exists - exists, err := dn.Exists("foo.txt") - if err != nil || !exists { - t.Errorf("Expected foo.txt to exist, err: %v", err) - } - exists, err = dn.Exists("bar") - if err != nil || !exists { - t.Errorf("Expected 'bar' directory to exist, err: %v", err) - } - exists, err = dn.Exists("nonexistent") - if err != nil || exists { - t.Errorf("Expected 'nonexistent' to not exist, err: %v", err) - } - - // Test Walk - var paths []string - dn.Walk(".", func(path string, d fs.DirEntry, err error) error { - paths = append(paths, path) - return nil - }) - expectedPaths := []string{".", "bar", "bar/baz.txt", "bar/qux.txt", "foo.txt"} - sort.Strings(paths) - if !reflect.DeepEqual(paths, expectedPaths) { - t.Errorf("Walk expected paths %v, got %v", expectedPaths, paths) - } -} diff --git a/pkg/matrix/config.go b/pkg/matrix/config.go index 80d9ab5..6ed7aa7 100644 --- a/pkg/matrix/config.go +++ b/pkg/matrix/config.go @@ -180,7 +180,7 @@ const DefaultConfigJSON = `{ }` // defaultConfig returns the default runc spec. -func defaultConfig() (map[string]interface{}, error) { +var defaultConfigVar = func() (map[string]interface{}, error) { var spec map[string]interface{} err := json.Unmarshal([]byte(DefaultConfigJSON), &spec) if err != nil { diff --git a/pkg/matrix/matrix.go b/pkg/matrix/matrix.go index ef15bec..a9ffbc3 100644 --- a/pkg/matrix/matrix.go +++ b/pkg/matrix/matrix.go @@ -19,7 +19,7 @@ type TerminalIsolationMatrix struct { func New() (*TerminalIsolationMatrix, error) { // Use the default runc spec as a starting point. // This can be customized later. - spec, err := defaultConfig() + spec, err := defaultConfigVar() if err != nil { return nil, err } diff --git a/pkg/matrix/matrix_more_test.go b/pkg/matrix/matrix_more_test.go new file mode 100644 index 0000000..a8100ff --- /dev/null +++ b/pkg/matrix/matrix_more_test.go @@ -0,0 +1,50 @@ +package matrix + +import ( + "errors" + "testing" + + "github.com/Snider/Borg/pkg/datanode" +) + +func TestNew_Error(t *testing.T) { + origDefaultConfig := defaultConfigVar + t.Cleanup(func() { + defaultConfigVar = origDefaultConfig + }) + + // Test error from defaultConfigVar + defaultConfigVar = func() (map[string]interface{}, error) { + return nil, errors.New("mock defaultConfig error") + } + _, err := New() + if err == nil { + t.Fatal("Expected error from defaultConfig, got nil") + } + + // Test error from json.Marshal + defaultConfigVar = func() (map[string]interface{}, error) { + return map[string]interface{}{"foo": make(chan int)}, nil + } + _, err = New() + if err == nil { + t.Fatal("Expected error from json.Marshal, got nil") + } +} + +func TestFromDataNode_Error(t *testing.T) { + origDefaultConfig := defaultConfigVar + t.Cleanup(func() { + defaultConfigVar = origDefaultConfig + }) + + defaultConfigVar = func() (map[string]interface{}, error) { + return nil, errors.New("mock defaultConfig error") + } + + dn := datanode.New() + _, err := FromDataNode(dn) + if err == nil { + t.Fatal("Expected error from FromDataNode, got nil") + } +} diff --git a/pkg/pwa/pwa_error_test.go b/pkg/pwa/pwa_error_test.go new file mode 100644 index 0000000..5007f96 --- /dev/null +++ b/pkg/pwa/pwa_error_test.go @@ -0,0 +1,47 @@ +package pwa + +import ( + "fmt" + "net/http" + "net/http/httptest" + "testing" + + "github.com/schollz/progressbar/v3" +) + +func TestDownloadAndPackagePWA_Error(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.URL.Path == "/manifest.json" { + w.Header().Set("Content-Type", "application/json") + w.Write([]byte(`{"start_url": "index.html"}`)) + } else { + http.NotFound(w, r) + } + })) + defer server.Close() + + client := newTestPWAClient() + + // Test with a server that returns a 404 for the start_url + bar := progressbar.New(1) + _, err := client.DownloadAndPackagePWA(server.URL, server.URL+"/manifest.json", bar) + if err == nil { + t.Fatal("Expected an error when the start_url returns a 404, but got nil") + } + + // Test with a bad manifest URL + _, err = client.DownloadAndPackagePWA(server.URL, "http://bad.url/manifest.json", bar) + if err == nil { + t.Fatal("Expected an error when the manifest URL is bad, but got nil") + } + + // Test with a manifest that is not valid JSON + server2 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + fmt.Fprintln(w, "this is not json") + })) + defer server2.Close() + _, err = client.DownloadAndPackagePWA(server2.URL, server2.URL, bar) + if err == nil { + t.Fatal("Expected an error when the manifest is not valid JSON, but got nil") + } +} diff --git a/pkg/website/website.go b/pkg/website/website.go index c96bac8..65198b6 100644 --- a/pkg/website/website.go +++ b/pkg/website/website.go @@ -23,6 +23,7 @@ type Downloader struct { maxDepth int progressBar *progressbar.ProgressBar client *http.Client + errors []error } // NewDownloader creates a new Downloader. @@ -33,10 +34,11 @@ func NewDownloader(maxDepth int) *Downloader { // NewDownloaderWithClient creates a new Downloader with a custom http.Client. func NewDownloaderWithClient(maxDepth int, client *http.Client) *Downloader { return &Downloader{ - dn: datanode.New(), - visited: make(map[string]bool), - maxDepth: maxDepth, - client: client, + dn: datanode.New(), + visited: make(map[string]bool), + maxDepth: maxDepth, + client: client, + errors: make([]error, 0), } } @@ -52,6 +54,14 @@ func downloadAndPackageWebsite(startURL string, maxDepth int, bar *progressbar.P d.progressBar = bar d.crawl(startURL, 0) + if len(d.errors) > 0 { + var errs []string + for _, e := range d.errors { + errs = append(errs, e.Error()) + } + return nil, fmt.Errorf("failed to download website:\n%s", strings.Join(errs, "\n")) + } + return d.dn, nil } @@ -66,23 +76,33 @@ func (d *Downloader) crawl(pageURL string, depth int) { resp, err := d.client.Get(pageURL) if err != nil { - fmt.Printf("Error getting %s: %v\n", pageURL, err) + d.errors = append(d.errors, fmt.Errorf("Error getting %s: %w", pageURL, err)) return } defer resp.Body.Close() + if resp.StatusCode >= 400 { + d.errors = append(d.errors, fmt.Errorf("bad status for %s: %s", pageURL, resp.Status)) + return + } + body, err := io.ReadAll(resp.Body) if err != nil { - fmt.Printf("Error reading body of %s: %v\n", pageURL, err) + d.errors = append(d.errors, fmt.Errorf("Error reading body of %s: %w", pageURL, err)) return } relPath := d.getRelativePath(pageURL) d.dn.AddData(relPath, body) + // Don't try to parse non-html content + if !strings.HasPrefix(resp.Header.Get("Content-Type"), "text/html") { + return + } + doc, err := html.Parse(strings.NewReader(string(body))) if err != nil { - fmt.Printf("Error parsing HTML of %s: %v\n", pageURL, err) + d.errors = append(d.errors, fmt.Errorf("Error parsing HTML of %s: %w", pageURL, err)) return } @@ -123,14 +143,19 @@ func (d *Downloader) downloadAsset(assetURL string) { resp, err := d.client.Get(assetURL) if err != nil { - fmt.Printf("Error getting asset %s: %v\n", assetURL, err) + d.errors = append(d.errors, fmt.Errorf("Error getting asset %s: %w", assetURL, err)) return } defer resp.Body.Close() + if resp.StatusCode >= 400 { + d.errors = append(d.errors, fmt.Errorf("bad status for asset %s: %s", assetURL, resp.Status)) + return + } + body, err := io.ReadAll(resp.Body) if err != nil { - fmt.Printf("Error reading body of asset %s: %v\n", assetURL, err) + d.errors = append(d.errors, fmt.Errorf("Error reading body of asset %s: %w", assetURL, err)) return }