diff --git a/.github/dependabot.yaml b/.github/dependabot.yaml index 403f428e4..7f9fff67a 100644 --- a/.github/dependabot.yaml +++ b/.github/dependabot.yaml @@ -13,6 +13,10 @@ updates: interval: "daily" commit-message: prefix: "build" + groups: + golang.org: + patterns: + - "golang.org/*" - package-ecosystem: "gomod" directory: "/cli/go-git" diff --git a/.github/workflows/cifuzz.yml b/.github/workflows/cifuzz.yml index a93087634..f6ac8ec5a 100644 --- a/.github/workflows/cifuzz.yml +++ b/.github/workflows/cifuzz.yml @@ -1,6 +1,11 @@ name: CIFuzz -on: [pull_request] +on: + pull_request: + branches: + - main + permissions: {} + jobs: Fuzzing: runs-on: ubuntu-latest @@ -28,7 +33,7 @@ jobs: path: ./out/artifacts - name: Upload Sarif if: always() && steps.build.outcome == 'success' - uses: github/codeql-action/upload-sarif@v3 + uses: github/codeql-action/upload-sarif@v3.28.10 with: # Path to SARIF file relative to the root of the repository sarif_file: cifuzz-sarif/results.sarif diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml index 920fc3e58..4b11d9425 100644 --- a/.github/workflows/codeql.yml +++ b/.github/workflows/codeql.yml @@ -1,17 +1,21 @@ -name: "CodeQL" - +name: CodeQL on: push: - branches: [ "master" ] + branches: + - releases/v5.x + - main pull_request: - branches: [ "master" ] + schedule: - cron: '00 5 * * 1' +permissions: {} + jobs: analyze: name: Analyze runs-on: ubuntu-latest + permissions: actions: read contents: read @@ -28,7 +32,7 @@ jobs: # Initializes the CodeQL tools for scanning. - name: Initialize CodeQL - uses: github/codeql-action/init@03e7845b7bfcd5e7fb63d1ae8c61b0e791134fab # v2.22.11 + uses: github/codeql-action/init@ff79de67cc25c7617163ae1e4b8aa23b902fdf15 # v2.22.11 with: languages: ${{ matrix.language }} # xref: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs @@ -39,6 +43,6 @@ jobs: run: go build ./... - name: Perform CodeQL Analysis - uses: github/codeql-action/analyze@03e7845b7bfcd5e7fb63d1ae8c61b0e791134fab # v2.22.11 + uses: github/codeql-action/analyze@ff79de67cc25c7617163ae1e4b8aa23b902fdf15 # v2.22.11 with: category: "/language:${{matrix.language}}" diff --git a/.github/workflows/git.yml b/.github/workflows/git.yml index c7ae9ee00..0c89b3d4e 100644 --- a/.github/workflows/git.yml +++ b/.github/workflows/git.yml @@ -1,7 +1,12 @@ -on: [push, pull_request] name: Git Compatibility -permissions: - contents: read +on: + push: + branches: + - releases/v5.x + - main + pull_request: + +permissions: {} jobs: test: @@ -15,6 +20,9 @@ jobs: GIT_VERSION: ${{ matrix.git[0] }} GIT_DIST_PATH: .git-dist/${{ matrix.git[0] }} + permissions: + contents: read + steps: - name: Checkout code uses: actions/checkout@v4 @@ -22,7 +30,7 @@ jobs: - name: Install Go uses: actions/setup-go@v5 with: - go-version: 1.22.x + go-version: stable - name: Install build dependencies run: sudo apt-get update && sudo apt-get install gettext libcurl4-openssl-dev diff --git a/.github/workflows/pr-validation.yml b/.github/workflows/pr-validation.yml index d7b115095..07b60b846 100644 --- a/.github/workflows/pr-validation.yml +++ b/.github/workflows/pr-validation.yml @@ -1,5 +1,4 @@ -name: 'PR Validation' - +name: PR Validation on: pull_request: types: @@ -8,18 +7,21 @@ on: - reopened - synchronize -permissions: - contents: read +permissions: {} jobs: check-commit-message: name: Check Commit Messages runs-on: ubuntu-latest + + permissions: + contents: read + steps: - name: Check Package Prefix uses: gsactions/commit-message-checker@v2 with: - pattern: '^(\*|git|plumbing|utils|config|_examples|internal|storage|cli|build): .+' + pattern: '^(\*|docs|git|plumbing|utils|config|_examples|internal|storage|cli|build): .+' error: | Commit message(s) does not align with contribution acceptance criteria. diff --git a/.github/workflows/stale-issues-bot.yaml b/.github/workflows/stale-issues-bot.yaml index fe40db367..c5c4fc5c3 100644 --- a/.github/workflows/stale-issues-bot.yaml +++ b/.github/workflows/stale-issues-bot.yaml @@ -1,15 +1,18 @@ -name: "stale issues bot" +name: stale issues bot on: schedule: - cron: "0 7 * * *" -permissions: - issues: write - pull-requests: write +permissions: {} jobs: stale-bot: runs-on: ubuntu-latest + + permissions: + issues: write + pull-requests: write + steps: - uses: actions/stale@v9 with: diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index a04763d44..85e3bbf60 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -1,16 +1,24 @@ -on: [push, pull_request] name: Test -permissions: - contents: read +on: + push: + branches: + - releases/v5.x + - main + pull_request: + +permissions: {} jobs: version-matrix: strategy: fail-fast: false matrix: - go-version: [1.20.x, 1.21.x, 1.22.x] + go-version: [1.22.x, 1.23.x, 1.24.x] platform: [ubuntu-latest, macos-latest, windows-latest] + permissions: + contents: read + runs-on: ${{ matrix.platform }} steps: - name: Checkout code @@ -36,4 +44,4 @@ jobs: run: make test-coverage - name: Test Examples - run: go test -timeout 30s -v -run '^TestExamples$' github.com/go-git/go-git/v5/_examples --examples + run: go test -timeout 45s -v -run '^TestExamples$' github.com/go-git/go-git/v5/_examples --examples diff --git a/COMPATIBILITY.md b/COMPATIBILITY.md index 0e1b696d4..ba1fb90ac 100644 --- a/COMPATIBILITY.md +++ b/COMPATIBILITY.md @@ -34,6 +34,7 @@ compatibility status with go-git. | `merge` | | ⚠️ (partial) | Fast-forward only | | | `mergetool` | | ❌ | | | | `stash` | | ❌ | | | +| `sparse-checkout` | | ✅ | | - [sparse-checkout](_examples/sparse-checkout/main.go) | | `tag` | | ✅ | | - [tag](_examples/tag/main.go)
- [tag create and push](_examples/tag-create-push/main.go) | ## Sharing and updating projects diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index fce25328a..83dfc2ce3 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -1,21 +1,22 @@ # Contributing Guidelines -source{d} go-git project is [Apache 2.0 licensed](LICENSE) and accepts -contributions via GitHub pull requests. This document outlines some of the +The go-git project is [Apache 2.0 licensed](LICENSE) and accepts +contributions via GitHub pull requests. This document outlines some of the conventions on development workflow, commit message formatting, contact points, and other resources to make it easier to get your contribution accepted. ## Support Channels -The official support channels, for both users and contributors, are: +The official support channels, for users are: -- [StackOverflow go-git tag](https://stackoverflow.com/questions/tagged/go-git) for user questions. -- GitHub [Issues](https://github.com/src-d/go-git/issues)* for bug reports and feature requests. +- [StackOverflow go-git tag] for user questions. +- GitHub [Issues]* for bug reports and feature requests. *Before opening a new issue or submitting a new pull request, it's helpful to search the project - it's likely that another user has already reported the issue you're facing, or it's a known issue that we're already aware of. +In addition to the channels above, contributors are also able to join the go-git [discord server]. ## How to Contribute @@ -23,14 +24,27 @@ Pull Requests (PRs) are the main and exclusive way to contribute to the official In order for a PR to be accepted it needs to pass a list of requirements: - You should be able to run the same query using `git`. We don't accept features that are not implemented in the official git implementation. -- The expected behavior must match the [official git implementation](https://github.com/git/git). +- The expected behavior must match the [official git implementation]. - The actual behavior must be correctly explained with natural language and providing a minimum working example in Go that reproduces it. -- All PRs must be written in idiomatic Go, formatted according to [gofmt](https://golang.org/cmd/gofmt/), and without any warnings from [go lint](https://github.com/golang/lint) nor [go vet](https://golang.org/cmd/vet/). +- All PRs must be written in idiomatic Go, formatted according to [gofmt], and without any warnings from [go vet]. - They should in general include tests, and those shall pass. - If the PR is a bug fix, it has to include a suite of unit tests for the new functionality. - If the PR is a new feature, it has to come with a suite of unit tests, that tests the new functionality. - In any case, all the PRs have to pass the personal evaluation of at least one of the maintainers of go-git. +### Branches + +The development branch is `main`, where all development takes place. +All new features and bug fixes should target it. This was formely known as `v6-exp`, +as it contains all the changes for `v6` - the next major release. + +The `releases/v5.x` branch is the branch for changes to the `v5` version, +which is now in maintaince mode. To avoid having to divert efforts from `v6`, +we will only be accepting bug fixes or CVE related dependency bumps for the +`v5` release. + +Bug fixes that also impact `main`, should be fixed there first, and then backported to `v5`. + ### Format of the commit message Every commit message should describe what was changed, under which context and, if applicable, the GitHub issue it relates to: @@ -44,3 +58,10 @@ The format can be described more formally as follows: ``` : , . [Fixes #] ``` + +[discord server]: https://discord.gg/8hrxYEVPE5 +[StackOverflow go-git tag]: https://stackoverflow.com/questions/tagged/go-git +[Issues]: https://github.com/go-git/go-git/issues +[official git implementation]: https://github.com/git/git +[gofmt]: https://golang.org/cmd/gofmt/ +[go vet]: https://golang.org/cmd/vet/ diff --git a/EXTENDING.md b/EXTENDING.md index a2778e34a..818c40f28 100644 --- a/EXTENDING.md +++ b/EXTENDING.md @@ -42,7 +42,7 @@ New filesystems (e.g. cloud based storage) could be created by implementing `go- Git supports various transport schemes, including `http`, `https`, `ssh`, `git`, `file`. `go-git` defines the [transport.Transport interface](plumbing/transport/common.go#L48) to represent them. -The built-in implementations can be replaced by calling `client.InstallProtocol`. +The built-in implementations can be replaced by calling `transport.Register`. An example of changing the built-in `https` implementation to skip TLS could look like this: @@ -53,7 +53,7 @@ An example of changing the built-in `https` implementation to skip TLS could loo }, } - client.InstallProtocol("https", githttp.NewClient(customClient)) + transport.Register("https", githttp.NewClient(customClient)) ``` Some internal implementations enables code reuse amongst the different transport implementations. Some of these may be made public in the future (e.g. `plumbing/transport/internal/common`). diff --git a/Makefile b/Makefile index 3d5b54f7e..9826e34bd 100644 --- a/Makefile +++ b/Makefile @@ -14,6 +14,10 @@ GIT_REPOSITORY = http://github.com/git/git.git COVERAGE_REPORT = coverage.out COVERAGE_MODE = count +# Defines the maximum time each fuzz target will be executed for. +FUZZ_TIME ?= 10s +FUZZ_PKGS = $(shell grep -r --include='**_test.go' --files-with-matches 'func Fuzz' . | xargs -I{} dirname {}) + build-git: @if [ -f $(GIT_DIST_PATH)/git ]; then \ echo "nothing to do, using cache $(GIT_DIST_PATH)"; \ @@ -45,10 +49,6 @@ clean: rm -rf $(GIT_DIST_PATH) fuzz: - @go test -fuzz=FuzzParser $(PWD)/internal/revision - @go test -fuzz=FuzzDecoder $(PWD)/plumbing/format/config - @go test -fuzz=FuzzPatchDelta $(PWD)/plumbing/format/packfile - @go test -fuzz=FuzzParseSignedBytes $(PWD)/plumbing/object - @go test -fuzz=FuzzDecode $(PWD)/plumbing/object - @go test -fuzz=FuzzDecoder $(PWD)/plumbing/protocol/packp - @go test -fuzz=FuzzNewEndpoint $(PWD)/plumbing/transport + @for path in $(FUZZ_PKGS); do \ + go test -fuzz=Fuzz -fuzztime=$(FUZZ_TIME) $$path; \ + done diff --git a/README.md b/README.md index ff0c9b72b..6a2d2e44b 100644 --- a/README.md +++ b/README.md @@ -10,7 +10,7 @@ It's being actively developed since 2015 and is being used extensively by [Keyba Project Status -------------- -After the legal issues with the [`src-d`](https://github.com/src-d) organization, the lack of update for four months and the requirement to make a hard fork, the project is **now back to normality**. +After the [legal issues](https://github.com/src-d/go-git/issues/1295#issuecomment-592965250) with the [`src-d`](https://github.com/src-d) organization, the lack of update for four months and the requirement to make a hard fork, the project is **now back to normality**. The project is currently actively maintained by individual contributors, including several of the original authors, but also backed by a new company, [gitsight](https://github.com/gitsight), where `go-git` is a critical component used at scale. diff --git a/_examples/README.md b/_examples/README.md index 1e9ea6ae6..aecf64b6b 100644 --- a/_examples/README.md +++ b/_examples/README.md @@ -12,6 +12,7 @@ Here you can find a list of annotated _go-git_ examples: a repository using a GitHub personal access token. - [ssh private key](clone/auth/ssh/private_key/main.go) - Cloning a repository using a ssh private key. - [ssh agent](clone/auth/ssh/ssh_agent/main.go) - Cloning a repository using ssh-agent. +- [config](config/main.go) - Explains how to work with config files. - [commit](commit/main.go) - Commit changes to the current branch to an existent repository. - [push](push/main.go) - Push repository to default remote (origin). - [pull](pull/main.go) - Pull changes from a remote repository. @@ -25,7 +26,6 @@ Here you can find a list of annotated _go-git_ examples: - [progress](progress/main.go) - Printing the progress information from the sideband. - [revision](revision/main.go) - Solve a revision into a commit. - [submodule](submodule/main.go) - Submodule update remote. -- [azure devops](azure_devops/main.go) - Cloning Azure DevOps repositories. - [blame](blame/main.go) - Blame/annotate a commit. - [ls-remote](ls-remote/main.go) - List remote tags without cloning a repository. @@ -34,3 +34,5 @@ Here you can find a list of annotated _go-git_ examples: - [clone with context](context/main.go) - Cloning a repository with graceful cancellation. - [storage](storage/README.md) - Implementing a custom storage system. - [sha256](sha256/main.go) - Init and committing repositories that use sha256 as object format. +- [memory](memory/main.go) - Clone a repository into an in-memory dotgit storage and worktree. +- [perf-clone](performance/clone/main.go) - Clone a repository with the least time and space complexity. diff --git a/_examples/azure_devops/main.go b/_examples/azure_devops/main.go deleted file mode 100644 index 9c02ca080..000000000 --- a/_examples/azure_devops/main.go +++ /dev/null @@ -1,56 +0,0 @@ -package main - -import ( - "fmt" - "os" - - git "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/plumbing/transport/http" -) - -func main() { - CheckArgs("", "", "", "") - url, directory, username, password := os.Args[1], os.Args[2], os.Args[3], os.Args[4] - - // Clone the given repository to the given directory - Info("git clone %s %s", url, directory) - - // Azure DevOps requires capabilities multi_ack / multi_ack_detailed, - // which are not fully implemented and by default are included in - // transport.UnsupportedCapabilities. - // - // The initial clone operations require a full download of the repository, - // and therefore those unsupported capabilities are not as crucial, so - // by removing them from that list allows for the first clone to work - // successfully. - // - // Additional fetches will yield issues, therefore work always from a clean - // clone until those capabilities are fully supported. - // - // New commits and pushes against a remote worked without any issues. - transport.UnsupportedCapabilities = []capability.Capability{ - capability.ThinPack, - } - - r, err := git.PlainClone(directory, false, &git.CloneOptions{ - Auth: &http.BasicAuth{ - Username: username, - Password: password, - }, - URL: url, - Progress: os.Stdout, - }) - CheckIfError(err) - - // ... retrieving the branch being pointed by HEAD - ref, err := r.Head() - CheckIfError(err) - // ... retrieving the commit object - commit, err := r.CommitObject(ref.Hash()) - CheckIfError(err) - - fmt.Println(commit) -} diff --git a/_examples/blame/main.go b/_examples/blame/main.go index 3ffae17b5..83ad8054d 100644 --- a/_examples/blame/main.go +++ b/_examples/blame/main.go @@ -4,8 +4,8 @@ import ( "fmt" "os" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" ) // Basic example of how to blame a repository. diff --git a/_examples/branch/main.go b/_examples/branch/main.go index b4b69de4d..ad308c0b4 100644 --- a/_examples/branch/main.go +++ b/_examples/branch/main.go @@ -3,9 +3,9 @@ package main import ( "os" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/plumbing" ) // An example of how to create and remove branches or any other kind of reference. diff --git a/_examples/checkout-branch/main.go b/_examples/checkout-branch/main.go index 59dfdfc3d..43351bfb8 100644 --- a/_examples/checkout-branch/main.go +++ b/_examples/checkout-branch/main.go @@ -4,10 +4,10 @@ import ( "fmt" "os" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/plumbing" ) // Checkout a branch diff --git a/_examples/checkout/main.go b/_examples/checkout/main.go index 92942c474..293fe2f9a 100644 --- a/_examples/checkout/main.go +++ b/_examples/checkout/main.go @@ -4,9 +4,9 @@ import ( "fmt" "os" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/plumbing" ) // Basic example of how to checkout a specific commit. diff --git a/_examples/clone/auth/basic/access_token/main.go b/_examples/clone/auth/basic/access_token/main.go index c50d02616..e3fd88cbf 100644 --- a/_examples/clone/auth/basic/access_token/main.go +++ b/_examples/clone/auth/basic/access_token/main.go @@ -4,9 +4,9 @@ import ( "fmt" "os" - git "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" - "github.com/go-git/go-git/v5/plumbing/transport/http" + git "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/plumbing/transport/http" ) func main() { diff --git a/_examples/clone/auth/basic/username_password/main.go b/_examples/clone/auth/basic/username_password/main.go index 845732085..61bf2cf56 100644 --- a/_examples/clone/auth/basic/username_password/main.go +++ b/_examples/clone/auth/basic/username_password/main.go @@ -4,9 +4,9 @@ import ( "fmt" "os" - git "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" - "github.com/go-git/go-git/v5/plumbing/transport/http" + git "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/plumbing/transport/http" ) func main() { diff --git a/_examples/clone/auth/ssh/private_key/main.go b/_examples/clone/auth/ssh/private_key/main.go index 5f21d9076..0ef6ef00b 100644 --- a/_examples/clone/auth/ssh/private_key/main.go +++ b/_examples/clone/auth/ssh/private_key/main.go @@ -4,9 +4,9 @@ import ( "fmt" "os" - git "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" - "github.com/go-git/go-git/v5/plumbing/transport/ssh" + git "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/plumbing/transport/ssh" ) func main() { diff --git a/_examples/clone/auth/ssh/ssh_agent/main.go b/_examples/clone/auth/ssh/ssh_agent/main.go index 7a2ebd367..555749936 100644 --- a/_examples/clone/auth/ssh/ssh_agent/main.go +++ b/_examples/clone/auth/ssh/ssh_agent/main.go @@ -4,9 +4,9 @@ import ( "fmt" "os" - git "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" - "github.com/go-git/go-git/v5/plumbing/transport/ssh" + git "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/plumbing/transport/ssh" ) func main() { diff --git a/_examples/clone/main.go b/_examples/clone/main.go index 0315f91a9..d04dc72df 100644 --- a/_examples/clone/main.go +++ b/_examples/clone/main.go @@ -4,8 +4,8 @@ import ( "fmt" "os" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" ) // Basic example of how to clone a repository using clone options. diff --git a/_examples/commit/main.go b/_examples/commit/main.go index 3f3c88048..02b112f2b 100644 --- a/_examples/commit/main.go +++ b/_examples/commit/main.go @@ -6,9 +6,9 @@ import ( "path/filepath" "time" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" - "github.com/go-git/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/plumbing/object" ) // Basic example of how to commit changes to the current branch to an existing diff --git a/_examples/common_test.go b/_examples/common_test.go index 5e3f75381..2db9dc033 100644 --- a/_examples/common_test.go +++ b/_examples/common_test.go @@ -19,26 +19,30 @@ var args = map[string][]string{ "checkout": {defaultURL, tempFolder(), "35e85108805c84807bc66a02d91535e1e24b38b9"}, "checkout-branch": {defaultURL, tempFolder(), "branch"}, "clone": {defaultURL, tempFolder()}, + "config": {}, "commit": {cloneRepository(defaultURL, tempFolder())}, "context": {defaultURL, tempFolder()}, "custom_http": {defaultURL}, "find-if-any-tag-point-head": {cloneRepository(defaultURL, tempFolder())}, "ls": {cloneRepository(defaultURL, tempFolder()), "HEAD", "vendor"}, "ls-remote": {defaultURL}, + "memory": {defaultURL}, "merge_base": {cloneRepository(defaultURL, tempFolder()), "--is-ancestor", "HEAD~3", "HEAD^"}, "open": {cloneRepository(defaultURL, tempFolder())}, + "perf-clone": {cloneRepository(defaultURL, tempFolder())}, "progress": {defaultURL, tempFolder()}, "pull": {createRepositoryWithRemote(tempFolder(), defaultURL)}, "push": {setEmptyRemote(cloneRepository(defaultURL, tempFolder()))}, + "restore": {cloneRepository(defaultURL, tempFolder())}, "revision": {cloneRepository(defaultURL, tempFolder()), "master~2^"}, "sha256": {tempFolder()}, "showcase": {defaultURL, tempFolder()}, + "sparse-checkout": {defaultURL, "vendor", tempFolder()}, "tag": {cloneRepository(defaultURL, tempFolder())}, } // tests not working / set-up var ignored = map[string]bool{ - "azure_devops": true, "ls": true, "sha256": true, "submodule": true, diff --git a/_examples/config/main.go b/_examples/config/main.go new file mode 100644 index 000000000..371c2d11a --- /dev/null +++ b/_examples/config/main.go @@ -0,0 +1,46 @@ +package main + +import ( + "os" + + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + + "github.com/jesseduffield/go-git/v5/config" +) + +// Example of how to: +// - Access basic local (i.e. ./.git/config) configuration params +// - Set basic local config params + +func main() { + tmp, err := os.MkdirTemp("", "go-git-example") + CheckIfError(err) + defer os.RemoveAll(tmp) + + Info("git init") + r, err := git.PlainInit(tmp, false) + CheckIfError(err) + + // Load the configuration + cfg, err := r.Config() + CheckIfError(err) + + Info("worktree is %s", cfg.Core.Worktree) + + // Set basic local config params + cfg.Remotes["origin"] = &config.RemoteConfig{ + Name: "origin", + URLs: []string{"https://github.com/git-fixtures/basic.git"}, + } + + Info("origin remote: %+v", cfg.Remotes["origin"]) + + cfg.User.Name = "Local name" + + Info("custom.name is %s", cfg.User.Name) + + // In order to save the config file, you need to call SetConfig + // After calling this go to .git/config and see the custom.name added and the changes to the remote + r.Storer.SetConfig(cfg) +} diff --git a/_examples/context/main.go b/_examples/context/main.go index 7516e7868..26cc1315a 100644 --- a/_examples/context/main.go +++ b/_examples/context/main.go @@ -5,8 +5,8 @@ import ( "os" "os/signal" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" ) // Graceful cancellation example of a basic git operation such as Clone. diff --git a/_examples/custom_http/main.go b/_examples/custom_http/main.go index 8dc1697ff..184d93b5a 100644 --- a/_examples/custom_http/main.go +++ b/_examples/custom_http/main.go @@ -7,11 +7,11 @@ import ( "os" "time" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" - "github.com/go-git/go-git/v5/plumbing/transport/client" - githttp "github.com/go-git/go-git/v5/plumbing/transport/http" - "github.com/go-git/go-git/v5/storage/memory" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/plumbing/transport/client" + githttp "github.com/jesseduffield/go-git/v5/plumbing/transport/http" + "github.com/jesseduffield/go-git/v5/storage/memory" ) // Here is an example to configure http client according to our own needs. @@ -36,7 +36,7 @@ func main() { } // Override http(s) default protocol to use our custom client - client.InstallProtocol("https", githttp.NewClient(customClient)) + transport.Register("https", githttp.NewClient(customClient)) // Clone repository using the new client if the protocol is https:// Info("git clone %s", url) diff --git a/_examples/find-if-any-tag-point-head/main.go b/_examples/find-if-any-tag-point-head/main.go index 834aea2bb..5a0e2e387 100644 --- a/_examples/find-if-any-tag-point-head/main.go +++ b/_examples/find-if-any-tag-point-head/main.go @@ -4,9 +4,9 @@ import ( "fmt" "os" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/plumbing" ) // Basic example of how to find if HEAD is tagged. diff --git a/_examples/log/main.go b/_examples/log/main.go index 35de58a83..ecfa881aa 100644 --- a/_examples/log/main.go +++ b/_examples/log/main.go @@ -4,10 +4,10 @@ import ( "fmt" "time" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/storage/memory" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/storage/memory" ) // Example of how to: diff --git a/_examples/ls-remote/main.go b/_examples/ls-remote/main.go index e49e8c9e4..bb3f0fb8f 100644 --- a/_examples/ls-remote/main.go +++ b/_examples/ls-remote/main.go @@ -4,11 +4,11 @@ import ( "log" "os" - "github.com/go-git/go-git/v5" - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/storage/memory" + "github.com/jesseduffield/go-git/v5" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/storage/memory" - . "github.com/go-git/go-git/v5/_examples" + . "github.com/jesseduffield/go-git/v5/_examples" ) // Retrieve remote tags without cloning repository diff --git a/_examples/ls/main.go b/_examples/ls/main.go index 95a0c60f1..4ad82885c 100644 --- a/_examples/ls/main.go +++ b/_examples/ls/main.go @@ -8,14 +8,14 @@ import ( "strings" "github.com/emirpasic/gods/trees/binaryheap" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - commitgraph_fmt "github.com/go-git/go-git/v5/plumbing/format/commitgraph" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/plumbing/object/commitgraph" - "github.com/go-git/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + commitgraph_fmt "github.com/jesseduffield/go-git/v5/plumbing/format/commitgraph" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/plumbing/object/commitgraph" + "github.com/jesseduffield/go-git/v5/storage/filesystem" "github.com/go-git/go-billy/v5" "github.com/go-git/go-billy/v5/osfs" diff --git a/_examples/memory/main.go b/_examples/memory/main.go new file mode 100644 index 000000000..8ca2f978a --- /dev/null +++ b/_examples/memory/main.go @@ -0,0 +1,37 @@ +package main + +import ( + "fmt" + "os" + + "github.com/go-git/go-billy/v5/memfs" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/storage/memory" +) + +// Basic example of how to clone a repository using clone options. +func main() { + CheckArgs("") + url := os.Args[1] + + // Clone the given repository to the given directory + Info("git clone %s", url) + + wt := memfs.New() + storer := memory.NewStorage() + r, err := git.Clone(storer, wt, &git.CloneOptions{ + URL: url, + }) + + CheckIfError(err) + + // ... retrieving the branch being pointed by HEAD + ref, err := r.Head() + CheckIfError(err) + // ... retrieving the commit object + commit, err := r.CommitObject(ref.Hash()) + CheckIfError(err) + + fmt.Println(commit) +} diff --git a/_examples/merge_base/helpers.go b/_examples/merge_base/helpers.go index 2b493c80b..f53b4d3c8 100644 --- a/_examples/merge_base/helpers.go +++ b/_examples/merge_base/helpers.go @@ -5,7 +5,7 @@ import ( "os" "strings" - "github.com/go-git/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/plumbing/object" ) func checkIfError(err error, code exitCode, mainReason string, v ...interface{}) { diff --git a/_examples/merge_base/main.go b/_examples/merge_base/main.go index 46725e1a7..736f18a5a 100644 --- a/_examples/merge_base/main.go +++ b/_examples/merge_base/main.go @@ -3,9 +3,9 @@ package main import ( "os" - "github.com/go-git/go-git/v5" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/object" ) type exitCode int diff --git a/_examples/open/main.go b/_examples/open/main.go index fdc8378ee..a65142887 100644 --- a/_examples/open/main.go +++ b/_examples/open/main.go @@ -4,9 +4,9 @@ import ( "fmt" "os" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" - "github.com/go-git/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/plumbing/object" ) // Open an existing repository in a specific folder. diff --git a/_examples/performance/clone/main.go b/_examples/performance/clone/main.go new file mode 100644 index 000000000..10963fc3b --- /dev/null +++ b/_examples/performance/clone/main.go @@ -0,0 +1,64 @@ +package main + +import ( + "crypto" + "crypto/sha1" + "fmt" + "os" + + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/plumbing/hash" + "github.com/jesseduffield/go-git/v5/utils/trace" +) + +// Expands the Basic example focusing in performance. +func main() { + CheckArgs("", "") + url := os.Args[1] + directory := os.Args[2] + + // Replace sha1cd with Golang's sha1 implementation, which is faster. + // SHA1 as a hash algorithm is broken, so Git implementations tend to use + // an alternative implementation that includes collision detection - which + // is the default on go-git and in the git cli. + // + // This operation is only safe when interacting with trustworthy Git servers, + // such as GitHub and GitLab. If your application needs to interact with + // custom servers or does not impose any sort of constraints on the target + // server, this is not recommended. + hash.RegisterHash(crypto.SHA1, sha1.New) + + // Clone the given repository to the given directory + Info("GIT_TRACE_PERFORMANCE=true git clone --no-tags --depth 1 --single-branch %s %s", url, directory) + + // Enable performance metrics. This is only to show the break down per + // operation, and can be removed. Like in the git CLI, this can be enabled + // at runtime by environment variable: + // GIT_TRACE_PERFORMANCE=true + trace.SetTarget(trace.Performance) + + r, err := git.PlainClone(directory, false, &git.CloneOptions{ + URL: url, + // Differently than the git CLI, by default go-git downloads + // all tags and its related objects. To avoid unnecessary + // data transmission and processing, opt-out tags. + Tags: git.NoTags, + // Shallow clones the repository, returning a single commit. + Depth: 1, + // Depth 1 implies single branch, so this is largely redundant. + SingleBranch: true, + // Not a net positive change for performance, this was added + // to better align the output when compared with the git CLI. + Progress: os.Stdout, + }) + + CheckIfError(err) + + ref, err := r.Head() + CheckIfError(err) + commit, err := r.CommitObject(ref.Hash()) + CheckIfError(err) + + fmt.Println(commit) +} diff --git a/_examples/progress/main.go b/_examples/progress/main.go index c15e32f08..f492a87db 100644 --- a/_examples/progress/main.go +++ b/_examples/progress/main.go @@ -3,8 +3,8 @@ package main import ( "os" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" ) // Example of how to show the progress when you do a basic clone operation. diff --git a/_examples/pull/main.go b/_examples/pull/main.go index cfd0551ac..5766c9dc0 100644 --- a/_examples/pull/main.go +++ b/_examples/pull/main.go @@ -4,8 +4,8 @@ import ( "fmt" "os" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" ) // Pull changes from a remote repository diff --git a/_examples/push/main.go b/_examples/push/main.go index 01eceaebf..49c6d73d8 100644 --- a/_examples/push/main.go +++ b/_examples/push/main.go @@ -3,8 +3,8 @@ package main import ( "os" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" ) // Example of how to open a repository in a specific path, and push to diff --git a/_examples/remotes/main.go b/_examples/remotes/main.go index d09957eae..65a7c31aa 100644 --- a/_examples/remotes/main.go +++ b/_examples/remotes/main.go @@ -3,11 +3,11 @@ package main import ( "fmt" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/storage/memory" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/storage/memory" ) // Example of how to: diff --git a/_examples/restore/main.go b/_examples/restore/main.go new file mode 100644 index 000000000..2d0fcb1af --- /dev/null +++ b/_examples/restore/main.go @@ -0,0 +1,103 @@ +package main + +import ( + "fmt" + "io/ioutil" + "os" + "path/filepath" + "time" + + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/plumbing/object" +) + +func prepareRepo(w *git.Worktree, directory string) { + // We need a known state of files inside the worktree for testing revert a modify and delete + Info("echo \"hello world! Modify\" > for-modify") + err := ioutil.WriteFile(filepath.Join(directory, "for-modify"), []byte("hello world! Modify"), 0644) + CheckIfError(err) + Info("git add for-modify") + _, err = w.Add("for-modify") + CheckIfError(err) + + Info("echo \"hello world! Delete\" > for-delete") + err = ioutil.WriteFile(filepath.Join(directory, "for-delete"), []byte("hello world! Delete"), 0644) + CheckIfError(err) + Info("git add for-delete") + _, err = w.Add("for-delete") + CheckIfError(err) + + Info("git commit -m \"example go-git commit\"") + _, err = w.Commit("example go-git commit", &git.CommitOptions{ + Author: &object.Signature{ + Name: "John Doe", + Email: "john@doe.org", + When: time.Now(), + }, + }) + CheckIfError(err) +} + +// An example of how to restore AKA unstage files +func main() { + CheckArgs("") + directory := os.Args[1] + + // Opens an already existing repository. + r, err := git.PlainOpen(directory) + CheckIfError(err) + + w, err := r.Worktree() + CheckIfError(err) + + prepareRepo(w, directory) + + // Perform the operation and stage them + Info("echo \"hello world! Modify 2\" > for-modify") + err = ioutil.WriteFile(filepath.Join(directory, "for-modify"), []byte("hello world! Modify 2"), 0644) + CheckIfError(err) + Info("git add for-modify") + _, err = w.Add("for-modify") + CheckIfError(err) + + Info("echo \"hello world! Add\" > for-add") + err = ioutil.WriteFile(filepath.Join(directory, "for-add"), []byte("hello world! Add"), 0644) + CheckIfError(err) + Info("git add for-add") + _, err = w.Add("for-add") + CheckIfError(err) + + Info("rm for-delete") + err = os.Remove(filepath.Join(directory, "for-delete")) + CheckIfError(err) + Info("git add for-delete") + _, err = w.Add("for-delete") + CheckIfError(err) + + // We can verify the current status of the worktree using the method Status. + Info("git status --porcelain") + status, err := w.Status() + CheckIfError(err) + fmt.Println(status) + + // Unstage a single file and see the status + Info("git restore --staged for-modify") + err = w.Restore(&git.RestoreOptions{Staged: true, Files: []string{"for-modify"}}) + CheckIfError(err) + + Info("git status --porcelain") + status, err = w.Status() + CheckIfError(err) + fmt.Println(status) + + // Unstage the other 2 files and see the status + Info("git restore --staged for-add for-delete") + err = w.Restore(&git.RestoreOptions{Staged: true, Files: []string{"for-add", "for-delete"}}) + CheckIfError(err) + + Info("git status --porcelain") + status, err = w.Status() + CheckIfError(err) + fmt.Println(status) +} diff --git a/_examples/revision/main.go b/_examples/revision/main.go index ddaf25e53..a7ded3453 100644 --- a/_examples/revision/main.go +++ b/_examples/revision/main.go @@ -4,9 +4,9 @@ import ( "fmt" "os" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/plumbing" ) // Example how to resolve a revision into its commit counterpart diff --git a/_examples/sha256/main.go b/_examples/sha256/main.go index 03927724d..41c7d16ef 100644 --- a/_examples/sha256/main.go +++ b/_examples/sha256/main.go @@ -6,10 +6,10 @@ import ( "path/filepath" "time" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" - "github.com/go-git/go-git/v5/plumbing/format/config" - "github.com/go-git/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/plumbing/format/config" + "github.com/jesseduffield/go-git/v5/plumbing/object" ) // This example requires building with the sha256 tag for it to work: diff --git a/_examples/showcase/main.go b/_examples/showcase/main.go index e2c2b5362..3504c04a4 100644 --- a/_examples/showcase/main.go +++ b/_examples/showcase/main.go @@ -5,10 +5,10 @@ import ( "os" "strings" - "github.com/go-git/go-git/v5" - "github.com/go-git/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5" + "github.com/jesseduffield/go-git/v5/plumbing/object" - . "github.com/go-git/go-git/v5/_examples" + . "github.com/jesseduffield/go-git/v5/_examples" ) // Example of an specific use case: diff --git a/_examples/sparse-checkout/main.go b/_examples/sparse-checkout/main.go new file mode 100644 index 000000000..1475ccf49 --- /dev/null +++ b/_examples/sparse-checkout/main.go @@ -0,0 +1,31 @@ +package main + +import ( + "os" + + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" +) + +func main() { + CheckArgs("", "", "") + url := os.Args[1] + path := os.Args[2] + directory := os.Args[3] + + Info("git clone %s %s", url, directory) + + r, err := git.PlainClone(directory, false, &git.CloneOptions{ + URL: url, + NoCheckout: true, + }) + CheckIfError(err) + + w, err := r.Worktree() + CheckIfError(err) + + err = w.Checkout(&git.CheckoutOptions{ + SparseCheckoutDirectories: []string{path}, + }) + CheckIfError(err) +} diff --git a/_examples/submodule/main.go b/_examples/submodule/main.go index 1a7619363..b4022a516 100644 --- a/_examples/submodule/main.go +++ b/_examples/submodule/main.go @@ -3,8 +3,8 @@ package main import ( "os" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" ) // Basic example of how to clone a repository including a submodule and diff --git a/_examples/tag-create-push/main.go b/_examples/tag-create-push/main.go index b820c76b7..a1c07536f 100644 --- a/_examples/tag-create-push/main.go +++ b/_examples/tag-create-push/main.go @@ -5,11 +5,11 @@ import ( "log" "os" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/plumbing/transport/ssh" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/plumbing/transport/ssh" ) // Example of how create a tag and push it to a remote. diff --git a/_examples/tag/main.go b/_examples/tag/main.go index 3f47ab704..acfd78a2f 100644 --- a/_examples/tag/main.go +++ b/_examples/tag/main.go @@ -4,10 +4,10 @@ import ( "fmt" "os" - "github.com/go-git/go-git/v5" - . "github.com/go-git/go-git/v5/_examples" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5" + . "github.com/jesseduffield/go-git/v5/_examples" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/object" ) // Basic example of how to list tags. diff --git a/blame.go b/blame.go index e83caf346..2f1c910a8 100644 --- a/blame.go +++ b/blame.go @@ -10,9 +10,9 @@ import ( "time" "unicode/utf8" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/utils/diff" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/utils/diff" "github.com/sergi/go-diff/diffmatchpatch" ) @@ -306,8 +306,8 @@ func (b *blame) addBlames(curItems []*queueItem) (bool, error) { for h := range hunks { hLines := countLines(hunks[h].Text) for hl := 0; hl < hLines; hl++ { - switch { - case hunks[h].Type == diffmatchpatch.DiffEqual: + switch hunks[h].Type { + case diffmatchpatch.DiffEqual: prevl++ curl++ if curl == curItem.NeedsMap[need].Cur { @@ -319,7 +319,7 @@ func (b *blame) addBlames(curItems []*queueItem) (bool, error) { break out } } - case hunks[h].Type == diffmatchpatch.DiffInsert: + case diffmatchpatch.DiffInsert: curl++ if curl == curItem.NeedsMap[need].Cur { // the line we want is added, it may have been added here (or by another parent), skip it for now @@ -328,7 +328,7 @@ func (b *blame) addBlames(curItems []*queueItem) (bool, error) { break out } } - case hunks[h].Type == diffmatchpatch.DiffDelete: + case diffmatchpatch.DiffDelete: prevl += hLines continue out default: diff --git a/blame_test.go b/blame_test.go index 1c5db266f..214f176e8 100644 --- a/blame_test.go +++ b/blame_test.go @@ -1,42 +1,48 @@ package git import ( - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/object" + "fmt" + "testing" + + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) type BlameSuite struct { + suite.Suite BaseSuite } -var _ = Suite(&BlameSuite{}) +func TestBlameSuite(t *testing.T) { + suite.Run(t, new(BlameSuite)) +} -func (s *BlameSuite) TestNewLines(c *C) { +func (s *BlameSuite) TestNewLines() { h := plumbing.NewHash("ce9f123d790717599aaeb76bc62510de437761be") lines, err := newLines([]string{"foo"}, []*object.Commit{{ Hash: h, Message: "foo", }}) - c.Assert(err, IsNil) - c.Assert(lines, HasLen, 1) - c.Assert(lines[0].Text, Equals, "foo") - c.Assert(lines[0].Hash, Equals, h) + s.NoError(err) + s.Len(lines, 1) + s.Equal("foo", lines[0].Text) + s.Equal(h, lines[0].Hash) } -func (s *BlameSuite) TestNewLinesWithNewLine(c *C) { +func (s *BlameSuite) TestNewLinesWithNewLine() { lines, err := newLines([]string{"foo", ""}, []*object.Commit{ {Message: "foo"}, {Message: "bar"}, }) - c.Assert(err, IsNil) - c.Assert(lines, HasLen, 2) - c.Assert(lines[0].Text, Equals, "foo") - c.Assert(lines[1].Text, Equals, "") + s.NoError(err) + s.Len(lines, 2) + s.Equal("foo", lines[0].Text) + s.Equal("", lines[1].Text) } type blameTest struct { @@ -47,39 +53,39 @@ type blameTest struct { } // run a blame on all the suite's tests -func (s *BlameSuite) TestBlame(c *C) { +func (s *BlameSuite) TestBlame() { for _, t := range blameTests { r := s.NewRepositoryFromPackfile(fixtures.ByURL(t.repo).One()) - exp := s.mockBlame(c, t, r) + exp := s.mockBlame(t, r) commit, err := r.CommitObject(plumbing.NewHash(t.rev)) - c.Assert(err, IsNil) + s.NoError(err) obt, err := Blame(commit, t.path) - c.Assert(err, IsNil) - c.Assert(obt, DeepEquals, exp) + s.NoError(err) + s.Equal(exp, obt) for i, l := range obt.Lines { - c.Assert(l.Hash.String(), Equals, t.blames[i]) + s.Equal(t.blames[i], l.Hash.String()) } } } -func (s *BlameSuite) mockBlame(c *C, t blameTest, r *Repository) (blame *BlameResult) { +func (s *BlameSuite) mockBlame(t blameTest, r *Repository) (blame *BlameResult) { commit, err := r.CommitObject(plumbing.NewHash(t.rev)) - c.Assert(err, IsNil, Commentf("%v: repo=%s, rev=%s", err, t.repo, t.rev)) + s.NoError(err, fmt.Sprintf("%v: repo=%s, rev=%s", err, t.repo, t.rev)) f, err := commit.File(t.path) - c.Assert(err, IsNil) + s.NoError(err) lines, err := f.Lines() - c.Assert(err, IsNil) - c.Assert(len(t.blames), Equals, len(lines), Commentf( + s.NoError(err) + s.Len(t.blames, len(lines), fmt.Sprintf( "repo=%s, path=%s, rev=%s: the number of lines in the file and the number of expected blames differ (len(blames)=%d, len(lines)=%d)\nblames=%#q\nlines=%#q", t.repo, t.path, t.rev, len(t.blames), len(lines), t.blames, lines)) blamedLines := make([]*Line, 0, len(t.blames)) for i := range t.blames { commit, err := r.CommitObject(plumbing.NewHash(t.blames[i])) - c.Assert(err, IsNil) + s.NoError(err) l := &Line{ Author: commit.Author.Email, AuthorName: commit.Author.Name, diff --git a/cli/go-git/receive_pack.go b/cli/go-git/receive_pack.go index 2a4fd1f4d..d312fdad4 100644 --- a/cli/go-git/receive_pack.go +++ b/cli/go-git/receive_pack.go @@ -5,7 +5,7 @@ import ( "os" "path/filepath" - "github.com/go-git/go-git/v5/plumbing/transport/file" + "github.com/jesseduffield/go-git/v5/plumbing/transport/file" ) type CmdReceivePack struct { diff --git a/cli/go-git/update_server_info.go b/cli/go-git/update_server_info.go index a7f3e3e39..29340c168 100644 --- a/cli/go-git/update_server_info.go +++ b/cli/go-git/update_server_info.go @@ -4,9 +4,9 @@ import ( "fmt" "os" - "github.com/go-git/go-git/v5" - "github.com/go-git/go-git/v5/plumbing/serverinfo" - "github.com/go-git/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5" + "github.com/jesseduffield/go-git/v5/plumbing/serverinfo" + "github.com/jesseduffield/go-git/v5/storage/filesystem" ) // CmdUpdateServerInfo command updates the server info files in the repository. diff --git a/cli/go-git/upload_pack.go b/cli/go-git/upload_pack.go index 975c3a7a1..f7f9d3669 100644 --- a/cli/go-git/upload_pack.go +++ b/cli/go-git/upload_pack.go @@ -5,7 +5,7 @@ import ( "os" "path/filepath" - "github.com/go-git/go-git/v5/plumbing/transport/file" + "github.com/jesseduffield/go-git/v5/plumbing/transport/file" ) type CmdUploadPack struct { diff --git a/common_test.go b/common_test.go index ff4d6b813..834ae1782 100644 --- a/common_test.go +++ b/common_test.go @@ -1,45 +1,46 @@ package git import ( + "fmt" "os" "testing" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/format/packfile" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/storage/filesystem" - "github.com/go-git/go-git/v5/storage/memory" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/format/packfile" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" "github.com/go-git/go-billy/v5" "github.com/go-git/go-billy/v5/memfs" "github.com/go-git/go-billy/v5/osfs" "github.com/go-git/go-billy/v5/util" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) -func Test(t *testing.T) { TestingT(t) } +type BaseFixtureSuite struct { + fixtures.Suite +} type BaseSuite struct { - fixtures.Suite + suite.Suite + BaseFixtureSuite Repository *Repository cache map[string]*Repository } -func (s *BaseSuite) SetUpSuite(c *C) { - s.buildBasicRepository(c) +func (s *BaseSuite) SetupSuite() { + s.buildBasicRepository() s.cache = make(map[string]*Repository) } -func (s *BaseSuite) TearDownSuite(c *C) { - s.Suite.TearDownSuite(c) -} - -func (s *BaseSuite) buildBasicRepository(_ *C) { +func (s *BaseSuite) buildBasicRepository() { f := fixtures.Basic().One() s.Repository = s.NewRepository(f) } @@ -74,7 +75,7 @@ func (s *BaseSuite) NewRepository(f *fixtures.Fixture) *Repository { // NewRepositoryWithEmptyWorktree returns a new repository using the .git folder // from the fixture but without a empty memfs worktree, the index and the // modules are deleted from the .git folder. -func (s *BaseSuite) NewRepositoryWithEmptyWorktree(f *fixtures.Fixture) *Repository { +func NewRepositoryWithEmptyWorktree(f *fixtures.Fixture) *Repository { dotgit := f.DotGit() err := dotgit.Remove("index") if err != nil { @@ -96,7 +97,6 @@ func (s *BaseSuite) NewRepositoryWithEmptyWorktree(f *fixtures.Fixture) *Reposit } return r - } func (s *BaseSuite) NewRepositoryFromPackfile(f *fixtures.Fixture) *Repository { @@ -136,21 +136,6 @@ func (s *BaseSuite) GetLocalRepositoryURL(f *fixtures.Fixture) string { return f.DotGit().Root() } -func (s *BaseSuite) TemporalDir() (path string, clean func()) { - fs := osfs.New(os.TempDir()) - relPath, err := util.TempDir(fs, "", "") - if err != nil { - panic(err) - } - - path = fs.Join(fs.Root(), relPath) - clean = func() { - _ = util.RemoveAll(fs, relPath) - } - - return -} - func (s *BaseSuite) TemporalHomeDir() (path string, clean func()) { home, err := os.UserHomeDir() if err != nil { @@ -171,8 +156,12 @@ func (s *BaseSuite) TemporalHomeDir() (path string, clean func()) { return } -func (s *BaseSuite) TemporalFilesystem() (fs billy.Filesystem, clean func()) { - fs = osfs.New(os.TempDir()) +func (s *BaseSuite) TemporalFilesystem() (fs billy.Filesystem) { + tmpDir, err := os.MkdirTemp("", "") + if err != nil { + panic(err) + } + fs = osfs.New(tmpDir) path, err := util.TempDir(fs, "", "") if err != nil { panic(err) @@ -183,16 +172,16 @@ func (s *BaseSuite) TemporalFilesystem() (fs billy.Filesystem, clean func()) { panic(err) } - clean = func() { - _ = util.RemoveAll(fs, path) - } - return } -type SuiteCommon struct{} +type SuiteCommon struct { + suite.Suite +} -var _ = Suite(&SuiteCommon{}) +func TestSuiteCommon(t *testing.T) { + suite.Run(t, new(SuiteCommon)) +} var countLinesTests = [...]struct { i string // the string we want to count lines from @@ -209,47 +198,47 @@ var countLinesTests = [...]struct { {"first line\n\tsecond line\nthird line\n", 3}, } -func (s *SuiteCommon) TestCountLines(c *C) { +func (s *SuiteCommon) TestCountLines() { for i, t := range countLinesTests { o := countLines(t.i) - c.Assert(o, Equals, t.e, Commentf("subtest %d, input=%q", i, t.i)) + s.Equal(t.e, o, fmt.Sprintf("subtest %d, input=%q", i, t.i)) } } -func AssertReferences(c *C, r *Repository, expected map[string]string) { +func AssertReferences(t *testing.T, r *Repository, expected map[string]string) { for name, target := range expected { expected := plumbing.NewReferenceFromStrings(name, target) obtained, err := r.Reference(expected.Name(), true) - c.Assert(err, IsNil) + assert.NoError(t, err) - c.Assert(obtained, DeepEquals, expected) + assert.Equal(t, expected, obtained) } } -func AssertReferencesMissing(c *C, r *Repository, expected []string) { +func AssertReferencesMissing(t *testing.T, r *Repository, expected []string) { for _, name := range expected { _, err := r.Reference(plumbing.ReferenceName(name), false) - c.Assert(err, NotNil) - c.Assert(err, Equals, plumbing.ErrReferenceNotFound) + assert.Error(t, err) + assert.ErrorIs(t, err, plumbing.ErrReferenceNotFound) } } -func CommitNewFile(c *C, repo *Repository, fileName string) plumbing.Hash { +func CommitNewFile(t *testing.T, repo *Repository, fileName string) plumbing.Hash { wt, err := repo.Worktree() - c.Assert(err, IsNil) + assert.NoError(t, err) fd, err := wt.Filesystem.Create(fileName) - c.Assert(err, IsNil) + assert.NoError(t, err) _, err = fd.Write([]byte("# test file")) - c.Assert(err, IsNil) + assert.NoError(t, err) err = fd.Close() - c.Assert(err, IsNil) + assert.NoError(t, err) _, err = wt.Add(fileName) - c.Assert(err, IsNil) + assert.NoError(t, err) sha, err := wt.Commit("test commit", &CommitOptions{ Author: &object.Signature{ @@ -263,7 +252,7 @@ func CommitNewFile(c *C, repo *Repository, fileName string) plumbing.Hash { When: time.Now(), }, }) - c.Assert(err, IsNil) + assert.NoError(t, err) return sha } diff --git a/config/branch.go b/config/branch.go index db2cb499a..3cf94e684 100644 --- a/config/branch.go +++ b/config/branch.go @@ -4,8 +4,8 @@ import ( "errors" "strings" - "github.com/go-git/go-git/v5/plumbing" - format "github.com/go-git/go-git/v5/plumbing/format/config" + "github.com/jesseduffield/go-git/v5/plumbing" + format "github.com/jesseduffield/go-git/v5/plumbing/format/config" ) var ( @@ -103,7 +103,7 @@ func quoteDescription(desc string) string { return strings.ReplaceAll(desc, "\n", `\n`) } -func (b *Branch) unmarshal(s *format.Subsection) error { +func (b *Branch) unmarshal(s *format.Subsection) { b.raw = s b.Name = b.raw.Name @@ -111,8 +111,6 @@ func (b *Branch) unmarshal(s *format.Subsection) error { b.Merge = plumbing.ReferenceName(b.raw.Options.Get(mergeKey)) b.Rebase = b.raw.Options.Get(rebaseKey) b.Description = unquoteDescription(b.raw.Options.Get(descriptionKey)) - - return b.Validate() } // hack to enable conditional quoting in the diff --git a/config/branch_test.go b/config/branch_test.go index ae1fe856e..9ca9a9378 100644 --- a/config/branch_test.go +++ b/config/branch_test.go @@ -1,16 +1,21 @@ package config import ( - "github.com/go-git/go-git/v5/plumbing" + "testing" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/stretchr/testify/suite" ) -type BranchSuite struct{} +type BranchSuite struct { + suite.Suite +} -var _ = Suite(&BranchSuite{}) +func TestBranchSuite(t *testing.T) { + suite.Run(t, new(BranchSuite)) +} -func (b *BranchSuite) TestValidateName(c *C) { +func (b *BranchSuite) TestValidateName() { goodBranch := Branch{ Name: "master", Remote: "some_remote", @@ -20,11 +25,11 @@ func (b *BranchSuite) TestValidateName(c *C) { Remote: "some_remote", Merge: "refs/heads/master", } - c.Assert(goodBranch.Validate(), IsNil) - c.Assert(badBranch.Validate(), NotNil) + b.Nil(goodBranch.Validate()) + b.NotNil(badBranch.Validate()) } -func (b *BranchSuite) TestValidateMerge(c *C) { +func (b *BranchSuite) TestValidateMerge() { goodBranch := Branch{ Name: "master", Remote: "some_remote", @@ -35,11 +40,11 @@ func (b *BranchSuite) TestValidateMerge(c *C) { Remote: "some_remote", Merge: "blah", } - c.Assert(goodBranch.Validate(), IsNil) - c.Assert(badBranch.Validate(), NotNil) + b.Nil(goodBranch.Validate()) + b.NotNil(badBranch.Validate()) } -func (b *BranchSuite) TestMarshal(c *C) { +func (b *BranchSuite) TestMarshal() { expected := []byte(`[core] bare = false [branch "branch-tracking-on-clone"] @@ -57,11 +62,11 @@ func (b *BranchSuite) TestMarshal(c *C) { } actual, err := cfg.Marshal() - c.Assert(err, IsNil) - c.Assert(string(actual), Equals, string(expected)) + b.NoError(err) + b.Equal(string(expected), string(actual)) } -func (b *BranchSuite) TestUnmarshal(c *C) { +func (b *BranchSuite) TestUnmarshal() { input := []byte(`[core] bare = false [branch "branch-tracking-on-clone"] @@ -72,10 +77,10 @@ func (b *BranchSuite) TestUnmarshal(c *C) { cfg := NewConfig() err := cfg.Unmarshal(input) - c.Assert(err, IsNil) + b.NoError(err) branch := cfg.Branches["branch-tracking-on-clone"] - c.Assert(branch.Name, Equals, "branch-tracking-on-clone") - c.Assert(branch.Remote, Equals, "fork") - c.Assert(branch.Merge, Equals, plumbing.ReferenceName("refs/heads/branch-tracking-on-clone")) - c.Assert(branch.Rebase, Equals, "interactive") + b.Equal("branch-tracking-on-clone", branch.Name) + b.Equal("fork", branch.Remote) + b.Equal(plumbing.ReferenceName("refs/heads/branch-tracking-on-clone"), branch.Merge) + b.Equal("interactive", branch.Rebase) } diff --git a/config/config.go b/config/config.go index 6d41c15dc..c4115490c 100644 --- a/config/config.go +++ b/config/config.go @@ -12,9 +12,10 @@ import ( "strconv" "github.com/go-git/go-billy/v5/osfs" - "github.com/go-git/go-git/v5/internal/url" - "github.com/go-git/go-git/v5/plumbing" - format "github.com/go-git/go-git/v5/plumbing/format/config" + "github.com/jesseduffield/go-git/v5/internal/url" + "github.com/jesseduffield/go-git/v5/plumbing" + format "github.com/jesseduffield/go-git/v5/plumbing/format/config" + "github.com/jesseduffield/go-git/v5/plumbing/protocol" ) const ( @@ -22,6 +23,12 @@ const ( DefaultFetchRefSpec = "+refs/heads/*:refs/remotes/%s/*" // DefaultPushRefSpec is the default refspec used for push. DefaultPushRefSpec = "refs/heads/*:refs/heads/*" + // DefaultProtocolVersion is the value assumed if none is defined + // at the config file. This value is used to define when this section + // should be marshalled or not. + // Note that this does not need to align with the default protocol + // version from plumbing/protocol. + DefaultProtocolVersion = protocol.V0 // go-git only supports V0 at the moment ) // ConfigStorer generic storage of Config object @@ -109,6 +116,20 @@ type Config struct { ObjectFormat format.ObjectFormat } + Protocol struct { + // Version sets the preferred version for the Git wire protocol. + // When set, clients will attempt to communicate with a server + // using the specified protocol version. If the server does not + // support it, communication falls back to version 0. If unset, + // the default version will be used. Supported versions: + // + // 0 - the original wire protocol. + // 1 - the original wire protocol with the addition of a + // version string in the initial response from the server. + // 2 - Wire protocol version 2. + Version protocol.Version + } + // Remotes list of repository remotes, the key of the map is the name // of the remote, should equal to RemoteConfig.Name. Remotes map[string]*RemoteConfig @@ -138,6 +159,7 @@ func NewConfig() *Config { } config.Pack.Window = DefaultPackWindow + config.Protocol.Version = DefaultProtocolVersion return config } @@ -250,8 +272,10 @@ const ( initSection = "init" urlSection = "url" extensionsSection = "extensions" + protocolSection = "protocol" fetchKey = "fetch" urlKey = "url" + pushurlKey = "pushurl" bareKey = "bare" worktreeKey = "worktree" commentCharKey = "commentChar" @@ -265,6 +289,7 @@ const ( repositoryFormatVersionKey = "repositoryformatversion" objectFormat = "objectformat" mirrorKey = "mirror" + versionKey = "version" // DefaultPackWindow holds the number of previous objects used to // generate deltas. The value 10 is the same used by git command. @@ -289,11 +314,13 @@ func (c *Config) Unmarshal(b []byte) error { } unmarshalSubmodules(c.Raw, c.Submodules) - if err := c.unmarshalBranches(); err != nil { + c.unmarshalBranches() + + if err := c.unmarshalURLs(); err != nil { return err } - if err := c.unmarshalURLs(); err != nil { + if err := c.unmarshalProtocol(); err != nil { return err } @@ -386,17 +413,32 @@ func unmarshalSubmodules(fc *format.Config, submodules map[string]*Submodule) { } } -func (c *Config) unmarshalBranches() error { +func (c *Config) unmarshalBranches() { bs := c.Raw.Section(branchSection) for _, sub := range bs.Subsections { b := &Branch{} - if err := b.unmarshal(sub); err != nil { - return err - } + b.unmarshal(sub) c.Branches[b.Name] = b } +} + +func (c *Config) unmarshalProtocol() error { + s := c.Raw.Section(protocolSection) + + c.Protocol.Version = DefaultProtocolVersion + + // If empty, don't try to parse and instead fallback + // to default protocol version. + if rv := s.Options.Get(versionKey); rv != "" { + v, err := protocol.Parse(rv) + if err != nil { + return err + } + c.Protocol.Version = v + } + return nil } @@ -415,6 +457,7 @@ func (c *Config) Marshal() ([]byte, error) { c.marshalSubmodules() c.marshalBranches() c.marshalURLs() + c.marshalProtocol() c.marshalInit() buf := bytes.NewBuffer(nil) @@ -565,6 +608,14 @@ func (c *Config) marshalURLs() { } } +func (c *Config) marshalProtocol() { + // Only marshal protocol section if a version was set. + if c.Protocol.Version != DefaultProtocolVersion { + s := c.Raw.Section(protocolSection) + s.SetOption(versionKey, c.Protocol.Version.String()) + } +} + func (c *Config) marshalInit() { s := c.Raw.Section(initSection) if c.Init.DefaultBranch != "" { @@ -633,6 +684,7 @@ func (c *RemoteConfig) unmarshal(s *format.Subsection) error { c.Name = c.raw.Name c.URLs = append([]string(nil), c.raw.Options.GetAll(urlKey)...) + c.URLs = append(c.URLs, c.raw.Options.GetAll(pushurlKey)...) c.Fetch = fetch c.Mirror = c.raw.Options.Get(mirrorKey) == "true" diff --git a/config/config_test.go b/config/config_test.go index 7e9483f6f..5c8bf123f 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -4,18 +4,24 @@ import ( "os" "path/filepath" "strings" + "testing" "github.com/go-git/go-billy/v5/osfs" "github.com/go-git/go-billy/v5/util" - "github.com/go-git/go-git/v5/plumbing" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/protocol" + "github.com/stretchr/testify/suite" ) -type ConfigSuite struct{} +type ConfigSuite struct { + suite.Suite +} -var _ = Suite(&ConfigSuite{}) +func TestConfigSuite(t *testing.T) { + suite.Run(t, new(ConfigSuite)) +} -func (s *ConfigSuite) TestUnmarshal(c *C) { +func (s *ConfigSuite) TestUnmarshal() { input := []byte(`[core] bare = true worktree = foo @@ -59,39 +65,39 @@ func (s *ConfigSuite) TestUnmarshal(c *C) { cfg := NewConfig() err := cfg.Unmarshal(input) - c.Assert(err, IsNil) - - c.Assert(cfg.Core.IsBare, Equals, true) - c.Assert(cfg.Core.Worktree, Equals, "foo") - c.Assert(cfg.Core.CommentChar, Equals, "bar") - c.Assert(cfg.User.Name, Equals, "John Doe") - c.Assert(cfg.User.Email, Equals, "john@example.com") - c.Assert(cfg.Author.Name, Equals, "Jane Roe") - c.Assert(cfg.Author.Email, Equals, "jane@example.com") - c.Assert(cfg.Committer.Name, Equals, "Richard Roe") - c.Assert(cfg.Committer.Email, Equals, "richard@example.com") - c.Assert(cfg.Pack.Window, Equals, uint(20)) - c.Assert(cfg.Remotes, HasLen, 4) - c.Assert(cfg.Remotes["origin"].Name, Equals, "origin") - c.Assert(cfg.Remotes["origin"].URLs, DeepEquals, []string{"git@github.com:mcuadros/go-git.git"}) - c.Assert(cfg.Remotes["origin"].Fetch, DeepEquals, []RefSpec{"+refs/heads/*:refs/remotes/origin/*"}) - c.Assert(cfg.Remotes["alt"].Name, Equals, "alt") - c.Assert(cfg.Remotes["alt"].URLs, DeepEquals, []string{"git@github.com:mcuadros/go-git.git", "git@github.com:src-d/go-git.git"}) - c.Assert(cfg.Remotes["alt"].Fetch, DeepEquals, []RefSpec{"+refs/heads/*:refs/remotes/origin/*", "+refs/pull/*:refs/remotes/origin/pull/*"}) - c.Assert(cfg.Remotes["win-local"].Name, Equals, "win-local") - c.Assert(cfg.Remotes["win-local"].URLs, DeepEquals, []string{"X:\\Git\\"}) - c.Assert(cfg.Remotes["insteadOf"].URLs, DeepEquals, []string{"ssh://git@github.com/kostyay/go-git.git"}) - c.Assert(cfg.Submodules, HasLen, 1) - c.Assert(cfg.Submodules["qux"].Name, Equals, "qux") - c.Assert(cfg.Submodules["qux"].URL, Equals, "https://github.com/foo/qux.git") - c.Assert(cfg.Submodules["qux"].Branch, Equals, "bar") - c.Assert(cfg.Branches["master"].Remote, Equals, "origin") - c.Assert(cfg.Branches["master"].Merge, Equals, plumbing.ReferenceName("refs/heads/master")) - c.Assert(cfg.Branches["master"].Description, Equals, "Add support for branch description.\n\nEdit branch description: git branch --edit-description\n") - c.Assert(cfg.Init.DefaultBranch, Equals, "main") + s.NoError(err) + + s.True(cfg.Core.IsBare) + s.Equal("foo", cfg.Core.Worktree) + s.Equal("bar", cfg.Core.CommentChar) + s.Equal("John Doe", cfg.User.Name) + s.Equal("john@example.com", cfg.User.Email) + s.Equal("Jane Roe", cfg.Author.Name) + s.Equal("jane@example.com", cfg.Author.Email) + s.Equal("Richard Roe", cfg.Committer.Name) + s.Equal("richard@example.com", cfg.Committer.Email) + s.Equal(uint(20), cfg.Pack.Window) + s.Len(cfg.Remotes, 4) + s.Equal("origin", cfg.Remotes["origin"].Name) + s.Equal([]string{"git@github.com:mcuadros/go-git.git"}, cfg.Remotes["origin"].URLs) + s.Equal([]RefSpec{"+refs/heads/*:refs/remotes/origin/*"}, cfg.Remotes["origin"].Fetch) + s.Equal("alt", cfg.Remotes["alt"].Name) + s.Equal([]string{"git@github.com:mcuadros/go-git.git", "git@github.com:src-d/go-git.git"}, cfg.Remotes["alt"].URLs) + s.Equal([]RefSpec{"+refs/heads/*:refs/remotes/origin/*", "+refs/pull/*:refs/remotes/origin/pull/*"}, cfg.Remotes["alt"].Fetch) + s.Equal("win-local", cfg.Remotes["win-local"].Name) + s.Equal([]string{"X:\\Git\\"}, cfg.Remotes["win-local"].URLs) + s.Equal([]string{"ssh://git@github.com/kostyay/go-git.git"}, cfg.Remotes["insteadOf"].URLs) + s.Len(cfg.Submodules, 1) + s.Equal("qux", cfg.Submodules["qux"].Name) + s.Equal("https://github.com/foo/qux.git", cfg.Submodules["qux"].URL) + s.Equal("bar", cfg.Submodules["qux"].Branch) + s.Equal("origin", cfg.Branches["master"].Remote) + s.Equal(plumbing.ReferenceName("refs/heads/master"), cfg.Branches["master"].Merge) + s.Equal("Add support for branch description.\n\nEdit branch description: git branch --edit-description\n", cfg.Branches["master"].Description) + s.Equal("main", cfg.Init.DefaultBranch) } -func (s *ConfigSuite) TestMarshal(c *C) { +func (s *ConfigSuite) TestMarshal() { output := []byte(`[core] bare = true worktree = bar @@ -159,17 +165,17 @@ func (s *ConfigSuite) TestMarshal(c *C) { } cfg.URLs["ssh://git@github.com/"] = &URL{ - Name: "ssh://git@github.com/", - InsteadOf: "https://github.com/", + Name: "ssh://git@github.com/", + InsteadOfs: []string{"https://github.com/"}, } b, err := cfg.Marshal() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(string(b), Equals, string(output)) + s.Equal(string(output), string(b)) } -func (s *ConfigSuite) TestUnmarshalMarshal(c *C) { +func (s *ConfigSuite) TestUnmarshalMarshal() { input := []byte(`[core] bare = true worktree = foo @@ -202,24 +208,24 @@ func (s *ConfigSuite) TestUnmarshalMarshal(c *C) { cfg := NewConfig() err := cfg.Unmarshal(input) - c.Assert(err, IsNil) + s.NoError(err) output, err := cfg.Marshal() - c.Assert(err, IsNil) - c.Assert(string(output), DeepEquals, string(input)) + s.NoError(err) + s.Equal(string(input), string(output)) } -func (s *ConfigSuite) TestLoadConfigXDG(c *C) { +func (s *ConfigSuite) TestLoadConfigXDG() { cfg := NewConfig() cfg.User.Name = "foo" cfg.User.Email = "foo@foo.com" tmp, err := util.TempDir(osfs.Default, "", "test-commit-options") - c.Assert(err, IsNil) + s.NoError(err) defer util.RemoveAll(osfs.Default, tmp) err = osfs.Default.MkdirAll(filepath.Join(tmp, "git"), 0777) - c.Assert(err, IsNil) + s.NoError(err) os.Setenv("XDG_CONFIG_HOME", tmp) defer func() { @@ -227,19 +233,19 @@ func (s *ConfigSuite) TestLoadConfigXDG(c *C) { }() content, err := cfg.Marshal() - c.Assert(err, IsNil) + s.NoError(err) cfgFile := filepath.Join(tmp, "git/config") err = util.WriteFile(osfs.Default, cfgFile, content, 0777) - c.Assert(err, IsNil) + s.NoError(err) cfg, err = LoadConfig(GlobalScope) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(cfg.User.Email, Equals, "foo@foo.com") + s.Equal("foo@foo.com", cfg.User.Email) } -func (s *ConfigSuite) TestValidateConfig(c *C) { +func (s *ConfigSuite) TestValidateConfig() { config := &Config{ Remotes: map[string]*RemoteConfig{ "bar": { @@ -259,49 +265,49 @@ func (s *ConfigSuite) TestValidateConfig(c *C) { }, } - c.Assert(config.Validate(), IsNil) + s.NoError(config.Validate()) } -func (s *ConfigSuite) TestValidateInvalidRemote(c *C) { +func (s *ConfigSuite) TestValidateInvalidRemote() { config := &Config{ Remotes: map[string]*RemoteConfig{ "foo": {Name: "foo"}, }, } - c.Assert(config.Validate(), Equals, ErrRemoteConfigEmptyURL) + s.ErrorIs(config.Validate(), ErrRemoteConfigEmptyURL) } -func (s *ConfigSuite) TestValidateInvalidRemoteKey(c *C) { +func (s *ConfigSuite) TestValidateInvalidRemoteKey() { config := &Config{ Remotes: map[string]*RemoteConfig{ "bar": {Name: "foo"}, }, } - c.Assert(config.Validate(), Equals, ErrInvalid) + s.ErrorIs(config.Validate(), ErrInvalid) } -func (s *ConfigSuite) TestRemoteConfigValidateMissingURL(c *C) { +func (s *ConfigSuite) TestRemoteConfigValidateMissingURL() { config := &RemoteConfig{Name: "foo"} - c.Assert(config.Validate(), Equals, ErrRemoteConfigEmptyURL) + s.ErrorIs(config.Validate(), ErrRemoteConfigEmptyURL) } -func (s *ConfigSuite) TestRemoteConfigValidateMissingName(c *C) { +func (s *ConfigSuite) TestRemoteConfigValidateMissingName() { config := &RemoteConfig{} - c.Assert(config.Validate(), Equals, ErrRemoteConfigEmptyName) + s.ErrorIs(config.Validate(), ErrRemoteConfigEmptyName) } -func (s *ConfigSuite) TestRemoteConfigValidateDefault(c *C) { +func (s *ConfigSuite) TestRemoteConfigValidateDefault() { config := &RemoteConfig{Name: "foo", URLs: []string{"http://foo/bar"}} - c.Assert(config.Validate(), IsNil) + s.NoError(config.Validate()) fetch := config.Fetch - c.Assert(fetch, HasLen, 1) - c.Assert(fetch[0].String(), Equals, "+refs/heads/*:refs/remotes/foo/*") + s.Len(fetch, 1) + s.Equal("+refs/heads/*:refs/remotes/foo/*", fetch[0].String()) } -func (s *ConfigSuite) TestValidateInvalidBranchKey(c *C) { +func (s *ConfigSuite) TestValidateInvalidBranchKey() { config := &Config{ Branches: map[string]*Branch{ "foo": { @@ -312,10 +318,10 @@ func (s *ConfigSuite) TestValidateInvalidBranchKey(c *C) { }, } - c.Assert(config.Validate(), Equals, ErrInvalid) + s.ErrorIs(config.Validate(), ErrInvalid) } -func (s *ConfigSuite) TestValidateInvalidBranch(c *C) { +func (s *ConfigSuite) TestValidateInvalidBranch() { config := &Config{ Branches: map[string]*Branch{ "bar": { @@ -331,26 +337,26 @@ func (s *ConfigSuite) TestValidateInvalidBranch(c *C) { }, } - c.Assert(config.Validate(), Equals, errBranchInvalidMerge) + s.ErrorIs(config.Validate(), errBranchInvalidMerge) } -func (s *ConfigSuite) TestRemoteConfigDefaultValues(c *C) { +func (s *ConfigSuite) TestRemoteConfigDefaultValues() { config := NewConfig() - c.Assert(config.Remotes, HasLen, 0) - c.Assert(config.Branches, HasLen, 0) - c.Assert(config.Submodules, HasLen, 0) - c.Assert(config.Raw, NotNil) - c.Assert(config.Pack.Window, Equals, DefaultPackWindow) + s.Len(config.Remotes, 0) + s.Len(config.Branches, 0) + s.Len(config.Submodules, 0) + s.NotNil(config.Raw) + s.Equal(DefaultPackWindow, config.Pack.Window) } -func (s *ConfigSuite) TestLoadConfigLocalScope(c *C) { +func (s *ConfigSuite) TestLoadConfigLocalScope() { cfg, err := LoadConfig(LocalScope) - c.Assert(err, NotNil) - c.Assert(cfg, IsNil) + s.NotNil(err) + s.Nil(cfg) } -func (s *ConfigSuite) TestRemoveUrlOptions(c *C) { +func (s *ConfigSuite) TestRemoveUrlOptions() { buf := []byte(` [remote "alt"] url = git@github.com:mcuadros/go-git.git @@ -360,14 +366,57 @@ func (s *ConfigSuite) TestRemoveUrlOptions(c *C) { cfg := NewConfig() err := cfg.Unmarshal(buf) - c.Assert(err, IsNil) - c.Assert(len(cfg.Remotes), Equals, 1) + s.NoError(err) + s.Len(cfg.Remotes, 1) cfg.Remotes["alt"].URLs = []string{} buf, err = cfg.Marshal() - c.Assert(err, IsNil) + s.NoError(err) if strings.Contains(string(buf), "url") { - c.Fatal("conifg should not contain any url sections") + s.Fail("config should not contain any url sections") } - c.Assert(err, IsNil) + s.NoError(err) +} + +func (s *ConfigSuite) TestProtocol() { + buf := []byte(` +[protocol] + version = 1`) + + cfg := NewConfig() + err := cfg.Unmarshal(buf) + s.NoError(err) + s.Equal(protocol.V1, cfg.Protocol.Version) + + cfg.Protocol.Version = protocol.V2 + buf, err = cfg.Marshal() + s.NoError(err) + + if !strings.Contains(string(buf), "version = 2") { + s.Fail("marshal did not update version") + } + s.NoError(err) +} + +func (s *ConfigSuite) TestUnmarshalRemotes() { + input := []byte(`[core] + bare = true + worktree = foo + custom = ignored +[user] + name = John Doe + email = john@example.com +[remote "origin"] + url = https://git.sr.ht/~mcepl/go-git + pushurl = git@git.sr.ht:~mcepl/go-git.git + fetch = +refs/heads/*:refs/remotes/origin/* + mirror = true +`) + + cfg := NewConfig() + err := cfg.Unmarshal(input) + s.NoError(err) + + s.Equal("https://git.sr.ht/~mcepl/go-git", cfg.Remotes["origin"].URLs[0]) + s.Equal("git@git.sr.ht:~mcepl/go-git.git", cfg.Remotes["origin"].URLs[1]) } diff --git a/config/modules.go b/config/modules.go index 1c10aa354..898e2d9ec 100644 --- a/config/modules.go +++ b/config/modules.go @@ -5,7 +5,7 @@ import ( "errors" "regexp" - format "github.com/go-git/go-git/v5/plumbing/format/config" + format "github.com/jesseduffield/go-git/v5/plumbing/format/config" ) var ( diff --git a/config/modules_test.go b/config/modules_test.go index 8ea68e777..287bc070c 100644 --- a/config/modules_test.go +++ b/config/modules_test.go @@ -1,17 +1,25 @@ package config -import . "gopkg.in/check.v1" +import ( + "testing" -type ModulesSuite struct{} + "github.com/stretchr/testify/suite" +) -var _ = Suite(&ModulesSuite{}) +type ModulesSuite struct { + suite.Suite +} + +func TestModulesSuite(t *testing.T) { + suite.Run(t, new(ModulesSuite)) +} -func (s *ModulesSuite) TestValidateMissingURL(c *C) { +func (s *ModulesSuite) TestValidateMissingURL() { m := &Submodule{Path: "foo"} - c.Assert(m.Validate(), Equals, ErrModuleEmptyURL) + s.Equal(ErrModuleEmptyURL, m.Validate()) } -func (s *ModulesSuite) TestValidateBadPath(c *C) { +func (s *ModulesSuite) TestValidateBadPath() { input := []string{ `..`, `../`, @@ -30,16 +38,16 @@ func (s *ModulesSuite) TestValidateBadPath(c *C) { Path: p, URL: "https://example.com/", } - c.Assert(m.Validate(), Equals, ErrModuleBadPath) + s.Equal(ErrModuleBadPath, m.Validate()) } } -func (s *ModulesSuite) TestValidateMissingName(c *C) { +func (s *ModulesSuite) TestValidateMissingName() { m := &Submodule{URL: "bar"} - c.Assert(m.Validate(), Equals, ErrModuleEmptyPath) + s.Equal(ErrModuleEmptyPath, m.Validate()) } -func (s *ModulesSuite) TestMarshal(c *C) { +func (s *ModulesSuite) TestMarshal() { input := []byte(`[submodule "qux"] path = qux url = baz @@ -50,11 +58,11 @@ func (s *ModulesSuite) TestMarshal(c *C) { cfg.Submodules["qux"] = &Submodule{Path: "qux", URL: "baz", Branch: "bar"} output, err := cfg.Marshal() - c.Assert(err, IsNil) - c.Assert(output, DeepEquals, input) + s.NoError(err) + s.Equal(input, output) } -func (s *ModulesSuite) TestUnmarshal(c *C) { +func (s *ModulesSuite) TestUnmarshal() { input := []byte(`[submodule "qux"] path = qux url = https://github.com/foo/qux.git @@ -69,17 +77,17 @@ func (s *ModulesSuite) TestUnmarshal(c *C) { cfg := NewModules() err := cfg.Unmarshal(input) - c.Assert(err, IsNil) - - c.Assert(cfg.Submodules, HasLen, 2) - c.Assert(cfg.Submodules["qux"].Name, Equals, "qux") - c.Assert(cfg.Submodules["qux"].URL, Equals, "https://github.com/foo/qux.git") - c.Assert(cfg.Submodules["foo/bar"].Name, Equals, "foo/bar") - c.Assert(cfg.Submodules["foo/bar"].URL, Equals, "https://github.com/foo/bar.git") - c.Assert(cfg.Submodules["foo/bar"].Branch, Equals, "dev") + s.NoError(err) + + s.Len(cfg.Submodules, 2) + s.Equal("qux", cfg.Submodules["qux"].Name) + s.Equal("https://github.com/foo/qux.git", cfg.Submodules["qux"].URL) + s.Equal("foo/bar", cfg.Submodules["foo/bar"].Name) + s.Equal("https://github.com/foo/bar.git", cfg.Submodules["foo/bar"].URL) + s.Equal("dev", cfg.Submodules["foo/bar"].Branch) } -func (s *ModulesSuite) TestUnmarshalMarshal(c *C) { +func (s *ModulesSuite) TestUnmarshalMarshal() { input := []byte(`[submodule "foo/bar"] path = foo/bar url = https://github.com/foo/bar.git @@ -88,9 +96,9 @@ func (s *ModulesSuite) TestUnmarshalMarshal(c *C) { cfg := NewModules() err := cfg.Unmarshal(input) - c.Assert(err, IsNil) + s.NoError(err) output, err := cfg.Marshal() - c.Assert(err, IsNil) - c.Assert(string(output), DeepEquals, string(input)) + s.NoError(err) + s.Equal(string(input), string(output)) } diff --git a/config/refspec.go b/config/refspec.go index e2cf8c97b..9df1b9fd0 100644 --- a/config/refspec.go +++ b/config/refspec.go @@ -4,18 +4,20 @@ import ( "errors" "strings" - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" ) const ( refSpecWildcard = "*" refSpecForce = "+" refSpecSeparator = ":" + refSpecNegative = "^" ) var ( ErrRefSpecMalformedSeparator = errors.New("malformed refspec, separators are wrong") ErrRefSpecMalformedWildcard = errors.New("malformed refspec, mismatched number of wildcards") + ErrRefSpecMalformedNegative = errors.New("malformed negative refspec, one ^ and no separators allowed") ) // RefSpec is a mapping from local branches to remote references. @@ -31,6 +33,24 @@ type RefSpec string // Validate validates the RefSpec func (s RefSpec) Validate() error { spec := string(s) + + if strings.Index(spec, refSpecNegative) == 0 { + // This is a negative refspec + if strings.Count(spec, refSpecNegative) != 1 { + return ErrRefSpecMalformedNegative + } + + if strings.Count(spec, refSpecSeparator) != 0 { + return ErrRefSpecMalformedNegative + } + + if strings.Count(spec, refSpecWildcard) > 1 { + return ErrRefSpecMalformedWildcard + } + + return nil + } + if strings.Count(spec, refSpecSeparator) != 1 { return ErrRefSpecMalformedSeparator } @@ -64,12 +84,17 @@ func (s RefSpec) IsExactSHA1() bool { return plumbing.IsHash(s.Src()) } +// IsNegative returns if the refspec is a negative one +func (s RefSpec) IsNegative() bool { + return s[0] == refSpecNegative[0] +} + // Src returns the src side. func (s RefSpec) Src() string { spec := string(s) var start int - if s.IsForceUpdate() { + if s.IsForceUpdate() || s.IsNegative() { start = 1 } else { start = 0 diff --git a/config/refspec_test.go b/config/refspec_test.go index 3be757304..511e04aad 100644 --- a/config/refspec_test.go +++ b/config/refspec_test.go @@ -1,115 +1,118 @@ package config import ( + "fmt" "testing" - "github.com/go-git/go-git/v5/plumbing" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/stretchr/testify/suite" ) -type RefSpecSuite struct{} - -var _ = Suite(&RefSpecSuite{}) +type RefSpecSuite struct { + suite.Suite +} -func Test(t *testing.T) { TestingT(t) } +func TestRefSpecSuite(t *testing.T) { + suite.Run(t, new(RefSpecSuite)) +} -func (s *RefSpecSuite) TestRefSpecIsValid(c *C) { +func (s *RefSpecSuite) TestRefSpecIsValid() { spec := RefSpec("+refs/heads/*:refs/remotes/origin/*") - c.Assert(spec.Validate(), Equals, nil) + s.NoError(spec.Validate()) spec = RefSpec("refs/heads/*:refs/remotes/origin/") - c.Assert(spec.Validate(), Equals, ErrRefSpecMalformedWildcard) + s.ErrorIs(spec.Validate(), ErrRefSpecMalformedWildcard) spec = RefSpec("refs/heads/master:refs/remotes/origin/master") - c.Assert(spec.Validate(), Equals, nil) + s.NoError(spec.Validate()) spec = RefSpec(":refs/heads/master") - c.Assert(spec.Validate(), Equals, nil) + s.NoError(spec.Validate()) spec = RefSpec(":refs/heads/*") - c.Assert(spec.Validate(), Equals, ErrRefSpecMalformedWildcard) + s.ErrorIs(spec.Validate(), ErrRefSpecMalformedWildcard) spec = RefSpec(":*") - c.Assert(spec.Validate(), Equals, ErrRefSpecMalformedWildcard) + s.ErrorIs(spec.Validate(), ErrRefSpecMalformedWildcard) spec = RefSpec("refs/heads/*") - c.Assert(spec.Validate(), Equals, ErrRefSpecMalformedSeparator) + s.ErrorIs(spec.Validate(), ErrRefSpecMalformedSeparator) spec = RefSpec("refs/heads:") - c.Assert(spec.Validate(), Equals, ErrRefSpecMalformedSeparator) + s.ErrorIs(spec.Validate(), ErrRefSpecMalformedSeparator) spec = RefSpec("12039e008f9a4e3394f3f94f8ea897785cb09448:refs/heads/foo") - c.Assert(spec.Validate(), Equals, nil) + s.NoError(spec.Validate()) spec = RefSpec("12039e008f9a4e3394f3f94f8ea897785cb09448:refs/heads/*") - c.Assert(spec.Validate(), Equals, ErrRefSpecMalformedWildcard) + s.ErrorIs(spec.Validate(), ErrRefSpecMalformedWildcard) } -func (s *RefSpecSuite) TestRefSpecIsForceUpdate(c *C) { +func (s *RefSpecSuite) TestRefSpecIsForceUpdate() { spec := RefSpec("+refs/heads/*:refs/remotes/origin/*") - c.Assert(spec.IsForceUpdate(), Equals, true) + s.True(spec.IsForceUpdate()) spec = RefSpec("refs/heads/*:refs/remotes/origin/*") - c.Assert(spec.IsForceUpdate(), Equals, false) + s.False(spec.IsForceUpdate()) } -func (s *RefSpecSuite) TestRefSpecIsDelete(c *C) { +func (s *RefSpecSuite) TestRefSpecIsDelete() { spec := RefSpec(":refs/heads/master") - c.Assert(spec.IsDelete(), Equals, true) + s.True(spec.IsDelete()) spec = RefSpec("+refs/heads/*:refs/remotes/origin/*") - c.Assert(spec.IsDelete(), Equals, false) + s.False(spec.IsDelete()) spec = RefSpec("refs/heads/*:refs/remotes/origin/*") - c.Assert(spec.IsDelete(), Equals, false) + s.False(spec.IsDelete()) } -func (s *RefSpecSuite) TestRefSpecIsExactSHA1(c *C) { +func (s *RefSpecSuite) TestRefSpecIsExactSHA1() { spec := RefSpec("foo:refs/heads/master") - c.Assert(spec.IsExactSHA1(), Equals, false) + s.False(spec.IsExactSHA1()) spec = RefSpec("12039e008f9a4e3394f3f94f8ea897785cb09448:refs/heads/foo") - c.Assert(spec.IsExactSHA1(), Equals, true) + s.True(spec.IsExactSHA1()) } -func (s *RefSpecSuite) TestRefSpecSrc(c *C) { +func (s *RefSpecSuite) TestRefSpecSrc() { spec := RefSpec("refs/heads/*:refs/remotes/origin/*") - c.Assert(spec.Src(), Equals, "refs/heads/*") + s.Equal("refs/heads/*", spec.Src()) spec = RefSpec("+refs/heads/*:refs/remotes/origin/*") - c.Assert(spec.Src(), Equals, "refs/heads/*") + s.Equal("refs/heads/*", spec.Src()) spec = RefSpec(":refs/heads/master") - c.Assert(spec.Src(), Equals, "") + s.Equal("", spec.Src()) spec = RefSpec("refs/heads/love+hate:refs/heads/love+hate") - c.Assert(spec.Src(), Equals, "refs/heads/love+hate") + s.Equal("refs/heads/love+hate", spec.Src()) spec = RefSpec("+refs/heads/love+hate:refs/heads/love+hate") - c.Assert(spec.Src(), Equals, "refs/heads/love+hate") + s.Equal("refs/heads/love+hate", spec.Src()) } -func (s *RefSpecSuite) TestRefSpecMatch(c *C) { +func (s *RefSpecSuite) TestRefSpecMatch() { spec := RefSpec("refs/heads/master:refs/remotes/origin/master") - c.Assert(spec.Match(plumbing.ReferenceName("refs/heads/foo")), Equals, false) - c.Assert(spec.Match(plumbing.ReferenceName("refs/heads/master")), Equals, true) + s.False(spec.Match(plumbing.ReferenceName("refs/heads/foo"))) + s.True(spec.Match(plumbing.ReferenceName("refs/heads/master"))) spec = RefSpec("+refs/heads/master:refs/remotes/origin/master") - c.Assert(spec.Match(plumbing.ReferenceName("refs/heads/foo")), Equals, false) - c.Assert(spec.Match(plumbing.ReferenceName("refs/heads/master")), Equals, true) + s.False(spec.Match(plumbing.ReferenceName("refs/heads/foo"))) + s.True(spec.Match(plumbing.ReferenceName("refs/heads/master"))) spec = RefSpec(":refs/heads/master") - c.Assert(spec.Match(plumbing.ReferenceName("")), Equals, true) - c.Assert(spec.Match(plumbing.ReferenceName("refs/heads/master")), Equals, false) + s.True(spec.Match(plumbing.ReferenceName(""))) + s.False(spec.Match(plumbing.ReferenceName("refs/heads/master"))) spec = RefSpec("refs/heads/love+hate:heads/love+hate") - c.Assert(spec.Match(plumbing.ReferenceName("refs/heads/love+hate")), Equals, true) + s.True(spec.Match(plumbing.ReferenceName("refs/heads/love+hate"))) spec = RefSpec("+refs/heads/love+hate:heads/love+hate") - c.Assert(spec.Match(plumbing.ReferenceName("refs/heads/love+hate")), Equals, true) + s.True(spec.Match(plumbing.ReferenceName("refs/heads/love+hate"))) } -func (s *RefSpecSuite) TestRefSpecMatchGlob(c *C) { +func (s *RefSpecSuite) TestRefSpecMatchGlob() { tests := map[string]map[string]bool{ "refs/heads/*:refs/remotes/origin/*": { "refs/tag/foo": false, @@ -135,24 +138,21 @@ func (s *RefSpecSuite) TestRefSpecMatchGlob(c *C) { for specStr, data := range tests { spec := RefSpec(specStr) for ref, matches := range data { - c.Assert(spec.Match(plumbing.ReferenceName(ref)), - Equals, - matches, - Commentf("while matching spec %q against ref %q", specStr, ref), + s.Equal(matches, + spec.Match(plumbing.ReferenceName(ref)), + fmt.Sprintf("while matching spec %q against ref %q", specStr, ref), ) } } } -func (s *RefSpecSuite) TestRefSpecDst(c *C) { +func (s *RefSpecSuite) TestRefSpecDst() { spec := RefSpec("refs/heads/master:refs/remotes/origin/master") - c.Assert( - spec.Dst(plumbing.ReferenceName("refs/heads/master")).String(), Equals, - "refs/remotes/origin/master", - ) + s.Equal("refs/remotes/origin/master", + spec.Dst(plumbing.ReferenceName("refs/heads/master")).String()) } -func (s *RefSpecSuite) TestRefSpecDstBlob(c *C) { +func (s *RefSpecSuite) TestRefSpecDstBlob() { ref := "refs/heads/abc" tests := map[string]string{ "refs/heads/*:refs/remotes/origin/*": "refs/remotes/origin/abc", @@ -174,29 +174,25 @@ func (s *RefSpecSuite) TestRefSpecDstBlob(c *C) { for specStr, dst := range tests { spec := RefSpec(specStr) - c.Assert(spec.Dst(plumbing.ReferenceName(ref)).String(), - Equals, - dst, - Commentf("while getting dst from spec %q with ref %q", specStr, ref), + s.Equal(dst, + spec.Dst(plumbing.ReferenceName(ref)).String(), + fmt.Sprintf("while getting dst from spec %q with ref %q", specStr, ref), ) } } -func (s *RefSpecSuite) TestRefSpecReverse(c *C) { +func (s *RefSpecSuite) TestRefSpecReverse() { spec := RefSpec("refs/heads/*:refs/remotes/origin/*") - c.Assert( - spec.Reverse(), Equals, - RefSpec("refs/remotes/origin/*:refs/heads/*"), - ) + s.Equal(RefSpec("refs/remotes/origin/*:refs/heads/*"), spec.Reverse()) } -func (s *RefSpecSuite) TestMatchAny(c *C) { +func (s *RefSpecSuite) TestMatchAny() { specs := []RefSpec{ "refs/heads/bar:refs/remotes/origin/foo", "refs/heads/foo:refs/remotes/origin/bar", } - c.Assert(MatchAny(specs, plumbing.ReferenceName("refs/heads/foo")), Equals, true) - c.Assert(MatchAny(specs, plumbing.ReferenceName("refs/heads/bar")), Equals, true) - c.Assert(MatchAny(specs, plumbing.ReferenceName("refs/heads/master")), Equals, false) + s.True(MatchAny(specs, plumbing.ReferenceName("refs/heads/foo"))) + s.True(MatchAny(specs, plumbing.ReferenceName("refs/heads/bar"))) + s.False(MatchAny(specs, plumbing.ReferenceName("refs/heads/master"))) } diff --git a/config/url.go b/config/url.go index 114d6b266..c2f52f467 100644 --- a/config/url.go +++ b/config/url.go @@ -4,7 +4,7 @@ import ( "errors" "strings" - format "github.com/go-git/go-git/v5/plumbing/format/config" + format "github.com/jesseduffield/go-git/v5/plumbing/format/config" ) var ( @@ -17,7 +17,7 @@ type URL struct { Name string // Any URL that starts with this value will be rewritten to start, instead, with . // When more than one insteadOf strings match a given URL, the longest match is used. - InsteadOf string + InsteadOfs []string // raw representation of the subsection, filled by marshal or unmarshal are // called. @@ -26,7 +26,7 @@ type URL struct { // Validate validates fields of branch func (b *URL) Validate() error { - if b.InsteadOf == "" { + if len(b.InsteadOfs) == 0 { return errURLEmptyInsteadOf } @@ -41,7 +41,7 @@ func (u *URL) unmarshal(s *format.Subsection) error { u.raw = s u.Name = s.Name - u.InsteadOf = u.raw.Option(insteadOfKey) + u.InsteadOfs = u.raw.OptionAll(insteadOfKey) return nil } @@ -51,21 +51,28 @@ func (u *URL) marshal() *format.Subsection { } u.raw.Name = u.Name - u.raw.SetOption(insteadOfKey, u.InsteadOf) + u.raw.SetOption(insteadOfKey, u.InsteadOfs...) return u.raw } func findLongestInsteadOfMatch(remoteURL string, urls map[string]*URL) *URL { var longestMatch *URL - for _, u := range urls { - if !strings.HasPrefix(remoteURL, u.InsteadOf) { - continue - } + var longestMatchLength int - // according to spec if there is more than one match, take the logest - if longestMatch == nil || len(longestMatch.InsteadOf) < len(u.InsteadOf) { - longestMatch = u + for _, u := range urls { + for _, currentInsteadOf := range u.InsteadOfs { + if !strings.HasPrefix(remoteURL, currentInsteadOf) { + continue + } + + lengthCurrentInsteadOf := len(currentInsteadOf) + + // according to spec if there is more than one match, take the longest + if longestMatch == nil || longestMatchLength < lengthCurrentInsteadOf { + longestMatch = u + longestMatchLength = lengthCurrentInsteadOf + } } } @@ -73,9 +80,11 @@ func findLongestInsteadOfMatch(remoteURL string, urls map[string]*URL) *URL { } func (u *URL) ApplyInsteadOf(url string) string { - if !strings.HasPrefix(url, u.InsteadOf) { - return url + for _, j := range u.InsteadOfs { + if strings.HasPrefix(url, j) { + return u.Name + url[len(j):] + } } - return u.Name + url[len(u.InsteadOf):] + return url } diff --git a/config/url_test.go b/config/url_test.go index 5afc9f39b..b7d7eea91 100644 --- a/config/url_test.go +++ b/config/url_test.go @@ -1,24 +1,30 @@ package config import ( - . "gopkg.in/check.v1" + "testing" + + "github.com/stretchr/testify/suite" ) -type URLSuite struct{} +type URLSuite struct { + suite.Suite +} -var _ = Suite(&URLSuite{}) +func TestURLSuite(t *testing.T) { + suite.Run(t, new(URLSuite)) +} -func (b *URLSuite) TestValidateInsteadOf(c *C) { +func (b *URLSuite) TestValidateInsteadOf() { goodURL := URL{ - Name: "ssh://github.com", - InsteadOf: "http://github.com", + Name: "ssh://github.com", + InsteadOfs: []string{"http://github.com"}, } badURL := URL{} - c.Assert(goodURL.Validate(), IsNil) - c.Assert(badURL.Validate(), NotNil) + b.Nil(goodURL.Validate()) + b.NotNil(badURL.Validate()) } -func (b *URLSuite) TestMarshal(c *C) { +func (b *URLSuite) TestMarshal() { expected := []byte(`[core] bare = false [url "ssh://git@github.com/"] @@ -27,36 +33,109 @@ func (b *URLSuite) TestMarshal(c *C) { cfg := NewConfig() cfg.URLs["ssh://git@github.com/"] = &URL{ - Name: "ssh://git@github.com/", - InsteadOf: "https://github.com/", + Name: "ssh://git@github.com/", + InsteadOfs: []string{"https://github.com/"}, } actual, err := cfg.Marshal() - c.Assert(err, IsNil) - c.Assert(string(actual), Equals, string(expected)) + b.Nil(err) + b.Equal(string(expected), string(actual)) +} + +func (b *URLSuite) TestMarshalMultipleInsteadOf() { + expected := []byte(`[core] + bare = false +[url "ssh://git@github.com/"] + insteadOf = https://github.com/ + insteadOf = https://google.com/ +`) + + cfg := NewConfig() + cfg.URLs["ssh://git@github.com/"] = &URL{ + Name: "ssh://git@github.com/", + InsteadOfs: []string{"https://github.com/", "https://google.com/"}, + } + + actual, err := cfg.Marshal() + b.NoError(err) + b.Equal(string(expected), string(actual)) +} + +func (b *URLSuite) TestUnmarshal() { + input := []byte(`[core] + bare = false +[url "ssh://git@github.com/"] + insteadOf = https://github.com/ +`) + + cfg := NewConfig() + err := cfg.Unmarshal(input) + b.NoError(err) + url := cfg.URLs["ssh://git@github.com/"] + b.Equal("ssh://git@github.com/", url.Name) + b.Equal("https://github.com/", url.InsteadOfs[0]) } -func (b *URLSuite) TestUnmarshal(c *C) { +func (b *URLSuite) TestUnmarshalMultipleInsteadOf() { input := []byte(`[core] bare = false [url "ssh://git@github.com/"] insteadOf = https://github.com/ + insteadOf = https://google.com/ `) cfg := NewConfig() err := cfg.Unmarshal(input) - c.Assert(err, IsNil) + b.Nil(err) url := cfg.URLs["ssh://git@github.com/"] - c.Assert(url.Name, Equals, "ssh://git@github.com/") - c.Assert(url.InsteadOf, Equals, "https://github.com/") + b.Equal("ssh://git@github.com/", url.Name) + + b.Equal("ssh://git@github.com/foobar", url.ApplyInsteadOf("https://github.com/foobar")) + b.Equal("ssh://git@github.com/foobar", url.ApplyInsteadOf("https://google.com/foobar")) } -func (b *URLSuite) TestApplyInsteadOf(c *C) { +func (b *URLSuite) TestUnmarshalDuplicateUrls() { + input := []byte(`[core] + bare = false +[url "ssh://git@github.com/"] + insteadOf = https://github.com/ +[url "ssh://git@github.com/"] + insteadOf = https://google.com/ +`) + + cfg := NewConfig() + err := cfg.Unmarshal(input) + b.Nil(err) + url := cfg.URLs["ssh://git@github.com/"] + b.Equal("ssh://git@github.com/", url.Name) + + b.Equal("ssh://git@github.com/foobar", url.ApplyInsteadOf("https://github.com/foobar")) + b.Equal("ssh://git@github.com/foobar", url.ApplyInsteadOf("https://google.com/foobar")) +} + +func (b *URLSuite) TestApplyInsteadOf() { urlRule := URL{ - Name: "ssh://github.com", - InsteadOf: "http://github.com", + Name: "ssh://github.com", + InsteadOfs: []string{"http://github.com"}, } - c.Assert(urlRule.ApplyInsteadOf("http://google.com"), Equals, "http://google.com") - c.Assert(urlRule.ApplyInsteadOf("http://github.com/myrepo"), Equals, "ssh://github.com/myrepo") + b.Equal("http://google.com", urlRule.ApplyInsteadOf("http://google.com")) + b.Equal("ssh://github.com/myrepo", urlRule.ApplyInsteadOf("http://github.com/myrepo")) +} + +func (b *URLSuite) TestFindLongestInsteadOfMatch() { + urlRules := map[string]*URL{ + "ssh://github.com": &URL{ + Name: "ssh://github.com", + InsteadOfs: []string{"http://github.com"}, + }, + "ssh://somethingelse.com": &URL{ + Name: "ssh://somethingelse.com", + InsteadOfs: []string{"http://github.com/foobar"}, + }, + } + + longestUrl := findLongestInsteadOfMatch("http://github.com/foobar/bingbash.git", urlRules) + + b.Equal("ssh://somethingelse.com", longestUrl.Name) } diff --git a/example_test.go b/example_test.go index 7b6adc5a6..b679ef6e6 100644 --- a/example_test.go +++ b/example_test.go @@ -7,11 +7,11 @@ import ( "os" "path/filepath" - "github.com/go-git/go-git/v5" - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/transport/http" - "github.com/go-git/go-git/v5/storage/memory" + "github.com/jesseduffield/go-git/v5" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/transport/http" + "github.com/jesseduffield/go-git/v5/storage/memory" "github.com/go-git/go-billy/v5/memfs" ) diff --git a/go.mod b/go.mod index a42ff3a86..18bd888f1 100644 --- a/go.mod +++ b/go.mod @@ -1,47 +1,50 @@ -module github.com/go-git/go-git/v5 +module github.com/jesseduffield/go-git/v5 // go-git supports the last 3 stable Go versions. -go 1.20 +go 1.23.0 + +toolchain go1.23.6 + +// Use the v6-exp branch across go-git dependencies. +replace ( + github.com/go-git/gcfg => github.com/go-git/gcfg v1.5.1-0.20240812080926-1b398f6213c9 + github.com/go-git/go-billy/v5 => github.com/go-git/go-billy/v5 v5.0.0-20240804231525-dc481f5289ba + github.com/go-git/go-git-fixtures/v5 => github.com/go-git/go-git-fixtures/v5 v5.0.0-20241203230421-0753e18f8f03 +) require ( - dario.cat/mergo v1.0.0 - github.com/ProtonMail/go-crypto v1.0.0 + dario.cat/mergo v1.0.1 + github.com/Microsoft/go-winio v0.6.2 + github.com/ProtonMail/go-crypto v1.1.6 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 - github.com/elazarl/goproxy v0.0.0-20240618083138-03be62527ccb + github.com/elazarl/goproxy v1.7.2 github.com/emirpasic/gods v1.18.1 - github.com/gliderlabs/ssh v0.3.7 + github.com/gliderlabs/ssh v0.3.8 github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 - github.com/go-git/go-billy/v5 v5.5.1-0.20240427054813-8453aa90c6ec + github.com/go-git/go-billy/v5 v5.6.0 github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 - github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da - github.com/google/go-cmp v0.6.0 - github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 + github.com/go-git/go-git-fixtures/v5 v5.0.0-20241203230421-0753e18f8f03 + github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 github.com/kevinburke/ssh_config v1.2.0 - github.com/pjbgf/sha1cd v0.3.0 + github.com/pjbgf/sha1cd v0.3.2 github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 - github.com/skeema/knownhosts v1.3.0 - github.com/stretchr/testify v1.9.0 - github.com/xanzy/ssh-agent v0.3.3 - golang.org/x/crypto v0.26.0 - golang.org/x/net v0.28.0 - golang.org/x/sys v0.24.0 - golang.org/x/text v0.17.0 - gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c + github.com/stretchr/testify v1.10.0 + golang.org/x/crypto v0.36.0 + golang.org/x/exp v0.0.0-20250218142911-aa4b98e5adaa + golang.org/x/net v0.37.0 + golang.org/x/sys v0.31.0 + golang.org/x/text v0.23.0 ) require ( - github.com/Microsoft/go-winio v0.6.1 // indirect github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be // indirect - github.com/cloudflare/circl v1.3.7 // indirect - github.com/cyphar/filepath-securejoin v0.2.4 // indirect + github.com/cloudflare/circl v1.6.0 // indirect + github.com/cyphar/filepath-securejoin v0.4.1 // indirect github.com/davecgh/go-spew v1.1.1 // indirect github.com/kr/pretty v0.3.1 // indirect github.com/kr/text v0.2.0 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect - github.com/rogpeppe/go-internal v1.11.0 // indirect - golang.org/x/mod v0.17.0 // indirect - golang.org/x/sync v0.8.0 // indirect - golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d // indirect - gopkg.in/warnings.v0 v0.1.2 // indirect + github.com/rogpeppe/go-internal v1.14.1 // indirect + gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index 14ccc5a6b..2e2d24c7b 100644 --- a/go.sum +++ b/go.sum @@ -1,44 +1,37 @@ -dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk= -dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk= -github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY= -github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow= -github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM= -github.com/ProtonMail/go-crypto v1.0.0 h1:LRuvITjQWX+WIfr930YHG2HNfjR1uOfyf5vE0kC2U78= -github.com/ProtonMail/go-crypto v1.0.0/go.mod h1:EjAoLdwvbIOoOQr3ihjnSoLZRtE8azugULFRteWMNc0= +dario.cat/mergo v1.0.1 h1:Ra4+bf83h2ztPIQYNP99R6m+Y7KfnARDfID+a+vLl4s= +dario.cat/mergo v1.0.1/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk= +github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= +github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= +github.com/ProtonMail/go-crypto v1.1.6 h1:ZcV+Ropw6Qn0AX9brlQLAUXfqLBc7Bl+f/DmNxpLfdw= +github.com/ProtonMail/go-crypto v1.1.6/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE= github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8= github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4= github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio= github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= -github.com/bwesterb/go-ristretto v1.2.3/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0= -github.com/cloudflare/circl v1.3.3/go.mod h1:5XYMA4rFBvNIrhs50XuiBJ15vF2pZn4nnUKZrLbUZFA= -github.com/cloudflare/circl v1.3.7 h1:qlCDlTPz2n9fu58M0Nh1J/JzcFpfgkFHHX3O35r5vcU= -github.com/cloudflare/circl v1.3.7/go.mod h1:sRTcRWXGLrKw6yIGJ+l7amYJFfAXbZG0kBSc8r4zxgA= +github.com/cloudflare/circl v1.6.0 h1:cr5JKic4HI+LkINy2lg3W2jF8sHCVTBncJr5gIIq7qk= +github.com/cloudflare/circl v1.6.0/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= -github.com/cyphar/filepath-securejoin v0.2.4 h1:Ugdm7cg7i6ZK6x3xDF1oEu1nfkyfH53EtKeQYTC3kyg= -github.com/cyphar/filepath-securejoin v0.2.4/go.mod h1:aPGpWjXOXUn2NCNjFvBE6aRxGGx79pTxQpKOJNYHHl4= +github.com/cyphar/filepath-securejoin v0.4.1 h1:JyxxyPEaktOD+GAnqIqTf9A8tHyAG22rowi7HkoSU1s= +github.com/cyphar/filepath-securejoin v0.4.1/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/elazarl/goproxy v0.0.0-20240618083138-03be62527ccb h1:2SoxRauy2IqekRMggrQk3yNI5X6omSnk6ugVbFywwXs= -github.com/elazarl/goproxy v0.0.0-20240618083138-03be62527ccb/go.mod h1:Ro8st/ElPeALwNFlcTpWmkr6IoMFfkjXAvTHpevnDsM= -github.com/elazarl/goproxy/ext v0.0.0-20190711103511-473e67f1d7d2 h1:dWB6v3RcOy03t/bUadywsbyrQwCqZeNIEX6M1OtSZOM= -github.com/elazarl/goproxy/ext v0.0.0-20190711103511-473e67f1d7d2/go.mod h1:gNh8nYJoAm43RfaxurUnxr+N1PwuFV3ZMl/efxlIlY8= +github.com/elazarl/goproxy v1.7.2 h1:Y2o6urb7Eule09PjlhQRGNsqRfPmYI3KKQLFpCAV3+o= +github.com/elazarl/goproxy v1.7.2/go.mod h1:82vkLNir0ALaW14Rc399OTTjyNREgmdL2cVoIbS6XaE= github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc= github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ= -github.com/gliderlabs/ssh v0.3.7 h1:iV3Bqi942d9huXnzEF2Mt+CY9gLu8DNM4Obd+8bODRE= -github.com/gliderlabs/ssh v0.3.7/go.mod h1:zpHEXBstFnQYtGnB8k8kQLol82umzn/2/snG7alWVD8= -github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI= -github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic= -github.com/go-git/go-billy/v5 v5.5.1-0.20240427054813-8453aa90c6ec h1:JtjPVUU/+C1OaEXG+ojNfspw7t7Y30jiyr6zsXA8Eco= -github.com/go-git/go-billy/v5 v5.5.1-0.20240427054813-8453aa90c6ec/go.mod h1:bmsuIkj+yaSISZdLRNCLRaSiWnwDatBN1b62vLkXn24= +github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c= +github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU= +github.com/go-git/gcfg v1.5.1-0.20240812080926-1b398f6213c9 h1:cXTrGai8zhfi/EexEzYsukiYgWG6ykM9u13m9lDxikY= +github.com/go-git/gcfg v1.5.1-0.20240812080926-1b398f6213c9/go.mod h1:o1cBpkqNUIZUA3uO5RpFwFoOrnsgm1vg1ht4w3zWTvk= +github.com/go-git/go-billy/v5 v5.0.0-20240804231525-dc481f5289ba h1:ri3xJXEvkWt6LDkX24uy+MCmc4L9O/ZotjcVzZC+7Ug= +github.com/go-git/go-billy/v5 v5.0.0-20240804231525-dc481f5289ba/go.mod h1:j9ZRVN9a7j6LUbqf39FthSLGwo1+mGB4CN8bmUxdYVo= github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4= github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII= -github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE= -github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= -github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= -github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= -github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A= -github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo= +github.com/go-git/go-git-fixtures/v5 v5.0.0-20241203230421-0753e18f8f03 h1:LumE+tQdnYW24a9RoO08w64LHTzkNkdUqBD/0QPtlEY= +github.com/go-git/go-git-fixtures/v5 v5.0.0-20241203230421-0753e18f8f03/go.mod h1:hMKrMnUE4W0SJ7bFyM00dyz/HoknZoptGWzrj6M+dEM= +github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ= +github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw= github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4= github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= @@ -49,99 +42,36 @@ github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/onsi/gomega v1.27.10 h1:naR28SdDFlqrG6kScpT8VWpu1xWY5nJRCF3XaYyBjhI= -github.com/pjbgf/sha1cd v0.3.0 h1:4D5XXmUUBUl/xQ6IjCkEAbqXskkq/4O7LmGn0AqMDs4= -github.com/pjbgf/sha1cd v0.3.0/go.mod h1:nZ1rrWOcGJ5uZgEEVL1VUM9iRQiZvWdbZjkKyFzPPsI= +github.com/pjbgf/sha1cd v0.3.2 h1:a9wb0bp1oC2TGwStyn0Umc/IGKQnEgF0vVaZ8QF8eo4= +github.com/pjbgf/sha1cd v0.3.2/go.mod h1:zQWigSxVmsHEZow5qaLtPYxpcKMMQpa09ixqBxuCS6A= github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= -github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= -github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-charset v0.0.0-20180617210344-2471d30d28b4/go.mod h1:qgYeAmZ5ZIpBWTGllZSQnw97Dj+woV0toclVaRGI8pc= github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= -github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M= -github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA= +github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= +github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8= github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4= -github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= -github.com/skeema/knownhosts v1.3.0 h1:AM+y0rI04VksttfwjkSTNQorvGqmwATnvnAHpSgc0LY= -github.com/skeema/knownhosts v1.3.0/go.mod h1:sPINvnADmT/qYH1kfv+ePMmOBTH6Tbl7b5LvTDjFK7M= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= -github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= -github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= -github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM= -github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw= -github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= -golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= -golang.org/x/crypto v0.3.1-0.20221117191849-2c476679df9a/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4= -golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU= -golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw= -golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54= -golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= -golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA= -golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= -golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= -golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY= -golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= -golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc= -golang.org/x/net v0.28.0 h1:a9JDOJc5GMUJ0+UDqmLT86WiEy7iWyIhz8gz8E4e5hE= -golang.org/x/net v0.28.0/go.mod h1:yqtgsTWOOnlGLG9GFRrK3++bGOUEkNBoHZc8MEDWPNg= -golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ= -golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= -golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.24.0 h1:Twjiwq9dn6R1fQcyiK+wQyHWfaz/BJB+YIpzU/Cv3Xg= -golang.org/x/sys v0.24.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc= -golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= -golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U= -golang.org/x/term v0.23.0 h1:F6D4vR+EHoL9/sWAWgAR1H2DcHr4PareCbAaCo1RpuU= -golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= -golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= -golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc= -golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= -golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= -golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d h1:vU5i/LfpvrRCpgM/VPfJLg5KjxD3E+hfT1SH+d9zLwg= -golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk= -golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34= +golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc= +golang.org/x/exp v0.0.0-20250218142911-aa4b98e5adaa h1:t2QcU6V556bFjYgu4L6C+6VrCPyJZ+eyRsABUPs1mz4= +golang.org/x/exp v0.0.0-20250218142911-aa4b98e5adaa/go.mod h1:BHOTPb3L19zxehTsLoJXVaTktb06DFgmdW6Wb9s8jqk= +golang.org/x/net v0.37.0 h1:1zLorHbz+LYj7MQlSf1+2tPIIgibq2eL5xkrGk6f+2c= +golang.org/x/net v0.37.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8= +golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik= +golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/term v0.30.0 h1:PQ39fJZ+mfadBm0y5WlL4vlM7Sx1Hgf13sMIY2+QS9Y= +golang.org/x/term v0.30.0/go.mod h1:NYYFdzHoI5wRh/h5tDMdMqCqPJZEuNqVR5xJLd/n67g= +golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY= +golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME= -gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= diff --git a/internal/reference/sort.go b/internal/reference/sort.go index 726edbdd3..7df4f1e22 100644 --- a/internal/reference/sort.go +++ b/internal/reference/sort.go @@ -3,7 +3,7 @@ package reference import ( "sort" - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" ) // Sort sorts the references by name to ensure a consistent order. diff --git a/internal/revision/parser_test.go b/internal/revision/parser_test.go index 1eb386100..303cd5ffd 100644 --- a/internal/revision/parser_test.go +++ b/internal/revision/parser_test.go @@ -6,26 +6,30 @@ import ( "testing" "time" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) -type ParserSuite struct{} +type ParserSuite struct { + suite.Suite +} -var _ = Suite(&ParserSuite{}) +func TestParserSuite(t *testing.T) { + suite.Run(t, new(ParserSuite)) +} -func (s *ParserSuite) TestErrInvalidRevision(c *C) { +func (s *ParserSuite) TestErrInvalidRevision() { e := ErrInvalidRevision{"test"} - c.Assert(e.Error(), Equals, "Revision invalid : test") + s.Equal("Revision invalid : test", e.Error()) } -func (s *ParserSuite) TestNewParserFromString(c *C) { +func (s *ParserSuite) TestNewParserFromString() { p := NewParserFromString("test") - c.Assert(p, FitsTypeOf, &Parser{}) + s.IsType(&Parser{}, p) } -func (s *ParserSuite) TestScan(c *C) { +func (s *ParserSuite) TestScan() { parser := NewParser(bytes.NewBufferString("Hello world !")) expected := []struct { @@ -61,33 +65,33 @@ func (s *ParserSuite) TestScan(c *C) { return } - c.Assert(err, Equals, nil) - c.Assert(str, Equals, expected[i].s) - c.Assert(tok, Equals, expected[i].t) + s.NoError(err) + s.Equal(expected[i].s, str) + s.Equal(expected[i].t, tok) i++ } } -func (s *ParserSuite) TestUnscan(c *C) { +func (s *ParserSuite) TestUnscan() { parser := NewParser(bytes.NewBufferString("Hello world !")) tok, str, err := parser.scan() - c.Assert(err, Equals, nil) - c.Assert(str, Equals, "Hello") - c.Assert(tok, Equals, word) + s.NoError(err) + s.Equal("Hello", str) + s.Equal(word, tok) parser.unscan() tok, str, err = parser.scan() - c.Assert(err, Equals, nil) - c.Assert(str, Equals, "Hello") - c.Assert(tok, Equals, word) + s.NoError(err) + s.Equal("Hello", str) + s.Equal(word, tok) } -func (s *ParserSuite) TestParseWithValidExpression(c *C) { +func (s *ParserSuite) TestParseWithValidExpression() { tim, _ := time.Parse("2006-01-02T15:04:05Z", "2016-12-16T21:42:47Z") datas := map[string]Revisioner{ @@ -179,12 +183,12 @@ func (s *ParserSuite) TestParseWithValidExpression(c *C) { result, err := parser.Parse() - c.Assert(err, Equals, nil) - c.Assert(result, DeepEquals, expected) + s.NoError(err) + s.Equal(expected, result) } } -func (s *ParserSuite) TestParseWithInvalidExpression(c *C) { +func (s *ParserSuite) TestParseWithInvalidExpression() { datas := map[string]error{ "..": &ErrInvalidRevision{`must not start with "."`}, "master^1master": &ErrInvalidRevision{`reference must be defined once at the beginning`}, @@ -204,14 +208,14 @@ func (s *ParserSuite) TestParseWithInvalidExpression(c *C) { "@@{{0": &ErrInvalidRevision{`missing "}" in @{} structure`}, } - for s, e := range datas { - parser := NewParser(bytes.NewBufferString(s)) + for st, e := range datas { + parser := NewParser(bytes.NewBufferString(st)) _, err := parser.Parse() - c.Assert(err, DeepEquals, e) + s.Equal(err, e) } } -func (s *ParserSuite) TestParseAtWithValidExpression(c *C) { +func (s *ParserSuite) TestParseAtWithValidExpression() { tim, _ := time.Parse("2006-01-02T15:04:05Z", "2016-12-16T21:42:47Z") datas := map[string]Revisioner{ @@ -229,27 +233,27 @@ func (s *ParserSuite) TestParseAtWithValidExpression(c *C) { result, err := parser.parseAt() - c.Assert(err, Equals, nil) - c.Assert(result, DeepEquals, expected) + s.NoError(err) + s.Equal(expected, result) } } -func (s *ParserSuite) TestParseAtWithInvalidExpression(c *C) { +func (s *ParserSuite) TestParseAtWithInvalidExpression() { datas := map[string]error{ "{test}": &ErrInvalidRevision{`wrong date "test" must fit ISO-8601 format : 2006-01-02T15:04:05Z`}, "{-1": &ErrInvalidRevision{`missing "}" in @{-n} structure`}, } - for s, e := range datas { - parser := NewParser(bytes.NewBufferString(s)) + for st, e := range datas { + parser := NewParser(bytes.NewBufferString(st)) _, err := parser.parseAt() - c.Assert(err, DeepEquals, e) + s.Equal(err, e) } } -func (s *ParserSuite) TestParseCaretWithValidExpression(c *C) { +func (s *ParserSuite) TestParseCaretWithValidExpression() { datas := map[string]Revisioner{ "": CaretPath{1}, "2": CaretPath{2}, @@ -269,12 +273,12 @@ func (s *ParserSuite) TestParseCaretWithValidExpression(c *C) { result, err := parser.parseCaret() - c.Assert(err, Equals, nil) - c.Assert(result, DeepEquals, expected) + s.NoError(err) + s.Equal(expected, result) } } -func (s *ParserSuite) TestParseCaretWithUnValidExpression(c *C) { +func (s *ParserSuite) TestParseCaretWithUnValidExpression() { datas := map[string]error{ "3": &ErrInvalidRevision{`"3" found must be 0, 1 or 2 after "^"`}, "{test}": &ErrInvalidRevision{`"test" is not a valid revision suffix brace component`}, @@ -282,16 +286,16 @@ func (s *ParserSuite) TestParseCaretWithUnValidExpression(c *C) { "{/test**}": &ErrInvalidRevision{"revision suffix brace component, error parsing regexp: invalid nested repetition operator: `**`"}, } - for s, e := range datas { - parser := NewParser(bytes.NewBufferString(s)) + for st, e := range datas { + parser := NewParser(bytes.NewBufferString(st)) _, err := parser.parseCaret() - c.Assert(err, DeepEquals, e) + s.Equal(err, e) } } -func (s *ParserSuite) TestParseTildeWithValidExpression(c *C) { +func (s *ParserSuite) TestParseTildeWithValidExpression() { datas := map[string]Revisioner{ "3": TildePath{3}, "1": TildePath{1}, @@ -303,12 +307,12 @@ func (s *ParserSuite) TestParseTildeWithValidExpression(c *C) { result, err := parser.parseTilde() - c.Assert(err, Equals, nil) - c.Assert(result, DeepEquals, expected) + s.NoError(err) + s.Equal(expected, result) } } -func (s *ParserSuite) TestParseColonWithValidExpression(c *C) { +func (s *ParserSuite) TestParseColonWithValidExpression() { datas := map[string]Revisioner{ "/hello world !": ColonReg{regexp.MustCompile("hello world !"), false}, "/!-hello world !": ColonReg{regexp.MustCompile("hello world !"), true}, @@ -327,27 +331,27 @@ func (s *ParserSuite) TestParseColonWithValidExpression(c *C) { result, err := parser.parseColon() - c.Assert(err, Equals, nil) - c.Assert(result, DeepEquals, expected) + s.NoError(err) + s.Equal(expected, result) } } -func (s *ParserSuite) TestParseColonWithUnValidExpression(c *C) { +func (s *ParserSuite) TestParseColonWithUnValidExpression() { datas := map[string]error{ "/!test": &ErrInvalidRevision{`revision suffix brace component sequences starting with "/!" others than those defined are reserved`}, "/*": &ErrInvalidRevision{"revision suffix brace component, error parsing regexp: missing argument to repetition operator: `*`"}, } - for s, e := range datas { - parser := NewParser(bytes.NewBufferString(s)) + for st, e := range datas { + parser := NewParser(bytes.NewBufferString(st)) _, err := parser.parseColon() - c.Assert(err, DeepEquals, e) + s.Equal(err, e) } } -func (s *ParserSuite) TestParseRefWithValidName(c *C) { +func (s *ParserSuite) TestParseRefWithValidName() { datas := []string{ "lock", "master", @@ -366,12 +370,12 @@ func (s *ParserSuite) TestParseRefWithValidName(c *C) { result, err := parser.parseRef() - c.Assert(err, Equals, nil) - c.Assert(result, Equals, Ref(d)) + s.NoError(err) + s.Equal(Ref(d), result) } } -func (s *ParserSuite) TestParseRefWithInvalidName(c *C) { +func (s *ParserSuite) TestParseRefWithInvalidName() { datas := map[string]error{ ".master": &ErrInvalidRevision{`must not start with "."`}, "/master": &ErrInvalidRevision{`must not start with "/"`}, @@ -390,16 +394,24 @@ func (s *ParserSuite) TestParseRefWithInvalidName(c *C) { "test.lock": &ErrInvalidRevision{`cannot end with .lock`}, } - for s, e := range datas { - parser := NewParser(bytes.NewBufferString(s)) + for st, e := range datas { + parser := NewParser(bytes.NewBufferString(st)) _, err := parser.parseRef() - c.Assert(err, DeepEquals, e) + s.Equal(err, e) } } func FuzzParser(f *testing.F) { + f.Add("@{2016-12-16T21:42:47Z}") + f.Add("@~3") + f.Add("v0.99.8^{}") + f.Add("master:./README") + f.Add("HEAD^{/fix nasty bug}") + f.Add("HEAD^{/[A-") + f.Add(":/fix nasty bug") + f.Add(":/[A-") f.Fuzz(func(t *testing.T, input string) { parser := NewParser(bytes.NewBufferString(input)) diff --git a/internal/revision/scanner.go b/internal/revision/scanner.go index c46c21b79..2444f33ec 100644 --- a/internal/revision/scanner.go +++ b/internal/revision/scanner.go @@ -43,6 +43,11 @@ func tokenizeExpression(ch rune, tokenType token, check runeCategoryValidator, r return tokenType, string(data), nil } +// maxRevisionLength holds the maximum length that will be parsed for a +// revision. Git itself doesn't enforce a max length, but rather leans on +// the OS to enforce it via its ARG_MAX. +const maxRevisionLength = 128 * 1024 // 128kb + var zeroRune = rune(0) // scanner represents a lexical scanner. @@ -52,7 +57,7 @@ type scanner struct { // newScanner returns a new instance of scanner. func newScanner(r io.Reader) *scanner { - return &scanner{r: bufio.NewReader(r)} + return &scanner{r: bufio.NewReader(io.LimitReader(r, maxRevisionLength))} } // Scan extracts tokens and their strings counterpart diff --git a/internal/revision/scanner_test.go b/internal/revision/scanner_test.go index d27ccb130..ae20085e0 100644 --- a/internal/revision/scanner_test.go +++ b/internal/revision/scanner_test.go @@ -4,191 +4,193 @@ import ( "bytes" "testing" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } - -type ScannerSuite struct{} +type ScannerSuite struct { + suite.Suite +} -var _ = Suite(&ScannerSuite{}) +func TestScannerSuite(t *testing.T) { + suite.Run(t, new(ScannerSuite)) +} -func (s *ScannerSuite) TestReadColon(c *C) { +func (s *ScannerSuite) TestReadColon() { scanner := newScanner(bytes.NewBufferString(":")) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, ":") - c.Assert(tok, Equals, colon) + s.NoError(err) + s.Equal(":", data) + s.Equal(colon, tok) } -func (s *ScannerSuite) TestReadTilde(c *C) { +func (s *ScannerSuite) TestReadTilde() { scanner := newScanner(bytes.NewBufferString("~")) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, "~") - c.Assert(tok, Equals, tilde) + s.NoError(err) + s.Equal("~", data) + s.Equal(tilde, tok) } -func (s *ScannerSuite) TestReadCaret(c *C) { +func (s *ScannerSuite) TestReadCaret() { scanner := newScanner(bytes.NewBufferString("^")) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, "^") - c.Assert(tok, Equals, caret) + s.NoError(err) + s.Equal("^", data) + s.Equal(caret, tok) } -func (s *ScannerSuite) TestReadDot(c *C) { +func (s *ScannerSuite) TestReadDot() { scanner := newScanner(bytes.NewBufferString(".")) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, ".") - c.Assert(tok, Equals, dot) + s.NoError(err) + s.Equal(".", data) + s.Equal(dot, tok) } -func (s *ScannerSuite) TestReadSlash(c *C) { +func (s *ScannerSuite) TestReadSlash() { scanner := newScanner(bytes.NewBufferString("/")) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, "/") - c.Assert(tok, Equals, slash) + s.NoError(err) + s.Equal("/", data) + s.Equal(slash, tok) } -func (s *ScannerSuite) TestReadEOF(c *C) { +func (s *ScannerSuite) TestReadEOF() { scanner := newScanner(bytes.NewBufferString(string(rune(0)))) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, "") - c.Assert(tok, Equals, eof) + s.NoError(err) + s.Equal("", data) + s.Equal(eof, tok) } -func (s *ScannerSuite) TestReadNumber(c *C) { +func (s *ScannerSuite) TestReadNumber() { scanner := newScanner(bytes.NewBufferString("1234")) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, "1234") - c.Assert(tok, Equals, number) + s.NoError(err) + s.Equal("1234", data) + s.Equal(number, tok) } -func (s *ScannerSuite) TestReadSpace(c *C) { +func (s *ScannerSuite) TestReadSpace() { scanner := newScanner(bytes.NewBufferString(" ")) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, " ") - c.Assert(tok, Equals, space) + s.NoError(err) + s.Equal(" ", data) + s.Equal(space, tok) } -func (s *ScannerSuite) TestReadControl(c *C) { +func (s *ScannerSuite) TestReadControl() { scanner := newScanner(bytes.NewBufferString("")) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, "\x01") - c.Assert(tok, Equals, control) + s.NoError(err) + s.Equal("\x01", data) + s.Equal(control, tok) } -func (s *ScannerSuite) TestReadOpenBrace(c *C) { +func (s *ScannerSuite) TestReadOpenBrace() { scanner := newScanner(bytes.NewBufferString("{")) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, "{") - c.Assert(tok, Equals, obrace) + s.NoError(err) + s.Equal("{", data) + s.Equal(obrace, tok) } -func (s *ScannerSuite) TestReadCloseBrace(c *C) { +func (s *ScannerSuite) TestReadCloseBrace() { scanner := newScanner(bytes.NewBufferString("}")) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, "}") - c.Assert(tok, Equals, cbrace) + s.NoError(err) + s.Equal("}", data) + s.Equal(cbrace, tok) } -func (s *ScannerSuite) TestReadMinus(c *C) { +func (s *ScannerSuite) TestReadMinus() { scanner := newScanner(bytes.NewBufferString("-")) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, "-") - c.Assert(tok, Equals, minus) + s.NoError(err) + s.Equal("-", data) + s.Equal(minus, tok) } -func (s *ScannerSuite) TestReadAt(c *C) { +func (s *ScannerSuite) TestReadAt() { scanner := newScanner(bytes.NewBufferString("@")) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, "@") - c.Assert(tok, Equals, at) + s.NoError(err) + s.Equal("@", data) + s.Equal(at, tok) } -func (s *ScannerSuite) TestReadAntislash(c *C) { +func (s *ScannerSuite) TestReadAntislash() { scanner := newScanner(bytes.NewBufferString("\\")) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, "\\") - c.Assert(tok, Equals, aslash) + s.NoError(err) + s.Equal("\\", data) + s.Equal(aslash, tok) } -func (s *ScannerSuite) TestReadQuestionMark(c *C) { +func (s *ScannerSuite) TestReadQuestionMark() { scanner := newScanner(bytes.NewBufferString("?")) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, "?") - c.Assert(tok, Equals, qmark) + s.NoError(err) + s.Equal("?", data) + s.Equal(qmark, tok) } -func (s *ScannerSuite) TestReadAsterisk(c *C) { +func (s *ScannerSuite) TestReadAsterisk() { scanner := newScanner(bytes.NewBufferString("*")) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, "*") - c.Assert(tok, Equals, asterisk) + s.NoError(err) + s.Equal("*", data) + s.Equal(asterisk, tok) } -func (s *ScannerSuite) TestReadOpenBracket(c *C) { +func (s *ScannerSuite) TestReadOpenBracket() { scanner := newScanner(bytes.NewBufferString("[")) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, "[") - c.Assert(tok, Equals, obracket) + s.NoError(err) + s.Equal("[", data) + s.Equal(obracket, tok) } -func (s *ScannerSuite) TestReadExclamationMark(c *C) { +func (s *ScannerSuite) TestReadExclamationMark() { scanner := newScanner(bytes.NewBufferString("!")) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, "!") - c.Assert(tok, Equals, emark) + s.NoError(err) + s.Equal("!", data) + s.Equal(emark, tok) } -func (s *ScannerSuite) TestReadWord(c *C) { +func (s *ScannerSuite) TestReadWord() { scanner := newScanner(bytes.NewBufferString("abcde")) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, "abcde") - c.Assert(tok, Equals, word) + s.NoError(err) + s.Equal("abcde", data) + s.Equal(word, tok) } -func (s *ScannerSuite) TestReadTokenError(c *C) { +func (s *ScannerSuite) TestReadTokenError() { scanner := newScanner(bytes.NewBufferString("`")) tok, data, err := scanner.scan() - c.Assert(err, Equals, nil) - c.Assert(data, Equals, "`") - c.Assert(tok, Equals, tokenError) + s.NoError(err) + s.Equal("`", data) + s.Equal(tokenError, tok) } diff --git a/internal/test/checkers.go b/internal/test/checkers.go deleted file mode 100644 index 257d93d8c..000000000 --- a/internal/test/checkers.go +++ /dev/null @@ -1,43 +0,0 @@ -package test - -import ( - "errors" - "fmt" - - check "gopkg.in/check.v1" -) - -// This check.Checker implementation exists because there's no implementation -// in the library that compares errors using `errors.Is`. If / when the check -// library fixes https://github.com/go-check/check/issues/139, this code can -// likely be removed and replaced with the library implementation. -// -// Added in Go 1.13 [https://go.dev/blog/go1.13-errors] `errors.Is` is the -// best mechanism to use to compare errors that might be wrapped in other -// errors. -type errorIsChecker struct { - *check.CheckerInfo -} - -var ErrorIs check.Checker = errorIsChecker{ - &check.CheckerInfo{ - Name: "ErrorIs", - Params: []string{"obtained", "expected"}, - }, -} - -func (e errorIsChecker) Check(params []interface{}, names []string) (bool, string) { - obtained, ok := params[0].(error) - if !ok { - return false, "obtained is not an error" - } - expected, ok := params[1].(error) - if !ok { - return false, "expected is not an error" - } - - if !errors.Is(obtained, expected) { - return false, fmt.Sprintf("obtained: %+v expected: %+v", obtained, expected) - } - return true, "" -} diff --git a/internal/transport/http/proxy_test.go b/internal/transport/http/proxy_test.go new file mode 100644 index 000000000..bca89d500 --- /dev/null +++ b/internal/transport/http/proxy_test.go @@ -0,0 +1,57 @@ +package http + +import ( + "context" + "fmt" + "os" + "sync/atomic" + "testing" + + "github.com/elazarl/goproxy" + "github.com/jesseduffield/go-git/v5/internal/transport/http/test" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/plumbing/transport/http" + "github.com/stretchr/testify/suite" +) + +type ProxySuite struct { + suite.Suite +} + +func TestProxySuite(t *testing.T) { + suite.Run(t, new(ProxySuite)) +} + +// This test tests proxy support via an env var, i.e. `HTTPS_PROXY`. +// Its located in a separate package because golang caches the value +// of proxy env vars leading to misleading/unexpected test results. +func (s *ProxySuite) TestAdvertisedReferences() { + var proxiedRequests int32 + + proxy := goproxy.NewProxyHttpServer() + proxy.Verbose = true + test.SetupHTTPSProxy(proxy, &proxiedRequests) + + httpsProxyAddr, tlsProxyServer, httpsListener := test.SetupProxyServer(s.T(), proxy, true, false) + defer httpsListener.Close() + defer tlsProxyServer.Close() + + os.Setenv("HTTPS_PROXY", fmt.Sprintf("https://user:pass@%s", httpsProxyAddr)) + defer os.Unsetenv("HTTPS_PROXY") + + endpoint, err := transport.NewEndpoint("https://github.com/git-fixtures/basic.git") + s.NoError(err) + endpoint.InsecureSkipTLS = true + + client := http.DefaultClient + session, err := client.NewUploadPackSession(endpoint, nil) + s.NoError(err) + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + info, err := session.AdvertisedReferencesContext(ctx) + s.NoError(err) + s.NotNil(info) + proxyUsed := atomic.LoadInt32(&proxiedRequests) > 0 + s.True(proxyUsed) +} diff --git a/internal/transport/http/test/test_utils.go b/internal/transport/http/test/test_utils.go new file mode 100644 index 000000000..66c2ecd40 --- /dev/null +++ b/internal/transport/http/test/test_utils.go @@ -0,0 +1,130 @@ +package test + +import ( + "crypto/tls" + "embed" + "encoding/base64" + "errors" + "fmt" + "io" + "net" + "net/http" + "strings" + "sync/atomic" + "testing" + + "github.com/elazarl/goproxy" + "github.com/stretchr/testify/assert" +) + +//go:embed testdata/certs/* +var certs embed.FS + +// Make sure you close the server after the test. +func SetupProxyServer(t *testing.T, handler http.Handler, isTls, schemaAddr bool) (string, *http.Server, net.Listener) { + httpListener, err := net.Listen("tcp", "127.0.0.1:0") + assert.NoError(t, err) + + schema := "http" + if isTls { + schema = "https" + } + + addr := "localhost:%d" + if schemaAddr { + addr = schema + "://localhost:%d" + } + + httpProxyAddr := fmt.Sprintf(addr, httpListener.Addr().(*net.TCPAddr).Port) + proxyServer := http.Server{ + Addr: httpProxyAddr, + Handler: handler, + } + if isTls { + certf, err := certs.Open("testdata/certs/server.crt") + assert.NoError(t, err) + defer certf.Close() + keyf, err := certs.Open("testdata/certs/server.key") + assert.NoError(t, err) + defer keyf.Close() + cert, err := io.ReadAll(certf) + assert.NoError(t, err) + key, err := io.ReadAll(keyf) + assert.NoError(t, err) + keyPair, err := tls.X509KeyPair(cert, key) + assert.NoError(t, err) + cfg := &tls.Config{ + NextProtos: []string{"http/1.1"}, + Certificates: []tls.Certificate{keyPair}, + } + + // Due to how golang manages http/2 when provided with custom TLS config, + // servers and clients running in the same process leads to issues. + // Ref: https://github.com/golang/go/issues/21336 + proxyServer.TLSConfig = cfg + } + + go func() { + var err error + if isTls { + err = proxyServer.ServeTLS(httpListener, "", "") + } else { + err = proxyServer.Serve(httpListener) + } + if err != nil && !errors.Is(err, http.ErrServerClosed) { + panic(err) + } + }() + return httpProxyAddr, &proxyServer, httpListener +} + +func SetupHTTPProxy(proxy *goproxy.ProxyHttpServer, proxiedRequests *int32) { + // The request is being forwarded to the local test git server in this handler. + var proxyHandler goproxy.FuncReqHandler = func(req *http.Request, ctx *goproxy.ProxyCtx) (*http.Request, *http.Response) { + if strings.Contains(req.Host, "localhost") { + user, pass, _ := ParseBasicAuth(req.Header.Get("Proxy-Authorization")) + if user != "user" || pass != "pass" { + return req, goproxy.NewResponse(req, goproxy.ContentTypeText, http.StatusUnauthorized, "") + } + atomic.AddInt32(proxiedRequests, 1) + return req, nil + } + // Reject if it isn't our request. + return req, goproxy.NewResponse(req, goproxy.ContentTypeText, http.StatusForbidden, "") + } + proxy.OnRequest().Do(proxyHandler) +} + +func SetupHTTPSProxy(proxy *goproxy.ProxyHttpServer, proxiedRequests *int32) { + var proxyHandler goproxy.FuncHttpsHandler = func(host string, ctx *goproxy.ProxyCtx) (*goproxy.ConnectAction, string) { + if strings.Contains(host, "github.com") { + user, pass, _ := ParseBasicAuth(ctx.Req.Header.Get("Proxy-Authorization")) + if user != "user" || pass != "pass" { + return goproxy.RejectConnect, host + } + atomic.AddInt32(proxiedRequests, 1) + return goproxy.OkConnect, host + } + // Reject if it isn't our request. + return goproxy.RejectConnect, host + } + proxy.OnRequest().HandleConnect(proxyHandler) +} + +// adapted from https://github.com/golang/go/blob/2ef70d9d0f98832c8103a7968b195e560a8bb262/src/net/http/request.go#L959 +func ParseBasicAuth(auth string) (username, password string, ok bool) { + const prefix = "Basic " + if len(auth) < len(prefix) || !strings.EqualFold(auth[:len(prefix)], prefix) { + return "", "", false + } + c, err := base64.StdEncoding.DecodeString(auth[len(prefix):]) + if err != nil { + return "", "", false + } + cs := string(c) + username, password, ok = strings.Cut(cs, ":") + if !ok { + return "", "", false + } + return username, password, true +} diff --git a/plumbing/transport/http/testdata/certs/server.crt b/internal/transport/http/test/testdata/certs/server.crt similarity index 100% rename from plumbing/transport/http/testdata/certs/server.crt rename to internal/transport/http/test/testdata/certs/server.crt diff --git a/plumbing/transport/http/testdata/certs/server.key b/internal/transport/http/test/testdata/certs/server.key similarity index 100% rename from plumbing/transport/http/testdata/certs/server.key rename to internal/transport/http/test/testdata/certs/server.key diff --git a/plumbing/transport/ssh/internal/test/proxy_test.go b/internal/transport/ssh/test/proxy_test.go similarity index 67% rename from plumbing/transport/ssh/internal/test/proxy_test.go rename to internal/transport/ssh/test/proxy_test.go index 8e775f89a..d56f5ceb6 100644 --- a/plumbing/transport/ssh/internal/test/proxy_test.go +++ b/internal/transport/ssh/test/proxy_test.go @@ -12,37 +12,42 @@ import ( "github.com/armon/go-socks5" "github.com/gliderlabs/ssh" - "github.com/go-git/go-git/v5/plumbing/transport" - ggssh "github.com/go-git/go-git/v5/plumbing/transport/ssh" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + ggssh "github.com/jesseduffield/go-git/v5/plumbing/transport/ssh" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" stdssh "golang.org/x/crypto/ssh" - . "gopkg.in/check.v1" ) -func Test(t *testing.T) { TestingT(t) } +type ProxyEnvFixtureSuite struct { + fixtures.Suite +} type ProxyEnvSuite struct { - fixtures.Suite + suite.Suite + ProxyEnvFixtureSuite port int base string } -var _ = Suite(&ProxyEnvSuite{}) +func TestProxyEnvSuite(t *testing.T) { + suite.Run(t, new(ProxyEnvSuite)) +} var socksProxiedRequests int32 // This test tests proxy support via an env var, i.e. `ALL_PROXY`. // Its located in a separate package because golang caches the value // of proxy env vars leading to misleading/unexpected test results. -func (s *ProxyEnvSuite) TestCommand(c *C) { +func (s *ProxyEnvSuite) TestCommand() { socksListener, err := net.Listen("tcp", "localhost:0") - c.Assert(err, IsNil) + s.NoError(err) socksServer, err := socks5.New(&socks5.Config{ Rules: TestProxyRule{}, }) - c.Assert(err, IsNil) + s.NoError(err) go func() { socksServer.Serve(socksListener) }() @@ -51,56 +56,56 @@ func (s *ProxyEnvSuite) TestCommand(c *C) { defer os.Unsetenv("ALL_PROXY") sshListener, err := net.Listen("tcp", "localhost:0") - c.Assert(err, IsNil) + s.NoError(err) sshServer := &ssh.Server{Handler: HandlerSSH} go func() { log.Fatal(sshServer.Serve(sshListener)) }() s.port = sshListener.Addr().(*net.TCPAddr).Port - s.base, err = os.MkdirTemp(os.TempDir(), fmt.Sprintf("go-git-ssh-%d", s.port)) - c.Assert(err, IsNil) + s.base, err = os.MkdirTemp("", fmt.Sprintf("go-git-ssh-%d", s.port)) + s.NoError(err) ggssh.DefaultAuthBuilder = func(user string) (ggssh.AuthMethod, error) { return &ggssh.Password{User: user}, nil } - ep := s.prepareRepository(c, fixtures.Basic().One(), "basic.git") - c.Assert(err, IsNil) + ep := s.prepareRepository(fixtures.Basic().One(), "basic.git") + s.NoError(err) client := ggssh.NewClient(&stdssh.ClientConfig{ HostKeyCallback: stdssh.InsecureIgnoreHostKey(), }) r, err := client.NewUploadPackSession(ep, nil) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(r.Close()) }() info, err := r.AdvertisedReferences() - c.Assert(err, IsNil) - c.Assert(info, NotNil) + s.NoError(err) + s.NotNil(info) proxyUsed := atomic.LoadInt32(&socksProxiedRequests) > 0 - c.Assert(proxyUsed, Equals, true) + s.True(proxyUsed) } -func (s *ProxyEnvSuite) prepareRepository(c *C, f *fixtures.Fixture, name string) *transport.Endpoint { +func (s *ProxyEnvSuite) prepareRepository(f *fixtures.Fixture, name string) *transport.Endpoint { fs := f.DotGit() err := fixtures.EnsureIsBare(fs) - c.Assert(err, IsNil) + s.NoError(err) path := filepath.Join(s.base, name) err = os.Rename(fs.Root(), path) - c.Assert(err, IsNil) + s.NoError(err) - return s.newEndpoint(c, name) + return s.newEndpoint(name) } -func (s *ProxyEnvSuite) newEndpoint(c *C, name string) *transport.Endpoint { +func (s *ProxyEnvSuite) newEndpoint(name string) *transport.Endpoint { ep, err := transport.NewEndpoint(fmt.Sprintf( "ssh://git@localhost:%d/%s/%s", s.port, filepath.ToSlash(s.base), name, )) - c.Assert(err, IsNil) + s.NoError(err) return ep } diff --git a/plumbing/transport/ssh/internal/test/test_utils.go b/internal/transport/ssh/test/test_utils.go similarity index 100% rename from plumbing/transport/ssh/internal/test/test_utils.go rename to internal/transport/ssh/test/test_utils.go diff --git a/plumbing/transport/test/receive_pack.go b/internal/transport/test/receive_pack.go similarity index 54% rename from plumbing/transport/test/receive_pack.go rename to internal/transport/test/receive_pack.go index d4d2b1070..48c251c60 100644 --- a/plumbing/transport/test/receive_pack.go +++ b/internal/transport/test/receive_pack.go @@ -5,23 +5,25 @@ package test import ( "bytes" "context" + "fmt" "io" "os" "path/filepath" + "regexp" - . "github.com/go-git/go-git/v5/internal/test" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/packfile" - "github.com/go-git/go-git/v5/plumbing/protocol/packp" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/storage/memory" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/packfile" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) type ReceivePackSuite struct { + suite.Suite Endpoint *transport.Endpoint EmptyEndpoint *transport.Endpoint NonExistentEndpoint *transport.Endpoint @@ -29,72 +31,72 @@ type ReceivePackSuite struct { Client transport.Transport } -func (s *ReceivePackSuite) TestAdvertisedReferencesEmpty(c *C) { +func (s *ReceivePackSuite) TestAdvertisedReferencesEmpty() { r, err := s.Client.NewReceivePackSession(s.EmptyEndpoint, s.EmptyAuth) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(r.Close()) }() ar, err := r.AdvertisedReferences() - c.Assert(err, IsNil) - c.Assert(ar.Head, IsNil) + s.NoError(err) + s.Nil(ar.Head) } -func (s *ReceivePackSuite) TestAdvertisedReferencesNotExists(c *C) { +func (s *ReceivePackSuite) TestAdvertisedReferencesNotExists() { r, err := s.Client.NewReceivePackSession(s.NonExistentEndpoint, s.EmptyAuth) - c.Assert(err, IsNil) + s.NoError(err) ar, err := r.AdvertisedReferences() - c.Assert(err, ErrorIs, transport.ErrRepositoryNotFound) - c.Assert(ar, IsNil) - c.Assert(r.Close(), IsNil) + s.ErrorIs(err, transport.ErrRepositoryNotFound) + s.Nil(ar) + s.Nil(r.Close()) r, err = s.Client.NewReceivePackSession(s.NonExistentEndpoint, s.EmptyAuth) - c.Assert(err, IsNil) + s.NoError(err) req := packp.NewReferenceUpdateRequest() req.Commands = []*packp.Command{ {Name: "master", Old: plumbing.ZeroHash, New: plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")}, } writer, err := r.ReceivePack(context.Background(), req) - c.Assert(err, ErrorIs, transport.ErrRepositoryNotFound) - c.Assert(writer, IsNil) - c.Assert(r.Close(), IsNil) + s.ErrorIs(err, transport.ErrRepositoryNotFound) + s.Nil(writer) + s.Nil(r.Close()) } -func (s *ReceivePackSuite) TestCallAdvertisedReferenceTwice(c *C) { +func (s *ReceivePackSuite) TestCallAdvertisedReferenceTwice() { r, err := s.Client.NewReceivePackSession(s.Endpoint, s.EmptyAuth) - defer func() { c.Assert(r.Close(), IsNil) }() - c.Assert(err, IsNil) + defer func() { s.Nil(r.Close()) }() + s.NoError(err) ar1, err := r.AdvertisedReferences() - c.Assert(err, IsNil) - c.Assert(ar1, NotNil) + s.NoError(err) + s.NotNil(ar1) ar2, err := r.AdvertisedReferences() - c.Assert(err, IsNil) - c.Assert(ar2, DeepEquals, ar1) + s.NoError(err) + s.Equal(ar1, ar2) } -func (s *ReceivePackSuite) TestDefaultBranch(c *C) { +func (s *ReceivePackSuite) TestDefaultBranch() { r, err := s.Client.NewReceivePackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(r.Close()) }() info, err := r.AdvertisedReferences() - c.Assert(err, IsNil) + s.NoError(err) ref, ok := info.References["refs/heads/master"] - c.Assert(ok, Equals, true) - c.Assert(ref.String(), Equals, fixtures.Basic().One().Head) + s.True(ok) + s.Equal(fixtures.Basic().One().Head, ref.String()) } -func (s *ReceivePackSuite) TestCapabilities(c *C) { +func (s *ReceivePackSuite) TestCapabilities() { r, err := s.Client.NewReceivePackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(r.Close()) }() info, err := r.AdvertisedReferences() - c.Assert(err, IsNil) - c.Assert(info.Capabilities.Get("agent"), HasLen, 1) + s.NoError(err) + s.Len(info.Capabilities.Get("agent"), 1) } -func (s *ReceivePackSuite) TestFullSendPackOnEmpty(c *C) { +func (s *ReceivePackSuite) TestFullSendPackOnEmpty() { endpoint := s.EmptyEndpoint full := true fixture := fixtures.Basic().ByTag("packfile").One() @@ -102,11 +104,11 @@ func (s *ReceivePackSuite) TestFullSendPackOnEmpty(c *C) { req.Commands = []*packp.Command{ {Name: "refs/heads/master", Old: plumbing.ZeroHash, New: plumbing.NewHash(fixture.Head)}, } - s.receivePack(c, endpoint, req, fixture, full) - s.checkRemoteHead(c, endpoint, plumbing.NewHash(fixture.Head)) + s.receivePack(endpoint, req, fixture, full) + s.checkRemoteHead(endpoint, plumbing.NewHash(fixture.Head)) } -func (s *ReceivePackSuite) TestSendPackWithContext(c *C) { +func (s *ReceivePackSuite) TestSendPackWithContext() { fixture := fixtures.Basic().ByTag("packfile").One() req := packp.NewReferenceUpdateRequest() req.Packfile = fixture.Packfile() @@ -115,22 +117,22 @@ func (s *ReceivePackSuite) TestSendPackWithContext(c *C) { } r, err := s.Client.NewReceivePackSession(s.EmptyEndpoint, s.EmptyAuth) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(r.Close()) }() info, err := r.AdvertisedReferences() - c.Assert(err, IsNil) - c.Assert(info, NotNil) + s.NoError(err) + s.NotNil(info) ctx, close := context.WithCancel(context.TODO()) close() report, err := r.ReceivePack(ctx, req) - c.Assert(err, NotNil) - c.Assert(report, IsNil) + s.NotNil(err) + s.Nil(report) } -func (s *ReceivePackSuite) TestSendPackOnEmpty(c *C) { +func (s *ReceivePackSuite) TestSendPackOnEmpty() { endpoint := s.EmptyEndpoint full := false fixture := fixtures.Basic().ByTag("packfile").One() @@ -138,11 +140,11 @@ func (s *ReceivePackSuite) TestSendPackOnEmpty(c *C) { req.Commands = []*packp.Command{ {Name: "refs/heads/master", Old: plumbing.ZeroHash, New: plumbing.NewHash(fixture.Head)}, } - s.receivePack(c, endpoint, req, fixture, full) - s.checkRemoteHead(c, endpoint, plumbing.NewHash(fixture.Head)) + s.receivePack(endpoint, req, fixture, full) + s.checkRemoteHead(endpoint, plumbing.NewHash(fixture.Head)) } -func (s *ReceivePackSuite) TestSendPackOnEmptyWithReportStatus(c *C) { +func (s *ReceivePackSuite) TestSendPackOnEmptyWithReportStatus() { endpoint := s.EmptyEndpoint full := false fixture := fixtures.Basic().ByTag("packfile").One() @@ -151,11 +153,11 @@ func (s *ReceivePackSuite) TestSendPackOnEmptyWithReportStatus(c *C) { {Name: "refs/heads/master", Old: plumbing.ZeroHash, New: plumbing.NewHash(fixture.Head)}, } req.Capabilities.Set(capability.ReportStatus) - s.receivePack(c, endpoint, req, fixture, full) - s.checkRemoteHead(c, endpoint, plumbing.NewHash(fixture.Head)) + s.receivePack(endpoint, req, fixture, full) + s.checkRemoteHead(endpoint, plumbing.NewHash(fixture.Head)) } -func (s *ReceivePackSuite) TestFullSendPackOnNonEmpty(c *C) { +func (s *ReceivePackSuite) TestFullSendPackOnNonEmpty() { endpoint := s.Endpoint full := true fixture := fixtures.Basic().ByTag("packfile").One() @@ -163,11 +165,11 @@ func (s *ReceivePackSuite) TestFullSendPackOnNonEmpty(c *C) { req.Commands = []*packp.Command{ {Name: "refs/heads/master", Old: plumbing.NewHash(fixture.Head), New: plumbing.NewHash(fixture.Head)}, } - s.receivePack(c, endpoint, req, fixture, full) - s.checkRemoteHead(c, endpoint, plumbing.NewHash(fixture.Head)) + s.receivePack(endpoint, req, fixture, full) + s.checkRemoteHead(endpoint, plumbing.NewHash(fixture.Head)) } -func (s *ReceivePackSuite) TestSendPackOnNonEmpty(c *C) { +func (s *ReceivePackSuite) TestSendPackOnNonEmpty() { endpoint := s.Endpoint full := false fixture := fixtures.Basic().ByTag("packfile").One() @@ -175,11 +177,11 @@ func (s *ReceivePackSuite) TestSendPackOnNonEmpty(c *C) { req.Commands = []*packp.Command{ {Name: "refs/heads/master", Old: plumbing.NewHash(fixture.Head), New: plumbing.NewHash(fixture.Head)}, } - s.receivePack(c, endpoint, req, fixture, full) - s.checkRemoteHead(c, endpoint, plumbing.NewHash(fixture.Head)) + s.receivePack(endpoint, req, fixture, full) + s.checkRemoteHead(endpoint, plumbing.NewHash(fixture.Head)) } -func (s *ReceivePackSuite) TestSendPackOnNonEmptyWithReportStatus(c *C) { +func (s *ReceivePackSuite) TestSendPackOnNonEmptyWithReportStatus() { endpoint := s.Endpoint full := false fixture := fixtures.Basic().ByTag("packfile").One() @@ -189,11 +191,11 @@ func (s *ReceivePackSuite) TestSendPackOnNonEmptyWithReportStatus(c *C) { } req.Capabilities.Set(capability.ReportStatus) - s.receivePack(c, endpoint, req, fixture, full) - s.checkRemoteHead(c, endpoint, plumbing.NewHash(fixture.Head)) + s.receivePack(endpoint, req, fixture, full) + s.checkRemoteHead(endpoint, plumbing.NewHash(fixture.Head)) } -func (s *ReceivePackSuite) TestSendPackOnNonEmptyWithReportStatusWithError(c *C) { +func (s *ReceivePackSuite) TestSendPackOnNonEmptyWithReportStatusWithError() { endpoint := s.Endpoint full := false fixture := fixtures.Basic().ByTag("packfile").One() @@ -203,26 +205,27 @@ func (s *ReceivePackSuite) TestSendPackOnNonEmptyWithReportStatusWithError(c *C) } req.Capabilities.Set(capability.ReportStatus) - report, err := s.receivePackNoCheck(c, endpoint, req, fixture, full) - //XXX: Recent git versions return "failed to update ref", while older + report, err := s.receivePackNoCheck(endpoint, req, fixture, full) + // XXX: Recent git versions return "failed to update ref", while older // (>=1.9) return "failed to lock". - c.Assert(err, ErrorMatches, ".*(failed to update ref|failed to lock).*") - c.Assert(report.UnpackStatus, Equals, "ok") - c.Assert(len(report.CommandStatuses), Equals, 1) - c.Assert(report.CommandStatuses[0].ReferenceName, Equals, plumbing.ReferenceName("refs/heads/master")) - c.Assert(report.CommandStatuses[0].Status, Matches, "(failed to update ref|failed to lock)") - s.checkRemoteHead(c, endpoint, plumbing.NewHash(fixture.Head)) + s.Regexp(regexp.MustCompile(".*(failed to update ref|failed to lock).*"), err) + s.Equal("ok", report.UnpackStatus) + s.Len(report.CommandStatuses, 1) + s.Equal(plumbing.ReferenceName("refs/heads/master"), report.CommandStatuses[0].ReferenceName) + s.Regexp(regexp.MustCompile("(failed to update ref|failed to lock)"), report.CommandStatuses[0].Status) + s.checkRemoteHead(endpoint, plumbing.NewHash(fixture.Head)) } -func (s *ReceivePackSuite) receivePackNoCheck(c *C, ep *transport.Endpoint, +func (s *ReceivePackSuite) receivePackNoCheck(ep *transport.Endpoint, req *packp.ReferenceUpdateRequest, fixture *fixtures.Fixture, - callAdvertisedReferences bool) (*packp.ReportStatus, error) { + callAdvertisedReferences bool, +) (*packp.ReportStatus, error) { url := "" if fixture != nil { url = fixture.URL } - comment := Commentf( - "failed with ep=%s fixture=%s callAdvertisedReferences=%s", + comment := fmt.Sprintf( + "failed with ep=%s fixture=%s callAdvertisedReferences=%v", ep.String(), url, callAdvertisedReferences, ) @@ -235,27 +238,27 @@ func (s *ReceivePackSuite) receivePackNoCheck(c *C, ep *transport.Endpoint, if rootPath != "" && err == nil && stat.IsDir() { objectPath := filepath.Join(rootPath, "objects/pack") files, err := os.ReadDir(objectPath) - c.Assert(err, IsNil) + s.NoError(err) for _, file := range files { path := filepath.Join(objectPath, file.Name()) - err = os.Chmod(path, 0644) - c.Assert(err, IsNil) + err = os.Chmod(path, 0o644) + s.NoError(err) } } r, err := s.Client.NewReceivePackSession(ep, s.EmptyAuth) - c.Assert(err, IsNil, comment) - defer func() { c.Assert(r.Close(), IsNil, comment) }() + s.NoError(err, comment) + defer func() { s.NoError(r.Close(), comment) }() if callAdvertisedReferences { info, err := r.AdvertisedReferences() - c.Assert(err, IsNil, comment) - c.Assert(info, NotNil, comment) + s.NoError(err, comment) + s.NotNil(info, comment) } if fixture != nil { - c.Assert(fixture.Packfile(), NotNil) + s.NotNil(fixture.Packfile()) req.Packfile = fixture.Packfile() } else { req.Packfile = s.emptyPackfile() @@ -264,62 +267,63 @@ func (s *ReceivePackSuite) receivePackNoCheck(c *C, ep *transport.Endpoint, return r.ReceivePack(context.Background(), req) } -func (s *ReceivePackSuite) receivePack(c *C, ep *transport.Endpoint, +func (s *ReceivePackSuite) receivePack(ep *transport.Endpoint, req *packp.ReferenceUpdateRequest, fixture *fixtures.Fixture, - callAdvertisedReferences bool) { + callAdvertisedReferences bool, +) { url := "" if fixture != nil { url = fixture.URL } - comment := Commentf( - "failed with ep=%s fixture=%s callAdvertisedReferences=%s", + comment := fmt.Sprintf( + "failed with ep=%s fixture=%s callAdvertisedReferences=%v", ep.String(), url, callAdvertisedReferences, ) - report, err := s.receivePackNoCheck(c, ep, req, fixture, callAdvertisedReferences) - c.Assert(err, IsNil, comment) + report, err := s.receivePackNoCheck(ep, req, fixture, callAdvertisedReferences) + s.NoError(err, comment) if req.Capabilities.Supports(capability.ReportStatus) { - c.Assert(report, NotNil, comment) - c.Assert(report.Error(), IsNil, comment) + s.NotNil(report, comment) + s.NoError(report.Error(), comment) } else { - c.Assert(report, IsNil, comment) + s.Nil(report, comment) } } -func (s *ReceivePackSuite) checkRemoteHead(c *C, ep *transport.Endpoint, head plumbing.Hash) { - s.checkRemoteReference(c, ep, "refs/heads/master", head) +func (s *ReceivePackSuite) checkRemoteHead(ep *transport.Endpoint, head plumbing.Hash) { + s.checkRemoteReference(ep, "refs/heads/master", head) } -func (s *ReceivePackSuite) checkRemoteReference(c *C, ep *transport.Endpoint, - refName string, head plumbing.Hash) { - +func (s *ReceivePackSuite) checkRemoteReference(ep *transport.Endpoint, + refName string, head plumbing.Hash, +) { r, err := s.Client.NewUploadPackSession(ep, s.EmptyAuth) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(r.Close()) }() ar, err := r.AdvertisedReferences() - c.Assert(err, IsNil, Commentf("endpoint: %s", ep.String())) + s.NoError(err, fmt.Sprintf("endpoint: %s", ep.String())) ref, ok := ar.References[refName] if head == plumbing.ZeroHash { - c.Assert(ok, Equals, false) + s.False(ok) } else { - c.Assert(ok, Equals, true) - c.Assert(ref, DeepEquals, head) + s.True(ok) + s.Equal(head, ref) } } -func (s *ReceivePackSuite) TestSendPackAddDeleteReference(c *C) { - s.testSendPackAddReference(c) - s.testSendPackDeleteReference(c) +func (s *ReceivePackSuite) TestSendPackAddDeleteReference() { + s.testSendPackAddReference() + s.testSendPackDeleteReference() } -func (s *ReceivePackSuite) testSendPackAddReference(c *C) { +func (s *ReceivePackSuite) testSendPackAddReference() { r, err := s.Client.NewReceivePackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) + s.NoError(err) fixture := fixtures.Basic().ByTag("packfile").One() ar, err := r.AdvertisedReferences() - c.Assert(err, IsNil) + s.NoError(err) req := packp.NewReferenceUpdateRequest() req.Commands = []*packp.Command{ @@ -329,20 +333,20 @@ func (s *ReceivePackSuite) testSendPackAddReference(c *C) { req.Capabilities.Set(capability.ReportStatus) } - c.Assert(r.Close(), IsNil) + s.Nil(r.Close()) - s.receivePack(c, s.Endpoint, req, nil, false) - s.checkRemoteReference(c, s.Endpoint, "refs/heads/newbranch", plumbing.NewHash(fixture.Head)) + s.receivePack(s.Endpoint, req, nil, false) + s.checkRemoteReference(s.Endpoint, "refs/heads/newbranch", plumbing.NewHash(fixture.Head)) } -func (s *ReceivePackSuite) testSendPackDeleteReference(c *C) { +func (s *ReceivePackSuite) testSendPackDeleteReference() { r, err := s.Client.NewReceivePackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) + s.NoError(err) fixture := fixtures.Basic().ByTag("packfile").One() ar, err := r.AdvertisedReferences() - c.Assert(err, IsNil) + s.NoError(err) req := packp.NewReferenceUpdateRequest() req.Commands = []*packp.Command{ @@ -353,13 +357,13 @@ func (s *ReceivePackSuite) testSendPackDeleteReference(c *C) { } if !ar.Capabilities.Supports(capability.DeleteRefs) { - c.Fatal("capability delete-refs not supported") + s.Fail("capability delete-refs not supported") } - c.Assert(r.Close(), IsNil) + s.Nil(r.Close()) - s.receivePack(c, s.Endpoint, req, nil, false) - s.checkRemoteReference(c, s.Endpoint, "refs/heads/newbranch", plumbing.ZeroHash) + s.receivePack(s.Endpoint, req, nil, false) + s.checkRemoteReference(s.Endpoint, "refs/heads/newbranch", plumbing.ZeroHash) } func (s *ReceivePackSuite) emptyPackfile() io.ReadCloser { diff --git a/plumbing/transport/test/upload_pack.go b/internal/transport/test/upload_pack.go similarity index 56% rename from plumbing/transport/test/upload_pack.go rename to internal/transport/test/upload_pack.go index f7842ebb7..b40ee3f83 100644 --- a/plumbing/transport/test/upload_pack.go +++ b/internal/transport/test/upload_pack.go @@ -8,17 +8,17 @@ import ( "io" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/packfile" - "github.com/go-git/go-git/v5/plumbing/protocol/packp" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/storage/memory" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/packfile" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/suite" ) type UploadPackSuite struct { + suite.Suite Endpoint *transport.Endpoint EmptyEndpoint *transport.Endpoint NonExistentEndpoint *transport.Endpoint @@ -26,163 +26,163 @@ type UploadPackSuite struct { Client transport.Transport } -func (s *UploadPackSuite) TestAdvertisedReferencesEmpty(c *C) { +func (s *UploadPackSuite) TestAdvertisedReferencesEmpty() { r, err := s.Client.NewUploadPackSession(s.EmptyEndpoint, s.EmptyAuth) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(r.Close()) }() ar, err := r.AdvertisedReferences() - c.Assert(err, Equals, transport.ErrEmptyRemoteRepository) - c.Assert(ar, IsNil) + s.Equal(err, transport.ErrEmptyRemoteRepository) + s.Nil(ar) } -func (s *UploadPackSuite) TestAdvertisedReferencesNotExists(c *C) { +func (s *UploadPackSuite) TestAdvertisedReferencesNotExists() { r, err := s.Client.NewUploadPackSession(s.NonExistentEndpoint, s.EmptyAuth) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(r.Close()) }() ar, err := r.AdvertisedReferences() - c.Assert(err, Equals, transport.ErrRepositoryNotFound) - c.Assert(ar, IsNil) + s.Equal(err, transport.ErrRepositoryNotFound) + s.Nil(ar) r, err = s.Client.NewUploadPackSession(s.NonExistentEndpoint, s.EmptyAuth) - c.Assert(err, IsNil) + s.NoError(err) req := packp.NewUploadPackRequest() req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) reader, err := r.UploadPack(context.Background(), req) - c.Assert(err, Equals, transport.ErrRepositoryNotFound) - c.Assert(reader, IsNil) + s.Equal(err, transport.ErrRepositoryNotFound) + s.Nil(reader) } -func (s *UploadPackSuite) TestCallAdvertisedReferenceTwice(c *C) { +func (s *UploadPackSuite) TestCallAdvertisedReferenceTwice() { r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(r.Close()) }() ar1, err := r.AdvertisedReferences() - c.Assert(err, IsNil) - c.Assert(ar1, NotNil) + s.NoError(err) + s.NotNil(ar1) ar2, err := r.AdvertisedReferences() - c.Assert(err, IsNil) - c.Assert(ar2, DeepEquals, ar1) + s.NoError(err) + s.Equal(ar1, ar2) } -func (s *UploadPackSuite) TestDefaultBranch(c *C) { +func (s *UploadPackSuite) TestDefaultBranch() { r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(r.Close()) }() info, err := r.AdvertisedReferences() - c.Assert(err, IsNil) + s.NoError(err) symrefs := info.Capabilities.Get(capability.SymRef) - c.Assert(symrefs, HasLen, 1) - c.Assert(symrefs[0], Equals, "HEAD:refs/heads/master") + s.Len(symrefs, 1) + s.Equal("HEAD:refs/heads/master", symrefs[0]) } -func (s *UploadPackSuite) TestAdvertisedReferencesFilterUnsupported(c *C) { +func (s *UploadPackSuite) TestAdvertisedReferencesFilterUnsupported() { r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(r.Close()) }() info, err := r.AdvertisedReferences() - c.Assert(err, IsNil) - c.Assert(info.Capabilities.Supports(capability.MultiACK), Equals, false) + s.NoError(err) + s.True(info.Capabilities.Supports(capability.MultiACK)) } -func (s *UploadPackSuite) TestCapabilities(c *C) { +func (s *UploadPackSuite) TestCapabilities() { r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(r.Close()) }() info, err := r.AdvertisedReferences() - c.Assert(err, IsNil) - c.Assert(info.Capabilities.Get(capability.Agent), HasLen, 1) + s.NoError(err) + s.Len(info.Capabilities.Get(capability.Agent), 1) } -func (s *UploadPackSuite) TestUploadPack(c *C) { +func (s *UploadPackSuite) TestUploadPack() { r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(r.Close()) }() req := packp.NewUploadPackRequest() req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) reader, err := r.UploadPack(context.Background(), req) - c.Assert(err, IsNil) + s.NoError(err) - s.checkObjectNumber(c, reader, 28) + s.checkObjectNumber(reader, 28) } -func (s *UploadPackSuite) TestUploadPackWithContext(c *C) { +func (s *UploadPackSuite) TestUploadPackWithContext() { ctx, cancel := context.WithTimeout(context.Background(), 1*time.Millisecond) defer cancel() r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(r.Close()) }() info, err := r.AdvertisedReferences() - c.Assert(err, IsNil) - c.Assert(info, NotNil) + s.NoError(err) + s.NotNil(info) req := packp.NewUploadPackRequest() req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) reader, err := r.UploadPack(ctx, req) - c.Assert(err, NotNil) - c.Assert(reader, IsNil) + s.NotNil(err) + s.Nil(reader) } -func (s *UploadPackSuite) TestUploadPackWithContextOnRead(c *C) { +func (s *UploadPackSuite) TestUploadPackWithContextOnRead() { ctx, cancel := context.WithCancel(context.Background()) r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) + s.NoError(err) info, err := r.AdvertisedReferences() - c.Assert(err, IsNil) - c.Assert(info, NotNil) + s.NoError(err) + s.NotNil(info) req := packp.NewUploadPackRequest() req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) reader, err := r.UploadPack(ctx, req) - c.Assert(err, IsNil) - c.Assert(reader, NotNil) + s.NoError(err) + s.NotNil(reader) cancel() _, err = io.Copy(io.Discard, reader) - c.Assert(err, NotNil) + s.NotNil(err) err = reader.Close() - c.Assert(err, IsNil) + s.NoError(err) err = r.Close() - c.Assert(err, IsNil) + s.NoError(err) } -func (s *UploadPackSuite) TestUploadPackFull(c *C) { +func (s *UploadPackSuite) TestUploadPackFull() { r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(r.Close()) }() info, err := r.AdvertisedReferences() - c.Assert(err, IsNil) - c.Assert(info, NotNil) + s.NoError(err) + s.NotNil(info) req := packp.NewUploadPackRequest() req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) reader, err := r.UploadPack(context.Background(), req) - c.Assert(err, IsNil) + s.NoError(err) - s.checkObjectNumber(c, reader, 28) + s.checkObjectNumber(reader, 28) } -func (s *UploadPackSuite) TestUploadPackInvalidReq(c *C) { +func (s *UploadPackSuite) TestUploadPackInvalidReq() { r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(r.Close()) }() req := packp.NewUploadPackRequest() req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) @@ -190,74 +190,74 @@ func (s *UploadPackSuite) TestUploadPackInvalidReq(c *C) { req.Capabilities.Set(capability.Sideband64k) _, err = r.UploadPack(context.Background(), req) - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *UploadPackSuite) TestUploadPackNoChanges(c *C) { +func (s *UploadPackSuite) TestUploadPackNoChanges() { r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(r.Close()) }() req := packp.NewUploadPackRequest() req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) req.Haves = append(req.Haves, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) reader, err := r.UploadPack(context.Background(), req) - c.Assert(err, Equals, transport.ErrEmptyUploadPackRequest) - c.Assert(reader, IsNil) + s.Equal(err, transport.ErrEmptyUploadPackRequest) + s.Nil(reader) } -func (s *UploadPackSuite) TestUploadPackMulti(c *C) { +func (s *UploadPackSuite) TestUploadPackMulti() { r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(r.Close()) }() req := packp.NewUploadPackRequest() req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) req.Wants = append(req.Wants, plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881")) reader, err := r.UploadPack(context.Background(), req) - c.Assert(err, IsNil) + s.NoError(err) - s.checkObjectNumber(c, reader, 31) + s.checkObjectNumber(reader, 31) } -func (s *UploadPackSuite) TestUploadPackPartial(c *C) { +func (s *UploadPackSuite) TestUploadPackPartial() { r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(r.Close()) }() req := packp.NewUploadPackRequest() req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) req.Haves = append(req.Haves, plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294")) reader, err := r.UploadPack(context.Background(), req) - c.Assert(err, IsNil) + s.NoError(err) - s.checkObjectNumber(c, reader, 4) + s.checkObjectNumber(reader, 4) } -func (s *UploadPackSuite) TestFetchError(c *C) { +func (s *UploadPackSuite) TestFetchError() { r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) + s.NoError(err) req := packp.NewUploadPackRequest() req.Wants = append(req.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) reader, err := r.UploadPack(context.Background(), req) - c.Assert(err, NotNil) - c.Assert(reader, IsNil) + s.NotNil(err) + s.Nil(reader) //XXX: We do not test Close error, since implementations might return // different errors if a previous error was found. } -func (s *UploadPackSuite) checkObjectNumber(c *C, r io.Reader, n int) { +func (s *UploadPackSuite) checkObjectNumber(r io.Reader, n int) { b, err := io.ReadAll(r) - c.Assert(err, IsNil) + s.NoError(err) buf := bytes.NewBuffer(b) storage := memory.NewStorage() err = packfile.UpdateObjectStorage(storage, buf) - c.Assert(err, IsNil) - c.Assert(len(storage.Objects), Equals, n) + s.NoError(err) + s.Len(storage.Objects, n) } diff --git a/internal/url/url_test.go b/internal/url/url_test.go index 29c3f3e96..fc40a0b36 100755 --- a/internal/url/url_test.go +++ b/internal/url/url_test.go @@ -3,16 +3,18 @@ package url import ( "testing" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } - -type URLSuite struct{} +type URLSuite struct { + suite.Suite +} -var _ = Suite(&URLSuite{}) +func TestURLSuite(t *testing.T) { + suite.Run(t, new(URLSuite)) +} -func (s *URLSuite) TestMatchesScpLike(c *C) { +func (s *URLSuite) TestMatchesScpLike() { // See https://github.com/git/git/blob/master/Documentation/urls.txt#L37 examples := []string{ // Most-extended case @@ -37,11 +39,11 @@ func (s *URLSuite) TestMatchesScpLike(c *C) { } for _, url := range examples { - c.Check(MatchesScpLike(url), Equals, true) + s.True(MatchesScpLike(url)) } } -func (s *URLSuite) TestFindScpLikeComponents(c *C) { +func (s *URLSuite) TestFindScpLikeComponents() { testCases := []struct { url, user, host, port, path string }{ @@ -94,16 +96,9 @@ func (s *URLSuite) TestFindScpLikeComponents(c *C) { for _, tc := range testCases { user, host, port, path := FindScpLikeComponents(tc.url) - logf := func(ok bool) { - if ok { - return - } - c.Logf("%q check failed", tc.url) - } - - logf(c.Check(user, Equals, tc.user)) - logf(c.Check(host, Equals, tc.host)) - logf(c.Check(port, Equals, tc.port)) - logf(c.Check(path, Equals, tc.path)) + s.Equal(tc.user, user, tc.url) + s.Equal(tc.host, host, tc.url) + s.Equal(tc.port, port, tc.url) + s.Equal(tc.path, path, tc.url) } } diff --git a/object_walker.go b/object_walker.go index 3a537bd80..2f390267a 100644 --- a/object_walker.go +++ b/object_walker.go @@ -3,10 +3,10 @@ package git import ( "fmt" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/filemode" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/storage" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/storage" ) type objectWalker struct { diff --git a/options.go b/options.go index d7776dad5..a7788339c 100644 --- a/options.go +++ b/options.go @@ -8,31 +8,30 @@ import ( "time" "github.com/ProtonMail/go-crypto/openpgp" - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/plumbing" - formatcfg "github.com/go-git/go-git/v5/plumbing/format/config" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband" - "github.com/go-git/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/plumbing" + formatcfg "github.com/jesseduffield/go-git/v5/plumbing/format/config" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/sideband" + "github.com/jesseduffield/go-git/v5/plumbing/transport" ) -// SubmoduleRescursivity defines how depth will affect any submodule recursive +// SubmoduleRecursivity defines how depth will affect any submodule recursive // operation. -type SubmoduleRescursivity uint +type SubmoduleRecursivity uint const ( // DefaultRemoteName name of the default Remote, just like git command. DefaultRemoteName = "origin" // NoRecurseSubmodules disables the recursion for a submodule operation. - NoRecurseSubmodules SubmoduleRescursivity = 0 + NoRecurseSubmodules SubmoduleRecursivity = 0 // DefaultSubmoduleRecursionDepth allow recursion in a submodule operation. - DefaultSubmoduleRecursionDepth SubmoduleRescursivity = 10 + DefaultSubmoduleRecursionDepth SubmoduleRecursivity = 10 ) -var ( - ErrMissingURL = errors.New("URL field is required") -) +var ErrMissingURL = errors.New("URL field is required") // CloneOptions describes how a clone should be performed. type CloneOptions struct { @@ -61,7 +60,7 @@ type CloneOptions struct { // RecurseSubmodules after the clone is created, initialize all submodules // within, using their default settings. This option is ignored if the // cloned repository does not have a worktree. - RecurseSubmodules SubmoduleRescursivity + RecurseSubmodules SubmoduleRecursivity // ShallowSubmodules limit cloning submodules to the 1 level of depth. // It matches the git command --shallow-submodules. ShallowSubmodules bool @@ -71,7 +70,7 @@ type CloneOptions struct { Progress sideband.Progress // Tags describe how the tags will be fetched from the remote repository, // by default is AllTags. - Tags TagMode + Tags plumbing.TagMode // InsecureSkipTLS skips ssl verify if protocol is https InsecureSkipTLS bool // CABundle specify additional ca bundle with system cert pool @@ -87,6 +86,9 @@ type CloneOptions struct { // // [Reference]: https://git-scm.com/docs/git-clone#Documentation/git-clone.txt---shared Shared bool + // Filter requests that the server to send only a subset of the objects. + // See https://git-scm.com/docs/git-clone#Documentation/git-clone.txt-code--filterltfilter-specgtcode + Filter packp.Filter } // MergeOptions describes how a merge should be performed. @@ -122,8 +124,8 @@ func (o *CloneOptions) Validate() error { o.ReferenceName = plumbing.HEAD } - if o.Tags == InvalidTagMode { - o.Tags = AllTags + if o.Tags == plumbing.InvalidTagMode { + o.Tags = plumbing.AllTags } return nil @@ -145,7 +147,7 @@ type PullOptions struct { Auth transport.AuthMethod // RecurseSubmodules controls if new commits of all populated submodules // should be fetched too. - RecurseSubmodules SubmoduleRescursivity + RecurseSubmodules SubmoduleRecursivity // Progress is where the human readable information sent by the server is // stored, if nil nothing is stored and the capability (if supported) // no-progress, is sent to the server to avoid send this information. @@ -174,19 +176,21 @@ func (o *PullOptions) Validate() error { return nil } -type TagMode int +// TagMode defines how the tags will be fetched from the remote repository. +// TODO: delete for V6 +type TagMode = plumbing.TagMode const ( - InvalidTagMode TagMode = iota + InvalidTagMode = plumbing.InvalidTagMode // TagFollowing any tag that points into the histories being fetched is also // fetched. TagFollowing requires a server with `include-tag` capability // in order to fetch the annotated tags objects. - TagFollowing + TagFollowing = plumbing.TagFollowing // AllTags fetch all tags from the remote (i.e., fetch remote tags // refs/tags/* into local tags with the same name) - AllTags + AllTags = plumbing.AllTags // NoTags fetch no tags from the remote at all - NoTags + NoTags = plumbing.NoTags ) // FetchOptions describes how a fetch should be performed @@ -207,7 +211,7 @@ type FetchOptions struct { Progress sideband.Progress // Tags describe how the tags will be fetched from the remote repository, // by default is TagFollowing. - Tags TagMode + Tags plumbing.TagMode // Force allows the fetch to update a local branch even when the remote // branch does not descend from it. Force bool @@ -220,6 +224,9 @@ type FetchOptions struct { // Prune specify that local refs that match given RefSpecs and that do // not exist remotely will be removed. Prune bool + // Filter requests that the server to send only a subset of the objects. + // See https://git-scm.com/docs/git-clone#Documentation/git-clone.txt-code--filterltfilter-specgtcode + Filter packp.Filter } // Validate validates the fields and sets the default values. @@ -228,8 +235,8 @@ func (o *FetchOptions) Validate() error { o.RemoteName = DefaultRemoteName } - if o.Tags == InvalidTagMode { - o.Tags = TagFollowing + if o.Tags == plumbing.InvalidTagMode { + o.Tags = plumbing.TagFollowing } for _, r := range o.RefSpecs { @@ -330,8 +337,8 @@ type SubmoduleUpdateOptions struct { NoFetch bool // RecurseSubmodules the update is performed not only in the submodules of // the current repository but also in any nested submodules inside those - // submodules (and so on). Until the SubmoduleRescursivity is reached. - RecurseSubmodules SubmoduleRescursivity + // submodules (and so on). Until the SubmoduleRecursivity is reached. + RecurseSubmodules SubmoduleRecursivity // Auth credentials, if required, to use with the remote repository. Auth transport.AuthMethod // Depth limit fetching to the specified number of commits from the tip of @@ -416,6 +423,9 @@ type ResetOptions struct { // the index (resetting it to the tree of Commit) and the working tree // depending on Mode. If empty MixedReset is used. Mode ResetMode + // Files, if not empty will constrain the reseting the index to only files + // specified in this list. + Files []string } // Validate validates the fields and sets the default values. @@ -454,6 +464,10 @@ type LogOptions struct { // the default From. From plumbing.Hash + // When To is set the log will go down until it reaches to the commit with the + // specified hash. The default value for this field in nil + To plumbing.Hash + // The default traversal algorithm is Depth-first search // set Order=LogOrderCommitterTime for ordering by committer time (more compatible with `git log`) // set Order=LogOrderBSF for Breadth-first search @@ -484,9 +498,7 @@ type LogOptions struct { Until *time.Time } -var ( - ErrMissingAuthor = errors.New("author field is required") -) +var ErrMissingAuthor = errors.New("author field is required") // AddOptions describes how an `add` operation should be performed type AddOptions struct { @@ -738,9 +750,7 @@ type GrepOptions struct { PathSpecs []*regexp.Regexp } -var ( - ErrHashOrReference = errors.New("ambiguous options, only one of CommitHash or ReferenceName can be passed") -) +var ErrHashOrReference = errors.New("ambiguous options, only one of CommitHash or ReferenceName can be passed") // Validate validates the fields and sets the default values. // @@ -790,3 +800,24 @@ type PlainInitOptions struct { // Validate validates the fields and sets the default values. func (o *PlainInitOptions) Validate() error { return nil } + +var ErrNoRestorePaths = errors.New("you must specify path(s) to restore") + +// RestoreOptions describes how a restore should be performed. +type RestoreOptions struct { + // Marks to restore the content in the index + Staged bool + // Marks to restore the content of the working tree + Worktree bool + // List of file paths that will be restored + Files []string +} + +// Validate validates the fields and sets the default values. +func (o *RestoreOptions) Validate() error { + if len(o.Files) == 0 { + return ErrNoRestorePaths + } + + return nil +} diff --git a/options_test.go b/options_test.go index 677c31719..fe822ae94 100644 --- a/options_test.go +++ b/options_test.go @@ -2,87 +2,91 @@ package git import ( "os" + "testing" "github.com/go-git/go-billy/v5/util" - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/object" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/stretchr/testify/suite" ) type OptionsSuite struct { + suite.Suite BaseSuite } -var _ = Suite(&OptionsSuite{}) +func TestOptionsSuite(t *testing.T) { + suite.Run(t, new(OptionsSuite)) +} -func (s *OptionsSuite) TestCommitOptionsParentsFromHEAD(c *C) { +func (s *OptionsSuite) TestCommitOptionsParentsFromHEAD() { o := CommitOptions{Author: &object.Signature{}} err := o.Validate(s.Repository) - c.Assert(err, IsNil) - c.Assert(o.Parents, HasLen, 1) + s.NoError(err) + s.Len(o.Parents, 1) } -func (s *OptionsSuite) TestResetOptionsCommitNotFound(c *C) { +func (s *OptionsSuite) TestResetOptionsCommitNotFound() { o := ResetOptions{Commit: plumbing.NewHash("ab1b15c6f6487b4db16f10d8ec69bb8bf91dcabd")} err := o.Validate(s.Repository) - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *OptionsSuite) TestCommitOptionsCommitter(c *C) { +func (s *OptionsSuite) TestCommitOptionsCommitter() { sig := &object.Signature{} o := CommitOptions{Author: sig} err := o.Validate(s.Repository) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(o.Committer, Equals, o.Author) + s.Equal(o.Author, o.Committer) } -func (s *OptionsSuite) TestCommitOptionsLoadGlobalConfigUser(c *C) { +func (s *OptionsSuite) TestCommitOptionsLoadGlobalConfigUser() { cfg := config.NewConfig() cfg.User.Name = "foo" cfg.User.Email = "foo@foo.com" - clean := s.writeGlobalConfig(c, cfg) + clean := s.writeGlobalConfig(cfg) defer clean() o := CommitOptions{} err := o.Validate(s.Repository) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(o.Author.Name, Equals, "foo") - c.Assert(o.Author.Email, Equals, "foo@foo.com") - c.Assert(o.Committer.Name, Equals, "foo") - c.Assert(o.Committer.Email, Equals, "foo@foo.com") + s.Equal("foo", o.Author.Name) + s.Equal("foo@foo.com", o.Author.Email) + s.Equal("foo", o.Committer.Name) + s.Equal("foo@foo.com", o.Committer.Email) } -func (s *OptionsSuite) TestCommitOptionsLoadGlobalCommitter(c *C) { +func (s *OptionsSuite) TestCommitOptionsLoadGlobalCommitter() { cfg := config.NewConfig() cfg.User.Name = "foo" cfg.User.Email = "foo@foo.com" cfg.Committer.Name = "bar" cfg.Committer.Email = "bar@bar.com" - clean := s.writeGlobalConfig(c, cfg) + clean := s.writeGlobalConfig(cfg) defer clean() o := CommitOptions{} err := o.Validate(s.Repository) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(o.Author.Name, Equals, "foo") - c.Assert(o.Author.Email, Equals, "foo@foo.com") - c.Assert(o.Committer.Name, Equals, "bar") - c.Assert(o.Committer.Email, Equals, "bar@bar.com") + s.Equal("foo", o.Author.Name) + s.Equal("foo@foo.com", o.Author.Email) + s.Equal("bar", o.Committer.Name) + s.Equal("bar@bar.com", o.Committer.Email) } -func (s *OptionsSuite) TestCreateTagOptionsLoadGlobal(c *C) { +func (s *OptionsSuite) TestCreateTagOptionsLoadGlobal() { cfg := config.NewConfig() cfg.User.Name = "foo" cfg.User.Email = "foo@foo.com" - clean := s.writeGlobalConfig(c, cfg) + clean := s.writeGlobalConfig(cfg) defer clean() o := CreateTagOptions{ @@ -90,32 +94,31 @@ func (s *OptionsSuite) TestCreateTagOptionsLoadGlobal(c *C) { } err := o.Validate(s.Repository, plumbing.ZeroHash) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(o.Tagger.Name, Equals, "foo") - c.Assert(o.Tagger.Email, Equals, "foo@foo.com") + s.Equal("foo", o.Tagger.Name) + s.Equal("foo@foo.com", o.Tagger.Email) } -func (s *OptionsSuite) writeGlobalConfig(c *C, cfg *config.Config) func() { - fs, clean := s.TemporalFilesystem() +func (s *OptionsSuite) writeGlobalConfig(cfg *config.Config) func() { + fs := s.TemporalFilesystem() tmp, err := util.TempDir(fs, "", "test-options") - c.Assert(err, IsNil) + s.NoError(err) err = fs.MkdirAll(fs.Join(tmp, "git"), 0777) - c.Assert(err, IsNil) + s.NoError(err) os.Setenv("XDG_CONFIG_HOME", fs.Join(fs.Root(), tmp)) content, err := cfg.Marshal() - c.Assert(err, IsNil) + s.NoError(err) cfgFile := fs.Join(tmp, "git/config") err = util.WriteFile(fs, cfgFile, content, 0777) - c.Assert(err, IsNil) + s.NoError(err) return func() { - clean() os.Setenv("XDG_CONFIG_HOME", "") } diff --git a/oss-fuzz.sh b/oss-fuzz.sh deleted file mode 100644 index 885548f40..000000000 --- a/oss-fuzz.sh +++ /dev/null @@ -1,35 +0,0 @@ -#!/bin/bash -eu -# Copyright 2023 Google LLC -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -################################################################################ - - -go mod download -go get github.com/AdamKorcz/go-118-fuzz-build/testing - -if [ "$SANITIZER" != "coverage" ]; then - sed -i '/func (s \*DecoderSuite) TestDecode(/,/^}/ s/^/\/\//' plumbing/format/config/decoder_test.go - sed -n '35,$p' plumbing/format/packfile/common_test.go >> plumbing/format/packfile/delta_test.go - sed -n '20,53p' plumbing/object/object_test.go >> plumbing/object/tree_test.go - sed -i 's|func Test|// func Test|' plumbing/transport/common_test.go -fi - -compile_native_go_fuzzer $(pwd)/internal/revision FuzzParser fuzz_parser -compile_native_go_fuzzer $(pwd)/plumbing/format/config FuzzDecoder fuzz_decoder_config -compile_native_go_fuzzer $(pwd)/plumbing/format/packfile FuzzPatchDelta fuzz_patch_delta -compile_native_go_fuzzer $(pwd)/plumbing/object FuzzParseSignedBytes fuzz_parse_signed_bytes -compile_native_go_fuzzer $(pwd)/plumbing/object FuzzDecode fuzz_decode -compile_native_go_fuzzer $(pwd)/plumbing/protocol/packp FuzzDecoder fuzz_decoder_packp -compile_native_go_fuzzer $(pwd)/plumbing/transport FuzzNewEndpoint fuzz_new_endpoint diff --git a/plumbing/cache/buffer_test.go b/plumbing/cache/buffer_test.go index 3e3adc25e..5509e5d05 100644 --- a/plumbing/cache/buffer_test.go +++ b/plumbing/cache/buffer_test.go @@ -3,11 +3,13 @@ package cache import ( "bytes" "sync" + "testing" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) type BufferSuite struct { + suite.Suite c map[string]Buffer aBuffer []byte bBuffer []byte @@ -16,9 +18,11 @@ type BufferSuite struct { eBuffer []byte } -var _ = Suite(&BufferSuite{}) +func TestBufferSuite(t *testing.T) { + suite.Run(t, new(BufferSuite)) +} -func (s *BufferSuite) SetUpTest(c *C) { +func (s *BufferSuite) SetupTest() { s.aBuffer = []byte("a") s.bBuffer = []byte("bbb") s.cBuffer = []byte("c") @@ -30,16 +34,16 @@ func (s *BufferSuite) SetUpTest(c *C) { s.c["default_lru"] = NewBufferLRUDefault() } -func (s *BufferSuite) TestPutSameBuffer(c *C) { +func (s *BufferSuite) TestPutSameBuffer() { for _, o := range s.c { o.Put(1, s.aBuffer) o.Put(1, s.aBuffer) _, ok := o.Get(1) - c.Assert(ok, Equals, true) + s.True(ok) } } -func (s *ObjectSuite) TestPutSameBufferWithDifferentSize(c *C) { +func (s *ObjectSuite) TestPutSameBufferWithDifferentSize() { aBuffer := []byte("a") bBuffer := []byte("bbb") cBuffer := []byte("ccccc") @@ -51,25 +55,25 @@ func (s *ObjectSuite) TestPutSameBufferWithDifferentSize(c *C) { cache.Put(1, cBuffer) cache.Put(1, dBuffer) - c.Assert(cache.MaxSize, Equals, 7*Byte) - c.Assert(cache.actualSize, Equals, 7*Byte) - c.Assert(cache.ll.Len(), Equals, 1) + s.Equal(7*Byte, cache.MaxSize) + s.Equal(7*Byte, cache.actualSize) + s.Equal(1, cache.ll.Len()) buf, ok := cache.Get(1) - c.Assert(bytes.Equal(buf, dBuffer), Equals, true) - c.Assert(FileSize(len(buf)), Equals, 7*Byte) - c.Assert(ok, Equals, true) + s.True(bytes.Equal(buf, dBuffer)) + s.Equal(7*Byte, FileSize(len(buf))) + s.True(ok) } -func (s *BufferSuite) TestPutBigBuffer(c *C) { +func (s *BufferSuite) TestPutBigBuffer() { for _, o := range s.c { o.Put(1, s.bBuffer) _, ok := o.Get(2) - c.Assert(ok, Equals, false) + s.False(ok) } } -func (s *BufferSuite) TestPutCacheOverflow(c *C) { +func (s *BufferSuite) TestPutCacheOverflow() { // this test only works with an specific size o := s.c["two_bytes"] @@ -78,17 +82,17 @@ func (s *BufferSuite) TestPutCacheOverflow(c *C) { o.Put(3, s.dBuffer) obj, ok := o.Get(1) - c.Assert(ok, Equals, false) - c.Assert(obj, IsNil) + s.False(ok) + s.Nil(obj) obj, ok = o.Get(2) - c.Assert(ok, Equals, true) - c.Assert(obj, NotNil) + s.True(ok) + s.NotNil(obj) obj, ok = o.Get(3) - c.Assert(ok, Equals, true) - c.Assert(obj, NotNil) + s.True(ok) + s.NotNil(obj) } -func (s *BufferSuite) TestEvictMultipleBuffers(c *C) { +func (s *BufferSuite) TestEvictMultipleBuffers() { o := s.c["two_bytes"] o.Put(1, s.cBuffer) @@ -96,27 +100,27 @@ func (s *BufferSuite) TestEvictMultipleBuffers(c *C) { o.Put(3, s.eBuffer) // this put should evict all previous objects obj, ok := o.Get(1) - c.Assert(ok, Equals, false) - c.Assert(obj, IsNil) + s.False(ok) + s.Nil(obj) obj, ok = o.Get(2) - c.Assert(ok, Equals, false) - c.Assert(obj, IsNil) + s.False(ok) + s.Nil(obj) obj, ok = o.Get(3) - c.Assert(ok, Equals, true) - c.Assert(obj, NotNil) + s.True(ok) + s.NotNil(obj) } -func (s *BufferSuite) TestClear(c *C) { +func (s *BufferSuite) TestClear() { for _, o := range s.c { o.Put(1, s.aBuffer) o.Clear() obj, ok := o.Get(1) - c.Assert(ok, Equals, false) - c.Assert(obj, IsNil) + s.False(ok) + s.Nil(obj) } } -func (s *BufferSuite) TestConcurrentAccess(c *C) { +func (s *BufferSuite) TestConcurrentAccess() { for _, o := range s.c { var wg sync.WaitGroup @@ -144,8 +148,8 @@ func (s *BufferSuite) TestConcurrentAccess(c *C) { } } -func (s *BufferSuite) TestDefaultLRU(c *C) { +func (s *BufferSuite) TestDefaultLRU() { defaultLRU := s.c["default_lru"].(*BufferLRU) - c.Assert(defaultLRU.MaxSize, Equals, DefaultMaxSize) + s.Equal(DefaultMaxSize, defaultLRU.MaxSize) } diff --git a/plumbing/cache/common.go b/plumbing/cache/common.go index 7b0d0c76b..7856df3d3 100644 --- a/plumbing/cache/common.go +++ b/plumbing/cache/common.go @@ -1,6 +1,6 @@ package cache -import "github.com/go-git/go-git/v5/plumbing" +import "github.com/jesseduffield/go-git/v5/plumbing" const ( Byte FileSize = 1 << (iota * 10) diff --git a/plumbing/cache/object_lru.go b/plumbing/cache/object_lru.go index c50d0d1e6..75b2b72b0 100644 --- a/plumbing/cache/object_lru.go +++ b/plumbing/cache/object_lru.go @@ -4,7 +4,7 @@ import ( "container/list" "sync" - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" ) // ObjectLRU implements an object cache with an LRU eviction policy and a diff --git a/plumbing/cache/object_test.go b/plumbing/cache/object_test.go index d3a217cd5..cf3aa4922 100644 --- a/plumbing/cache/object_test.go +++ b/plumbing/cache/object_test.go @@ -6,14 +6,12 @@ import ( "sync" "testing" - "github.com/go-git/go-git/v5/plumbing" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } - type ObjectSuite struct { + suite.Suite c map[string]Object aObject plumbing.EncodedObject bObject plumbing.EncodedObject @@ -22,9 +20,11 @@ type ObjectSuite struct { eObject plumbing.EncodedObject } -var _ = Suite(&ObjectSuite{}) +func TestObjectSuite(t *testing.T) { + suite.Run(t, new(ObjectSuite)) +} -func (s *ObjectSuite) SetUpTest(c *C) { +func (s *ObjectSuite) SetupTest() { s.aObject = newObject("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 1*Byte) s.bObject = newObject("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", 3*Byte) s.cObject = newObject("cccccccccccccccccccccccccccccccccccccccc", 1*Byte) @@ -36,16 +36,16 @@ func (s *ObjectSuite) SetUpTest(c *C) { s.c["default_lru"] = NewObjectLRUDefault() } -func (s *ObjectSuite) TestPutSameObject(c *C) { +func (s *ObjectSuite) TestPutSameObject() { for _, o := range s.c { o.Put(s.aObject) o.Put(s.aObject) _, ok := o.Get(s.aObject.Hash()) - c.Assert(ok, Equals, true) + s.True(ok) } } -func (s *ObjectSuite) TestPutSameObjectWithDifferentSize(c *C) { +func (s *ObjectSuite) TestPutSameObjectWithDifferentSize() { const hash = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" cache := NewObjectLRU(7 * Byte) @@ -54,25 +54,25 @@ func (s *ObjectSuite) TestPutSameObjectWithDifferentSize(c *C) { cache.Put(newObject(hash, 5*Byte)) cache.Put(newObject(hash, 7*Byte)) - c.Assert(cache.MaxSize, Equals, 7*Byte) - c.Assert(cache.actualSize, Equals, 7*Byte) - c.Assert(cache.ll.Len(), Equals, 1) + s.Equal(7*Byte, cache.MaxSize) + s.Equal(7*Byte, cache.actualSize) + s.Equal(1, cache.ll.Len()) obj, ok := cache.Get(plumbing.NewHash(hash)) - c.Assert(obj.Hash(), Equals, plumbing.NewHash(hash)) - c.Assert(FileSize(obj.Size()), Equals, 7*Byte) - c.Assert(ok, Equals, true) + s.Equal(plumbing.NewHash(hash), obj.Hash()) + s.Equal(7*Byte, FileSize(obj.Size())) + s.True(ok) } -func (s *ObjectSuite) TestPutBigObject(c *C) { +func (s *ObjectSuite) TestPutBigObject() { for _, o := range s.c { o.Put(s.bObject) _, ok := o.Get(s.aObject.Hash()) - c.Assert(ok, Equals, false) + s.False(ok) } } -func (s *ObjectSuite) TestPutCacheOverflow(c *C) { +func (s *ObjectSuite) TestPutCacheOverflow() { // this test only works with an specific size o := s.c["two_bytes"] @@ -81,17 +81,17 @@ func (s *ObjectSuite) TestPutCacheOverflow(c *C) { o.Put(s.dObject) obj, ok := o.Get(s.aObject.Hash()) - c.Assert(ok, Equals, false) - c.Assert(obj, IsNil) + s.False(ok) + s.Nil(obj) obj, ok = o.Get(s.cObject.Hash()) - c.Assert(ok, Equals, true) - c.Assert(obj, NotNil) + s.True(ok) + s.NotNil(obj) obj, ok = o.Get(s.dObject.Hash()) - c.Assert(ok, Equals, true) - c.Assert(obj, NotNil) + s.True(ok) + s.NotNil(obj) } -func (s *ObjectSuite) TestEvictMultipleObjects(c *C) { +func (s *ObjectSuite) TestEvictMultipleObjects() { o := s.c["two_bytes"] o.Put(s.cObject) @@ -99,27 +99,27 @@ func (s *ObjectSuite) TestEvictMultipleObjects(c *C) { o.Put(s.eObject) // this put should evict all previous objects obj, ok := o.Get(s.cObject.Hash()) - c.Assert(ok, Equals, false) - c.Assert(obj, IsNil) + s.False(ok) + s.Nil(obj) obj, ok = o.Get(s.dObject.Hash()) - c.Assert(ok, Equals, false) - c.Assert(obj, IsNil) + s.False(ok) + s.Nil(obj) obj, ok = o.Get(s.eObject.Hash()) - c.Assert(ok, Equals, true) - c.Assert(obj, NotNil) + s.True(ok) + s.NotNil(obj) } -func (s *ObjectSuite) TestClear(c *C) { +func (s *ObjectSuite) TestClear() { for _, o := range s.c { o.Put(s.aObject) o.Clear() obj, ok := o.Get(s.aObject.Hash()) - c.Assert(ok, Equals, false) - c.Assert(obj, IsNil) + s.False(ok) + s.Nil(obj) } } -func (s *ObjectSuite) TestConcurrentAccess(c *C) { +func (s *ObjectSuite) TestConcurrentAccess() { for _, o := range s.c { var wg sync.WaitGroup @@ -147,13 +147,13 @@ func (s *ObjectSuite) TestConcurrentAccess(c *C) { } } -func (s *ObjectSuite) TestDefaultLRU(c *C) { +func (s *ObjectSuite) TestDefaultLRU() { defaultLRU := s.c["default_lru"].(*ObjectLRU) - c.Assert(defaultLRU.MaxSize, Equals, DefaultMaxSize) + s.Equal(DefaultMaxSize, defaultLRU.MaxSize) } -func (s *ObjectSuite) TestObjectUpdateOverflow(c *C) { +func (s *ObjectSuite) TestObjectUpdateOverflow() { o := NewObjectLRU(9 * Byte) a1 := newObject(s.aObject.Hash().String(), 9*Byte) diff --git a/plumbing/filemode/filemode_test.go b/plumbing/filemode/filemode_test.go index 8d713f6f0..a53276836 100644 --- a/plumbing/filemode/filemode_test.go +++ b/plumbing/filemode/filemode_test.go @@ -1,19 +1,22 @@ package filemode import ( + "fmt" "os" "testing" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } - -type ModeSuite struct{} +type ModeSuite struct { + suite.Suite +} -var _ = Suite(&ModeSuite{}) +func TestModeSuite(t *testing.T) { + suite.Run(t, new(ModeSuite)) +} -func (s *ModeSuite) TestNew(c *C) { +func (s *ModeSuite) TestNew() { for _, test := range [...]struct { input string expected FileMode @@ -37,14 +40,14 @@ func (s *ModeSuite) TestNew(c *C) { {input: "42", expected: FileMode(042)}, {input: "00000000000100644", expected: Regular}, } { - comment := Commentf("input = %q", test.input) + comment := fmt.Sprintf("input = %q", test.input) obtained, err := New(test.input) - c.Assert(obtained, Equals, test.expected, comment) - c.Assert(err, IsNil, comment) + s.Equal(test.expected, obtained, comment) + s.NoError(err, comment) } } -func (s *ModeSuite) TestNewErrors(c *C) { +func (s *ModeSuite) TestNewErrors() { for _, input := range [...]string{ "0x81a4", // Regular in hex "-rw-r--r--", // Regular in default UNIX representation @@ -56,10 +59,10 @@ func (s *ModeSuite) TestNewErrors(c *C) { "-100644", "+100644", } { - comment := Commentf("input = %q", input) + comment := fmt.Sprintf("input = %q", input) obtained, err := New(input) - c.Assert(obtained, Equals, Empty, comment) - c.Assert(err, Not(IsNil), comment) + s.Equal(Empty, obtained, comment) + s.NotNil(err, comment) } } @@ -70,18 +73,18 @@ type fixture struct { err string // error regexp, empty string for nil error } -func (f fixture) test(c *C) { +func (f fixture) test(s *ModeSuite) { obtained, err := NewFromOSFileMode(f.input) - comment := Commentf("input = %s (%07o)", f.input, uint32(f.input)) - c.Assert(obtained, Equals, f.expected, comment) + comment := fmt.Sprintf("input = %s (%07o)", f.input, uint32(f.input)) + s.Equal(f.expected, obtained, comment) if f.err != "" { - c.Assert(err, ErrorMatches, f.err, comment) + s.ErrorContains(err, f.err, comment) } else { - c.Assert(err, IsNil, comment) + s.NoError(err, comment) } } -func (s *ModeSuite) TestNewFromOsFileModeSimplePerms(c *C) { +func (s *ModeSuite) TestNewFromOsFileModeSimplePerms() { for _, f := range [...]fixture{ {os.FileMode(0755) | os.ModeDir, Dir, ""}, // drwxr-xr-x {os.FileMode(0700) | os.ModeDir, Dir, ""}, // drwx------ @@ -100,106 +103,106 @@ func (s *ModeSuite) TestNewFromOsFileModeSimplePerms(c *C) { {os.FileMode(0550), Executable, ""}, // -r-xr-x--- {os.FileMode(0777) | os.ModeSymlink, Symlink, ""}, // Lrwxrwxrwx } { - f.test(c) + f.test(s) } } -func (s *ModeSuite) TestNewFromOsFileModeAppend(c *C) { +func (s *ModeSuite) TestNewFromOsFileModeAppend() { // append files are just regular files fixture{ input: os.FileMode(0644) | os.ModeAppend, // arw-r--r-- expected: Regular, err: "", - }.test(c) + }.test(s) } -func (s *ModeSuite) TestNewFromOsFileModeExclusive(c *C) { +func (s *ModeSuite) TestNewFromOsFileModeExclusive() { // exclusive files are just regular or executable files fixture{ input: os.FileMode(0644) | os.ModeExclusive, // lrw-r--r-- expected: Regular, err: "", - }.test(c) + }.test(s) fixture{ input: os.FileMode(0755) | os.ModeExclusive, // lrwxr-xr-x expected: Executable, err: "", - }.test(c) + }.test(s) } -func (s *ModeSuite) TestNewFromOsFileModeTemporary(c *C) { +func (s *ModeSuite) TestNewFromOsFileModeTemporary() { // temporary files are ignored fixture{ input: os.FileMode(0644) | os.ModeTemporary, // Trw-r--r-- - expected: Empty, err: "no equivalent.*", - }.test(c) + expected: Empty, err: "no equivalent", + }.test(s) fixture{ input: os.FileMode(0755) | os.ModeTemporary, // Trwxr-xr-x - expected: Empty, err: "no equivalent.*", - }.test(c) + expected: Empty, err: "no equivalent", + }.test(s) } -func (s *ModeSuite) TestNewFromOsFileModeDevice(c *C) { +func (s *ModeSuite) TestNewFromOsFileModeDevice() { // device files has no git equivalent fixture{ input: os.FileMode(0644) | os.ModeDevice, // Drw-r--r-- - expected: Empty, err: "no equivalent.*", - }.test(c) + expected: Empty, err: "no equivalent", + }.test(s) } -func (s *ModeSuite) TestNewFromOsFileNamedPipe(c *C) { +func (s *ModeSuite) TestNewFromOsFileNamedPipe() { // named pipes files has not git equivalent fixture{ input: os.FileMode(0644) | os.ModeNamedPipe, // prw-r--r-- - expected: Empty, err: "no equivalent.*", - }.test(c) + expected: Empty, err: "no equivalent", + }.test(s) } -func (s *ModeSuite) TestNewFromOsFileModeSocket(c *C) { +func (s *ModeSuite) TestNewFromOsFileModeSocket() { // sockets has no git equivalent fixture{ input: os.FileMode(0644) | os.ModeSocket, // Srw-r--r-- - expected: Empty, err: "no equivalent.*", - }.test(c) + expected: Empty, err: "no equivalent", + }.test(s) } -func (s *ModeSuite) TestNewFromOsFileModeSetuid(c *C) { +func (s *ModeSuite) TestNewFromOsFileModeSetuid() { // Setuid are just executables fixture{ input: os.FileMode(0755) | os.ModeSetuid, // urwxr-xr-x expected: Executable, err: "", - }.test(c) + }.test(s) } -func (s *ModeSuite) TestNewFromOsFileModeSetgid(c *C) { +func (s *ModeSuite) TestNewFromOsFileModeSetgid() { // Setguid are regular or executables, depending on the owner perms fixture{ input: os.FileMode(0644) | os.ModeSetgid, // grw-r--r-- expected: Regular, err: "", - }.test(c) + }.test(s) fixture{ input: os.FileMode(0755) | os.ModeSetgid, // grwxr-xr-x expected: Executable, err: "", - }.test(c) + }.test(s) } -func (s *ModeSuite) TestNewFromOsFileModeCharDevice(c *C) { +func (s *ModeSuite) TestNewFromOsFileModeCharDevice() { // char devices has no git equivalent fixture{ input: os.FileMode(0644) | os.ModeCharDevice, // crw-r--r-- - expected: Empty, err: "no equivalent.*", - }.test(c) + expected: Empty, err: "no equivalent", + }.test(s) } -func (s *ModeSuite) TestNewFromOsFileModeSticky(c *C) { +func (s *ModeSuite) TestNewFromOsFileModeSticky() { // dirs with the sticky bit are just dirs fixture{ input: os.FileMode(0755) | os.ModeDir | os.ModeSticky, // dtrwxr-xr-x expected: Dir, err: "", - }.test(c) + }.test(s) } -func (s *ModeSuite) TestByte(c *C) { +func (s *ModeSuite) TestByte() { for _, test := range [...]struct { input FileMode expected []byte @@ -218,12 +221,12 @@ func (s *ModeSuite) TestByte(c *C) { {Symlink, []byte{0x00, 0xa0, 0x00, 0x00}}, {Submodule, []byte{0x00, 0xe0, 0x00, 0x00}}, } { - c.Assert(test.input.Bytes(), DeepEquals, test.expected, - Commentf("input = %s", test.input)) + s.Equal(test.expected, test.input.Bytes(), + fmt.Sprintf("input = %s", test.input)) } } -func (s *ModeSuite) TestIsMalformed(c *C) { +func (s *ModeSuite) TestIsMalformed() { for _, test := range [...]struct { mode FileMode expected bool @@ -242,11 +245,11 @@ func (s *ModeSuite) TestIsMalformed(c *C) { {FileMode(010000), true}, {FileMode(0100000), true}, } { - c.Assert(test.mode.IsMalformed(), Equals, test.expected) + s.Equal(test.expected, test.mode.IsMalformed()) } } -func (s *ModeSuite) TestString(c *C) { +func (s *ModeSuite) TestString() { for _, test := range [...]struct { mode FileMode expected string @@ -265,11 +268,11 @@ func (s *ModeSuite) TestString(c *C) { {FileMode(010000), "0010000"}, {FileMode(0100000), "0100000"}, } { - c.Assert(test.mode.String(), Equals, test.expected) + s.Equal(test.expected, test.mode.String()) } } -func (s *ModeSuite) TestIsRegular(c *C) { +func (s *ModeSuite) TestIsRegular() { for _, test := range [...]struct { mode FileMode expected bool @@ -288,11 +291,11 @@ func (s *ModeSuite) TestIsRegular(c *C) { {FileMode(010000), false}, {FileMode(0100000), false}, } { - c.Assert(test.mode.IsRegular(), Equals, test.expected) + s.Equal(test.expected, test.mode.IsRegular()) } } -func (s *ModeSuite) TestIsFile(c *C) { +func (s *ModeSuite) TestIsFile() { for _, test := range [...]struct { mode FileMode expected bool @@ -311,38 +314,38 @@ func (s *ModeSuite) TestIsFile(c *C) { {FileMode(010000), false}, {FileMode(0100000), false}, } { - c.Assert(test.mode.IsFile(), Equals, test.expected) + s.Equal(test.expected, test.mode.IsFile()) } } -func (s *ModeSuite) TestToOSFileMode(c *C) { +func (s *ModeSuite) TestToOSFileMode() { for _, test := range [...]struct { input FileMode expected os.FileMode errRegExp string // empty string for nil error }{ - {Empty, os.FileMode(0), "malformed.*"}, + {Empty, os.FileMode(0), "malformed"}, {Dir, os.ModePerm | os.ModeDir, ""}, {Regular, os.FileMode(0644), ""}, {Deprecated, os.FileMode(0644), ""}, {Executable, os.FileMode(0755), ""}, {Symlink, os.ModePerm | os.ModeSymlink, ""}, {Submodule, os.ModePerm | os.ModeDir, ""}, - {FileMode(01), os.FileMode(0), "malformed.*"}, - {FileMode(010), os.FileMode(0), "malformed.*"}, - {FileMode(0100), os.FileMode(0), "malformed.*"}, - {FileMode(01000), os.FileMode(0), "malformed.*"}, - {FileMode(010000), os.FileMode(0), "malformed.*"}, - {FileMode(0100000), os.FileMode(0), "malformed.*"}, + {FileMode(01), os.FileMode(0), "malformed"}, + {FileMode(010), os.FileMode(0), "malformed"}, + {FileMode(0100), os.FileMode(0), "malformed"}, + {FileMode(01000), os.FileMode(0), "malformed"}, + {FileMode(010000), os.FileMode(0), "malformed"}, + {FileMode(0100000), os.FileMode(0), "malformed"}, } { obtained, err := test.input.ToOSFileMode() - comment := Commentf("input = %s", test.input) + comment := fmt.Sprintf("input = %s", test.input) if test.errRegExp != "" { - c.Assert(obtained, Equals, os.FileMode(0), comment) - c.Assert(err, ErrorMatches, test.errRegExp, comment) + s.Equal(os.FileMode(0), obtained, comment) + s.ErrorContains(err, test.errRegExp, comment) } else { - c.Assert(obtained, Equals, test.expected, comment) - c.Assert(err, IsNil, comment) + s.Equal(test.expected, obtained, comment) + s.NoError(err, comment) } } } diff --git a/plumbing/format/commitgraph/commitgraph.go b/plumbing/format/commitgraph/commitgraph.go index e772d2636..632360b0e 100644 --- a/plumbing/format/commitgraph/commitgraph.go +++ b/plumbing/format/commitgraph/commitgraph.go @@ -3,7 +3,7 @@ package commitgraph import ( "time" - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" ) // CommitData is a reduced representation of Commit as presented in the commit graph diff --git a/plumbing/format/commitgraph/commitgraph_test.go b/plumbing/format/commitgraph/commitgraph_test.go index 4540ae371..8f6749f78 100644 --- a/plumbing/format/commitgraph/commitgraph_test.go +++ b/plumbing/format/commitgraph/commitgraph_test.go @@ -6,130 +6,135 @@ import ( "github.com/go-git/go-billy/v5" "github.com/go-git/go-billy/v5/util" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/commitgraph" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/commitgraph" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) -func Test(t *testing.T) { TestingT(t) } +type CommitgraphFixtureSuite struct { + fixtures.Suite +} type CommitgraphSuite struct { - fixtures.Suite + suite.Suite + CommitgraphFixtureSuite } -var _ = Suite(&CommitgraphSuite{}) +func TestCommitgraphSuite(t *testing.T) { + suite.Run(t, new(CommitgraphSuite)) +} -func testDecodeHelper(c *C, fs billy.Filesystem, path string) { +func testDecodeHelper(s *CommitgraphSuite, fs billy.Filesystem, path string) { reader, err := fs.Open(path) - c.Assert(err, IsNil) + s.NoError(err) defer reader.Close() index, err := commitgraph.OpenFileIndex(reader) - c.Assert(err, IsNil) + s.NoError(err) // Root commit nodeIndex, err := index.GetIndexByHash(plumbing.NewHash("347c91919944a68e9413581a1bc15519550a3afe")) - c.Assert(err, IsNil) + s.NoError(err) commitData, err := index.GetCommitDataByIndex(nodeIndex) - c.Assert(err, IsNil) - c.Assert(len(commitData.ParentIndexes), Equals, 0) - c.Assert(len(commitData.ParentHashes), Equals, 0) + s.NoError(err) + s.Len(commitData.ParentIndexes, 0) + s.Len(commitData.ParentHashes, 0) // Regular commit nodeIndex, err = index.GetIndexByHash(plumbing.NewHash("e713b52d7e13807e87a002e812041f248db3f643")) - c.Assert(err, IsNil) + s.NoError(err) commitData, err = index.GetCommitDataByIndex(nodeIndex) - c.Assert(err, IsNil) - c.Assert(len(commitData.ParentIndexes), Equals, 1) - c.Assert(len(commitData.ParentHashes), Equals, 1) - c.Assert(commitData.ParentHashes[0].String(), Equals, "347c91919944a68e9413581a1bc15519550a3afe") + s.NoError(err) + s.Len(commitData.ParentIndexes, 1) + s.Len(commitData.ParentHashes, 1) + s.Equal("347c91919944a68e9413581a1bc15519550a3afe", commitData.ParentHashes[0].String()) // Merge commit nodeIndex, err = index.GetIndexByHash(plumbing.NewHash("b29328491a0682c259bcce28741eac71f3499f7d")) - c.Assert(err, IsNil) + s.NoError(err) commitData, err = index.GetCommitDataByIndex(nodeIndex) - c.Assert(err, IsNil) - c.Assert(len(commitData.ParentIndexes), Equals, 2) - c.Assert(len(commitData.ParentHashes), Equals, 2) - c.Assert(commitData.ParentHashes[0].String(), Equals, "e713b52d7e13807e87a002e812041f248db3f643") - c.Assert(commitData.ParentHashes[1].String(), Equals, "03d2c021ff68954cf3ef0a36825e194a4b98f981") + s.NoError(err) + s.Len(commitData.ParentIndexes, 2) + s.Len(commitData.ParentHashes, 2) + s.Equal("e713b52d7e13807e87a002e812041f248db3f643", commitData.ParentHashes[0].String()) + s.Equal("03d2c021ff68954cf3ef0a36825e194a4b98f981", commitData.ParentHashes[1].String()) // Octopus merge commit nodeIndex, err = index.GetIndexByHash(plumbing.NewHash("6f6c5d2be7852c782be1dd13e36496dd7ad39560")) - c.Assert(err, IsNil) + s.NoError(err) commitData, err = index.GetCommitDataByIndex(nodeIndex) - c.Assert(err, IsNil) - c.Assert(len(commitData.ParentIndexes), Equals, 3) - c.Assert(len(commitData.ParentHashes), Equals, 3) - c.Assert(commitData.ParentHashes[0].String(), Equals, "ce275064ad67d51e99f026084e20827901a8361c") - c.Assert(commitData.ParentHashes[1].String(), Equals, "bb13916df33ed23004c3ce9ed3b8487528e655c1") - c.Assert(commitData.ParentHashes[2].String(), Equals, "a45273fe2d63300e1962a9e26a6b15c276cd7082") + s.NoError(err) + s.Len(commitData.ParentIndexes, 3) + s.Len(commitData.ParentHashes, 3) + s.Equal("ce275064ad67d51e99f026084e20827901a8361c", commitData.ParentHashes[0].String()) + s.Equal("bb13916df33ed23004c3ce9ed3b8487528e655c1", commitData.ParentHashes[1].String()) + s.Equal("a45273fe2d63300e1962a9e26a6b15c276cd7082", commitData.ParentHashes[2].String()) // Check all hashes hashes := index.Hashes() - c.Assert(len(hashes), Equals, 11) - c.Assert(hashes[0].String(), Equals, "03d2c021ff68954cf3ef0a36825e194a4b98f981") - c.Assert(hashes[10].String(), Equals, "e713b52d7e13807e87a002e812041f248db3f643") + s.Len(hashes, 11) + s.Equal("03d2c021ff68954cf3ef0a36825e194a4b98f981", hashes[0].String()) + s.Equal("e713b52d7e13807e87a002e812041f248db3f643", hashes[10].String()) } -func (s *CommitgraphSuite) TestDecode(c *C) { - fixtures.ByTag("commit-graph").Test(c, func(f *fixtures.Fixture) { +func (s *CommitgraphSuite) TestDecode() { + for _, f := range fixtures.ByTag("commit-graph") { dotgit := f.DotGit() - testDecodeHelper(c, dotgit, dotgit.Join("objects", "info", "commit-graph")) - }) + testDecodeHelper(s, dotgit, dotgit.Join("objects", "info", "commit-graph")) + } } -func (s *CommitgraphSuite) TestReencode(c *C) { - fixtures.ByTag("commit-graph").Test(c, func(f *fixtures.Fixture) { +func (s *CommitgraphSuite) TestReencode() { + for _, f := range fixtures.ByTag("commit-graph") { dotgit := f.DotGit() reader, err := dotgit.Open(dotgit.Join("objects", "info", "commit-graph")) - c.Assert(err, IsNil) + s.NoError(err) defer reader.Close() index, err := commitgraph.OpenFileIndex(reader) - c.Assert(err, IsNil) + s.NoError(err) writer, err := util.TempFile(dotgit, "", "commit-graph") - c.Assert(err, IsNil) + s.NoError(err) tmpName := writer.Name() defer os.Remove(tmpName) encoder := commitgraph.NewEncoder(writer) err = encoder.Encode(index) - c.Assert(err, IsNil) + s.NoError(err) writer.Close() - testDecodeHelper(c, dotgit, tmpName) - }) + testDecodeHelper(s, dotgit, tmpName) + } } -func (s *CommitgraphSuite) TestReencodeInMemory(c *C) { - fixtures.ByTag("commit-graph").Test(c, func(f *fixtures.Fixture) { +func (s *CommitgraphSuite) TestReencodeInMemory() { + for _, f := range fixtures.ByTag("commit-graph") { dotgit := f.DotGit() reader, err := dotgit.Open(dotgit.Join("objects", "info", "commit-graph")) - c.Assert(err, IsNil) + s.NoError(err) index, err := commitgraph.OpenFileIndex(reader) - c.Assert(err, IsNil) + s.NoError(err) memoryIndex := commitgraph.NewMemoryIndex() for i, hash := range index.Hashes() { commitData, err := index.GetCommitDataByIndex(i) - c.Assert(err, IsNil) + s.NoError(err) memoryIndex.Add(hash, commitData) } reader.Close() writer, err := util.TempFile(dotgit, "", "commit-graph") - c.Assert(err, IsNil) + s.NoError(err) tmpName := writer.Name() defer os.Remove(tmpName) encoder := commitgraph.NewEncoder(writer) err = encoder.Encode(memoryIndex) - c.Assert(err, IsNil) + s.NoError(err) writer.Close() - testDecodeHelper(c, dotgit, tmpName) - }) + testDecodeHelper(s, dotgit, tmpName) + } } diff --git a/plumbing/format/commitgraph/encoder.go b/plumbing/format/commitgraph/encoder.go index 317635384..623553545 100644 --- a/plumbing/format/commitgraph/encoder.go +++ b/plumbing/format/commitgraph/encoder.go @@ -4,9 +4,9 @@ import ( "crypto" "io" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/hash" - "github.com/go-git/go-git/v5/utils/binary" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/hash" + "github.com/jesseduffield/go-git/v5/utils/binary" ) // Encoder writes MemoryIndex structs to an output stream. diff --git a/plumbing/format/commitgraph/file.go b/plumbing/format/commitgraph/file.go index ef8fb3496..d5d892306 100644 --- a/plumbing/format/commitgraph/file.go +++ b/plumbing/format/commitgraph/file.go @@ -8,9 +8,9 @@ import ( "io" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/hash" - "github.com/go-git/go-git/v5/utils/binary" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/hash" + "github.com/jesseduffield/go-git/v5/utils/binary" ) // Deprecated: This package uses the wrong types for Generation and Index in CommitData. diff --git a/plumbing/format/commitgraph/memory.go b/plumbing/format/commitgraph/memory.go index 06415e515..1216d7015 100644 --- a/plumbing/format/commitgraph/memory.go +++ b/plumbing/format/commitgraph/memory.go @@ -1,7 +1,7 @@ package commitgraph import ( - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" ) // MemoryIndex provides a way to build the commit-graph in memory diff --git a/plumbing/format/commitgraph/v2/chain.go b/plumbing/format/commitgraph/v2/chain.go index 8da60d01b..13e34dd9c 100644 --- a/plumbing/format/commitgraph/v2/chain.go +++ b/plumbing/format/commitgraph/v2/chain.go @@ -6,7 +6,7 @@ import ( "path" "github.com/go-git/go-billy/v5" - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" ) // OpenChainFile reads a commit chain file and returns a slice of the hashes within it diff --git a/plumbing/format/commitgraph/v2/chain_test.go b/plumbing/format/commitgraph/v2/chain_test.go index 32ffd69e1..4308dc4d4 100644 --- a/plumbing/format/commitgraph/v2/chain_test.go +++ b/plumbing/format/commitgraph/v2/chain_test.go @@ -5,13 +5,11 @@ import ( "crypto" "strings" - commitgraph "github.com/go-git/go-git/v5/plumbing/format/commitgraph/v2" - "github.com/go-git/go-git/v5/plumbing/hash" - - . "gopkg.in/check.v1" + commitgraph "github.com/jesseduffield/go-git/v5/plumbing/format/commitgraph/v2" + "github.com/jesseduffield/go-git/v5/plumbing/hash" ) -func (s *CommitgraphSuite) TestOpenChainFile(c *C) { +func (s *CommitgraphSuite) TestOpenChainFile() { sha1Data := []string{ "c336d16298a017486c4164c40f8acb28afe64e84", "31eae7b619d166c366bf5df4991f04ba8cebea0a", @@ -71,8 +69,8 @@ func (s *CommitgraphSuite) TestOpenChainFile(c *C) { chainReader := strings.NewReader(chainData) chain, err := commitgraph.OpenChainFile(chainReader) - c.Assert(err, IsNil) - c.Assert(goodShas, DeepEquals, chain) + s.NoError(err) + s.Equal(chain, goodShas) // Test with bad shas chainData = strings.Join(badShas, "\n") + "\n" @@ -80,21 +78,21 @@ func (s *CommitgraphSuite) TestOpenChainFile(c *C) { chainReader = strings.NewReader(chainData) chain, err = commitgraph.OpenChainFile(chainReader) - c.Assert(err, Equals, commitgraph.ErrMalformedCommitGraphFile) - c.Assert(chain, IsNil) + s.Equal(err, commitgraph.ErrMalformedCommitGraphFile) + s.Nil(chain) // Test with empty file emptyChainReader := bytes.NewReader(nil) chain, err = commitgraph.OpenChainFile(emptyChainReader) - c.Assert(err, IsNil) - c.Assert(chain, DeepEquals, []string{}) + s.NoError(err) + s.Equal([]string{}, chain) // Test with file containing only newlines newlineChainData := []byte("\n\n\n") newlineChainReader := bytes.NewReader(newlineChainData) chain, err = commitgraph.OpenChainFile(newlineChainReader) - c.Assert(err, Equals, commitgraph.ErrMalformedCommitGraphFile) - c.Assert(chain, IsNil) + s.Equal(err, commitgraph.ErrMalformedCommitGraphFile) + s.Nil(chain) } diff --git a/plumbing/format/commitgraph/v2/commitgraph.go b/plumbing/format/commitgraph/v2/commitgraph.go index 9c89cd9b4..54f32517c 100644 --- a/plumbing/format/commitgraph/v2/commitgraph.go +++ b/plumbing/format/commitgraph/v2/commitgraph.go @@ -5,7 +5,7 @@ import ( "math" "time" - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" ) // CommitData is a reduced representation of Commit as presented in the commit graph diff --git a/plumbing/format/commitgraph/v2/commitgraph_test.go b/plumbing/format/commitgraph/v2/commitgraph_test.go index 127840567..9ac2d3125 100644 --- a/plumbing/format/commitgraph/v2/commitgraph_test.go +++ b/plumbing/format/commitgraph/v2/commitgraph_test.go @@ -6,85 +6,90 @@ import ( "github.com/go-git/go-billy/v5" "github.com/go-git/go-billy/v5/util" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - commitgraph "github.com/go-git/go-git/v5/plumbing/format/commitgraph/v2" - "github.com/go-git/go-git/v5/plumbing/format/packfile" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + commitgraph "github.com/jesseduffield/go-git/v5/plumbing/format/commitgraph/v2" + "github.com/jesseduffield/go-git/v5/plumbing/format/packfile" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) -func Test(t *testing.T) { TestingT(t) } +type CommitgraphFixtureSuite struct { + fixtures.Suite +} type CommitgraphSuite struct { - fixtures.Suite + suite.Suite + CommitgraphFixtureSuite } -var _ = Suite(&CommitgraphSuite{}) +func TestCommitgraphSuite(t *testing.T) { + suite.Run(t, new(CommitgraphSuite)) +} -func testReadIndex(c *C, fs billy.Filesystem, path string) commitgraph.Index { +func testReadIndex(s *CommitgraphSuite, fs billy.Filesystem, path string) commitgraph.Index { reader, err := fs.Open(path) - c.Assert(err, IsNil) + s.NoError(err) index, err := commitgraph.OpenFileIndex(reader) - c.Assert(err, IsNil) - c.Assert(index, NotNil) + s.NoError(err) + s.NotNil(index) return index } -func testDecodeHelper(c *C, index commitgraph.Index) { +func testDecodeHelper(s *CommitgraphSuite, index commitgraph.Index) { // Root commit nodeIndex, err := index.GetIndexByHash(plumbing.NewHash("347c91919944a68e9413581a1bc15519550a3afe")) - c.Assert(err, IsNil) + s.NoError(err) commitData, err := index.GetCommitDataByIndex(nodeIndex) - c.Assert(err, IsNil) - c.Assert(len(commitData.ParentIndexes), Equals, 0) - c.Assert(len(commitData.ParentHashes), Equals, 0) + s.NoError(err) + s.Len(commitData.ParentIndexes, 0) + s.Len(commitData.ParentHashes, 0) // Regular commit nodeIndex, err = index.GetIndexByHash(plumbing.NewHash("e713b52d7e13807e87a002e812041f248db3f643")) - c.Assert(err, IsNil) + s.NoError(err) commitData, err = index.GetCommitDataByIndex(nodeIndex) - c.Assert(err, IsNil) - c.Assert(len(commitData.ParentIndexes), Equals, 1) - c.Assert(len(commitData.ParentHashes), Equals, 1) - c.Assert(commitData.ParentHashes[0].String(), Equals, "347c91919944a68e9413581a1bc15519550a3afe") + s.NoError(err) + s.Len(commitData.ParentIndexes, 1) + s.Len(commitData.ParentHashes, 1) + s.Equal("347c91919944a68e9413581a1bc15519550a3afe", commitData.ParentHashes[0].String()) // Merge commit nodeIndex, err = index.GetIndexByHash(plumbing.NewHash("b29328491a0682c259bcce28741eac71f3499f7d")) - c.Assert(err, IsNil) + s.NoError(err) commitData, err = index.GetCommitDataByIndex(nodeIndex) - c.Assert(err, IsNil) - c.Assert(len(commitData.ParentIndexes), Equals, 2) - c.Assert(len(commitData.ParentHashes), Equals, 2) - c.Assert(commitData.ParentHashes[0].String(), Equals, "e713b52d7e13807e87a002e812041f248db3f643") - c.Assert(commitData.ParentHashes[1].String(), Equals, "03d2c021ff68954cf3ef0a36825e194a4b98f981") + s.NoError(err) + s.Len(commitData.ParentIndexes, 2) + s.Len(commitData.ParentHashes, 2) + s.Equal("e713b52d7e13807e87a002e812041f248db3f643", commitData.ParentHashes[0].String()) + s.Equal("03d2c021ff68954cf3ef0a36825e194a4b98f981", commitData.ParentHashes[1].String()) // Octopus merge commit nodeIndex, err = index.GetIndexByHash(plumbing.NewHash("6f6c5d2be7852c782be1dd13e36496dd7ad39560")) - c.Assert(err, IsNil) + s.NoError(err) commitData, err = index.GetCommitDataByIndex(nodeIndex) - c.Assert(err, IsNil) - c.Assert(len(commitData.ParentIndexes), Equals, 3) - c.Assert(len(commitData.ParentHashes), Equals, 3) - c.Assert(commitData.ParentHashes[0].String(), Equals, "ce275064ad67d51e99f026084e20827901a8361c") - c.Assert(commitData.ParentHashes[1].String(), Equals, "bb13916df33ed23004c3ce9ed3b8487528e655c1") - c.Assert(commitData.ParentHashes[2].String(), Equals, "a45273fe2d63300e1962a9e26a6b15c276cd7082") + s.NoError(err) + s.Len(commitData.ParentIndexes, 3) + s.Len(commitData.ParentHashes, 3) + s.Equal("ce275064ad67d51e99f026084e20827901a8361c", commitData.ParentHashes[0].String()) + s.Equal("bb13916df33ed23004c3ce9ed3b8487528e655c1", commitData.ParentHashes[1].String()) + s.Equal("a45273fe2d63300e1962a9e26a6b15c276cd7082", commitData.ParentHashes[2].String()) // Check all hashes hashes := index.Hashes() - c.Assert(len(hashes), Equals, 11) - c.Assert(hashes[0].String(), Equals, "03d2c021ff68954cf3ef0a36825e194a4b98f981") - c.Assert(hashes[10].String(), Equals, "e713b52d7e13807e87a002e812041f248db3f643") + s.Len(hashes, 11) + s.Equal("03d2c021ff68954cf3ef0a36825e194a4b98f981", hashes[0].String()) + s.Equal("e713b52d7e13807e87a002e812041f248db3f643", hashes[10].String()) } -func (s *CommitgraphSuite) TestDecodeMultiChain(c *C) { - fixtures.ByTag("commit-graph-chain-2").Test(c, func(f *fixtures.Fixture) { +func (s *CommitgraphSuite) TestDecodeMultiChain() { + for _, f := range fixtures.ByTag("commit-graph-chain-2") { dotgit := f.DotGit() index, err := commitgraph.OpenChainOrFileIndex(dotgit) - c.Assert(err, IsNil) + s.NoError(err) defer index.Close() storer := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) p := f.Packfile() @@ -93,108 +98,108 @@ func (s *CommitgraphSuite) TestDecodeMultiChain(c *C) { for idx, hash := range index.Hashes() { idx2, err := index.GetIndexByHash(hash) - c.Assert(err, IsNil) - c.Assert(idx2, Equals, uint32(idx)) + s.NoError(err) + s.Equal(uint32(idx), idx2) hash2, err := index.GetHashByIndex(idx2) - c.Assert(err, IsNil) - c.Assert(hash2.String(), Equals, hash.String()) + s.NoError(err) + s.Equal(hash.String(), hash2.String()) commitData, err := index.GetCommitDataByIndex(uint32(idx)) - c.Assert(err, IsNil) + s.NoError(err) commit, err := object.GetCommit(storer, hash) - c.Assert(err, IsNil) + s.NoError(err) for i, parent := range commit.ParentHashes { - c.Assert(hash.String()+":"+parent.String(), Equals, hash.String()+":"+commitData.ParentHashes[i].String()) + s.Equal(hash.String()+":"+commitData.ParentHashes[i].String(), hash.String()+":"+parent.String()) } } - }) + } } -func (s *CommitgraphSuite) TestDecode(c *C) { - fixtures.ByTag("commit-graph").Test(c, func(f *fixtures.Fixture) { +func (s *CommitgraphSuite) TestDecode() { + for _, f := range fixtures.ByTag("commit-graph") { dotgit := f.DotGit() - index := testReadIndex(c, dotgit, dotgit.Join("objects", "info", "commit-graph")) + index := testReadIndex(s, dotgit, dotgit.Join("objects", "info", "commit-graph")) defer index.Close() - testDecodeHelper(c, index) - }) + testDecodeHelper(s, index) + } } -func (s *CommitgraphSuite) TestDecodeChain(c *C) { - fixtures.ByTag("commit-graph").Test(c, func(f *fixtures.Fixture) { +func (s *CommitgraphSuite) TestDecodeChain() { + for _, f := range fixtures.ByTag("commit-graph") { dotgit := f.DotGit() index, err := commitgraph.OpenChainOrFileIndex(dotgit) - c.Assert(err, IsNil) + s.NoError(err) defer index.Close() - testDecodeHelper(c, index) - }) + testDecodeHelper(s, index) + } - fixtures.ByTag("commit-graph-chain").Test(c, func(f *fixtures.Fixture) { + for _, f := range fixtures.ByTag("commit-graph-chain") { dotgit := f.DotGit() index, err := commitgraph.OpenChainOrFileIndex(dotgit) - c.Assert(err, IsNil) + s.NoError(err) defer index.Close() - testDecodeHelper(c, index) - }) + testDecodeHelper(s, index) + } } -func (s *CommitgraphSuite) TestReencode(c *C) { - fixtures.ByTag("commit-graph").Test(c, func(f *fixtures.Fixture) { +func (s *CommitgraphSuite) TestReencode() { + for _, f := range fixtures.ByTag("commit-graph") { dotgit := f.DotGit() reader, err := dotgit.Open(dotgit.Join("objects", "info", "commit-graph")) - c.Assert(err, IsNil) + s.NoError(err) defer reader.Close() index, err := commitgraph.OpenFileIndex(reader) - c.Assert(err, IsNil) + s.NoError(err) defer index.Close() writer, err := util.TempFile(dotgit, "", "commit-graph") - c.Assert(err, IsNil) + s.NoError(err) tmpName := writer.Name() defer os.Remove(tmpName) encoder := commitgraph.NewEncoder(writer) err = encoder.Encode(index) - c.Assert(err, IsNil) + s.NoError(err) writer.Close() - tmpIndex := testReadIndex(c, dotgit, tmpName) + tmpIndex := testReadIndex(s, dotgit, tmpName) defer tmpIndex.Close() - testDecodeHelper(c, tmpIndex) - }) + testDecodeHelper(s, tmpIndex) + } } -func (s *CommitgraphSuite) TestReencodeInMemory(c *C) { - fixtures.ByTag("commit-graph").Test(c, func(f *fixtures.Fixture) { +func (s *CommitgraphSuite) TestReencodeInMemory() { + for _, f := range fixtures.ByTag("commit-graph") { dotgit := f.DotGit() reader, err := dotgit.Open(dotgit.Join("objects", "info", "commit-graph")) - c.Assert(err, IsNil) + s.NoError(err) index, err := commitgraph.OpenFileIndex(reader) - c.Assert(err, IsNil) + s.NoError(err) memoryIndex := commitgraph.NewMemoryIndex() defer memoryIndex.Close() for i, hash := range index.Hashes() { commitData, err := index.GetCommitDataByIndex(uint32(i)) - c.Assert(err, IsNil) + s.NoError(err) memoryIndex.Add(hash, commitData) } index.Close() writer, err := util.TempFile(dotgit, "", "commit-graph") - c.Assert(err, IsNil) + s.NoError(err) tmpName := writer.Name() defer os.Remove(tmpName) encoder := commitgraph.NewEncoder(writer) err = encoder.Encode(memoryIndex) - c.Assert(err, IsNil) + s.NoError(err) writer.Close() - tmpIndex := testReadIndex(c, dotgit, tmpName) + tmpIndex := testReadIndex(s, dotgit, tmpName) defer tmpIndex.Close() - testDecodeHelper(c, tmpIndex) - }) + testDecodeHelper(s, tmpIndex) + } } diff --git a/plumbing/format/commitgraph/v2/encoder.go b/plumbing/format/commitgraph/v2/encoder.go index b79bc77f7..16c3ab05b 100644 --- a/plumbing/format/commitgraph/v2/encoder.go +++ b/plumbing/format/commitgraph/v2/encoder.go @@ -5,9 +5,9 @@ import ( "io" "math" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/hash" - "github.com/go-git/go-git/v5/utils/binary" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/hash" + "github.com/jesseduffield/go-git/v5/utils/binary" ) // Encoder writes MemoryIndex structs to an output stream. diff --git a/plumbing/format/commitgraph/v2/file.go b/plumbing/format/commitgraph/v2/file.go index c5f61e4de..5e12c505f 100644 --- a/plumbing/format/commitgraph/v2/file.go +++ b/plumbing/format/commitgraph/v2/file.go @@ -8,9 +8,9 @@ import ( "io" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/hash" - "github.com/go-git/go-git/v5/utils/binary" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/hash" + "github.com/jesseduffield/go-git/v5/utils/binary" ) var ( diff --git a/plumbing/format/commitgraph/v2/memory.go b/plumbing/format/commitgraph/v2/memory.go index 8de0c5f08..ad7c908cf 100644 --- a/plumbing/format/commitgraph/v2/memory.go +++ b/plumbing/format/commitgraph/v2/memory.go @@ -3,7 +3,7 @@ package v2 import ( "math" - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" ) // MemoryIndex provides a way to build the commit-graph in memory diff --git a/plumbing/format/config/common_test.go b/plumbing/format/config/common_test.go index dca38dff8..8728e5c48 100644 --- a/plumbing/format/config/common_test.go +++ b/plumbing/format/config/common_test.go @@ -3,16 +3,18 @@ package config import ( "testing" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } - -type CommonSuite struct{} +type CommonSuite struct { + suite.Suite +} -var _ = Suite(&CommonSuite{}) +func TestCommonSuite(t *testing.T) { + suite.Run(t, new(CommonSuite)) +} -func (s *CommonSuite) TestConfig_SetOption(c *C) { +func (s *CommonSuite) TestConfig_SetOption() { obtained := New().SetOption("section", NoSubsection, "key1", "value1") expected := &Config{ Sections: []*Section{ @@ -24,9 +26,9 @@ func (s *CommonSuite) TestConfig_SetOption(c *C) { }, }, } - c.Assert(obtained, DeepEquals, expected) + s.Equal(expected, obtained) obtained = obtained.SetOption("section", NoSubsection, "key1", "value1") - c.Assert(obtained, DeepEquals, expected) + s.Equal(expected, obtained) obtained = New().SetOption("section", "subsection", "key1", "value1") expected = &Config{ @@ -44,12 +46,12 @@ func (s *CommonSuite) TestConfig_SetOption(c *C) { }, }, } - c.Assert(obtained, DeepEquals, expected) + s.Equal(expected, obtained) obtained = obtained.SetOption("section", "subsection", "key1", "value1") - c.Assert(obtained, DeepEquals, expected) + s.Equal(expected, obtained) } -func (s *CommonSuite) TestConfig_AddOption(c *C) { +func (s *CommonSuite) TestConfig_AddOption() { obtained := New().AddOption("section", NoSubsection, "key1", "value1") expected := &Config{ Sections: []*Section{ @@ -61,34 +63,34 @@ func (s *CommonSuite) TestConfig_AddOption(c *C) { }, }, } - c.Assert(obtained, DeepEquals, expected) + s.Equal(expected, obtained) } -func (s *CommonSuite) TestConfig_HasSection(c *C) { +func (s *CommonSuite) TestConfig_HasSection() { sect := New(). AddOption("section1", "sub1", "key1", "value1"). AddOption("section1", "sub2", "key1", "value1") - c.Assert(sect.HasSection("section1"), Equals, true) - c.Assert(sect.HasSection("section2"), Equals, false) + s.True(sect.HasSection("section1")) + s.False(sect.HasSection("section2")) } -func (s *CommonSuite) TestConfig_RemoveSection(c *C) { +func (s *CommonSuite) TestConfig_RemoveSection() { sect := New(). AddOption("section1", NoSubsection, "key1", "value1"). AddOption("section2", NoSubsection, "key1", "value1") expected := New(). AddOption("section1", NoSubsection, "key1", "value1") - c.Assert(sect.RemoveSection("other"), DeepEquals, sect) - c.Assert(sect.RemoveSection("section2"), DeepEquals, expected) + s.Equal(sect, sect.RemoveSection("other")) + s.Equal(expected, sect.RemoveSection("section2")) } -func (s *CommonSuite) TestConfig_RemoveSubsection(c *C) { +func (s *CommonSuite) TestConfig_RemoveSubsection() { sect := New(). AddOption("section1", "sub1", "key1", "value1"). AddOption("section1", "sub2", "key1", "value1") expected := New(). AddOption("section1", "sub1", "key1", "value1") - c.Assert(sect.RemoveSubsection("section1", "other"), DeepEquals, sect) - c.Assert(sect.RemoveSubsection("other", "other"), DeepEquals, sect) - c.Assert(sect.RemoveSubsection("section1", "sub2"), DeepEquals, expected) + s.Equal(sect, sect.RemoveSubsection("section1", "other")) + s.Equal(sect, sect.RemoveSubsection("other", "other")) + s.Equal(expected, sect.RemoveSubsection("section1", "sub2")) } diff --git a/plumbing/format/config/decoder_test.go b/plumbing/format/config/decoder_test.go index 6283f5e14..4f2ec178c 100644 --- a/plumbing/format/config/decoder_test.go +++ b/plumbing/format/config/decoder_test.go @@ -2,95 +2,100 @@ package config import ( "bytes" + "fmt" "testing" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) -type DecoderSuite struct{} +type DecoderSuite struct { + suite.Suite +} -var _ = Suite(&DecoderSuite{}) +func TestDecoderSuite(t *testing.T) { + suite.Run(t, new(DecoderSuite)) +} -func (s *DecoderSuite) TestDecode(c *C) { +func (s *DecoderSuite) TestDecode() { for idx, fixture := range fixtures { r := bytes.NewReader([]byte(fixture.Raw)) d := NewDecoder(r) cfg := &Config{} err := d.Decode(cfg) - c.Assert(err, IsNil, Commentf("decoder error for fixture: %d", idx)) + s.NoError(err, fmt.Sprintf("decoder error for fixture: %d", idx)) buf := bytes.NewBuffer(nil) e := NewEncoder(buf) _ = e.Encode(cfg) - c.Assert(cfg, DeepEquals, fixture.Config, Commentf("bad result for fixture: %d, %s", idx, buf.String())) + s.Equal(fixture.Config, cfg, fmt.Sprintf("bad result for fixture: %d, %s", idx, buf.String())) } } -func (s *DecoderSuite) TestDecodeFailsWithIdentBeforeSection(c *C) { +func (s *DecoderSuite) TestDecodeFailsWithIdentBeforeSection() { t := ` key=value [section] key=value ` - decodeFails(c, t) + decodeFails(s, t) } -func (s *DecoderSuite) TestDecodeFailsWithEmptySectionName(c *C) { +func (s *DecoderSuite) TestDecodeFailsWithEmptySectionName() { t := ` [] key=value ` - decodeFails(c, t) + decodeFails(s, t) } -func (s *DecoderSuite) TestDecodeFailsWithEmptySubsectionName(c *C) { +func (s *DecoderSuite) TestDecodeFailsWithEmptySubsectionName() { t := ` [remote ""] key=value ` - decodeFails(c, t) + decodeFails(s, t) } -func (s *DecoderSuite) TestDecodeFailsWithBadSubsectionName(c *C) { +func (s *DecoderSuite) TestDecodeFailsWithBadSubsectionName() { t := ` [remote origin"] key=value ` - decodeFails(c, t) + decodeFails(s, t) t = ` [remote "origin] key=value ` - decodeFails(c, t) + decodeFails(s, t) } -func (s *DecoderSuite) TestDecodeFailsWithTrailingGarbage(c *C) { +func (s *DecoderSuite) TestDecodeFailsWithTrailingGarbage() { t := ` [remote]garbage key=value ` - decodeFails(c, t) + decodeFails(s, t) t = ` [remote "origin"]garbage key=value ` - decodeFails(c, t) + decodeFails(s, t) } -func (s *DecoderSuite) TestDecodeFailsWithGarbage(c *C) { - decodeFails(c, "---") - decodeFails(c, "????") - decodeFails(c, "[sect\nkey=value") - decodeFails(c, "sect]\nkey=value") - decodeFails(c, `[section]key="value`) - decodeFails(c, `[section]key=value"`) +func (s *DecoderSuite) TestDecodeFailsWithGarbage() { + decodeFails(s, "---") + decodeFails(s, "????") + decodeFails(s, "[sect\nkey=value") + decodeFails(s, "sect]\nkey=value") + decodeFails(s, `[section]key="value`) + decodeFails(s, `[section]key=value"`) } -func decodeFails(c *C, text string) { +func decodeFails(s *DecoderSuite, text string) { r := bytes.NewReader([]byte(text)) d := NewDecoder(r) cfg := &Config{} err := d.Decode(cfg) - c.Assert(err, NotNil) + s.NotNil(err) } func FuzzDecoder(f *testing.F) { diff --git a/plumbing/format/config/encoder_test.go b/plumbing/format/config/encoder_test.go index 5335b83ff..7191ff475 100644 --- a/plumbing/format/config/encoder_test.go +++ b/plumbing/format/config/encoder_test.go @@ -2,20 +2,26 @@ package config import ( "bytes" + "fmt" + "testing" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) -type EncoderSuite struct{} +type EncoderSuite struct { + suite.Suite +} -var _ = Suite(&EncoderSuite{}) +func TestEncoderSuite(t *testing.T) { + suite.Run(t, new(EncoderSuite)) +} -func (s *EncoderSuite) TestEncode(c *C) { +func (s *EncoderSuite) TestEncode() { for idx, fixture := range fixtures { buf := &bytes.Buffer{} e := NewEncoder(buf) err := e.Encode(fixture.Config) - c.Assert(err, IsNil, Commentf("encoder error for fixture: %d", idx)) - c.Assert(buf.String(), Equals, fixture.Text, Commentf("bad result for fixture: %d", idx)) + s.NoError(err, fmt.Sprintf("encoder error for fixture: %d", idx)) + s.Equal(fixture.Text, buf.String(), fmt.Sprintf("bad result for fixture: %d", idx)) } } diff --git a/plumbing/format/config/option_test.go b/plumbing/format/config/option_test.go index 49b48556d..f8c622e88 100644 --- a/plumbing/format/config/option_test.go +++ b/plumbing/format/config/option_test.go @@ -1,48 +1,54 @@ package config import ( - . "gopkg.in/check.v1" + "testing" + + "github.com/stretchr/testify/suite" ) -type OptionSuite struct{} +type OptionSuite struct { + suite.Suite +} -var _ = Suite(&OptionSuite{}) +func TestOptionSuite(t *testing.T) { + suite.Run(t, new(OptionSuite)) +} -func (s *OptionSuite) TestOptions_Has(c *C) { +func (s *OptionSuite) TestOptions_Has() { o := Options{ &Option{"k", "v"}, &Option{"ok", "v1"}, &Option{"K", "v2"}, } - c.Assert(o.Has("k"), Equals, true) - c.Assert(o.Has("K"), Equals, true) - c.Assert(o.Has("ok"), Equals, true) - c.Assert(o.Has("unexistant"), Equals, false) + s.True(o.Has("k")) + s.True(o.Has("K")) + s.True(o.Has("ok")) + s.False(o.Has("unexistant")) o = Options{} - c.Assert(o.Has("k"), Equals, false) + s.False(o.Has("k")) } -func (s *OptionSuite) TestOptions_GetAll(c *C) { +func (s *OptionSuite) TestOptions_GetAll() { o := Options{ &Option{"k", "v"}, &Option{"ok", "v1"}, &Option{"K", "v2"}, } - c.Assert(o.GetAll("k"), DeepEquals, []string{"v", "v2"}) - c.Assert(o.GetAll("K"), DeepEquals, []string{"v", "v2"}) - c.Assert(o.GetAll("ok"), DeepEquals, []string{"v1"}) - c.Assert(o.GetAll("unexistant"), DeepEquals, []string{}) + s.Equal([]string{"v", "v2"}, o.GetAll("k")) + s.Equal([]string{"v", "v2"}, o.GetAll("K")) + s.Equal([]string{"v1"}, o.GetAll("ok")) + s.Equal([]string{}, o.GetAll("unexistant")) o = Options{} - c.Assert(o.GetAll("k"), DeepEquals, []string{}) + s.Equal([]string{}, o.GetAll("k")) } -func (s *OptionSuite) TestOption_IsKey(c *C) { - c.Assert((&Option{Key: "key"}).IsKey("key"), Equals, true) - c.Assert((&Option{Key: "key"}).IsKey("KEY"), Equals, true) - c.Assert((&Option{Key: "KEY"}).IsKey("key"), Equals, true) - c.Assert((&Option{Key: "key"}).IsKey("other"), Equals, false) - c.Assert((&Option{Key: "key"}).IsKey(""), Equals, false) - c.Assert((&Option{Key: ""}).IsKey("key"), Equals, false) +func (s *OptionSuite) TestOption_IsKey() { + s.True((&Option{Key: "key"}).IsKey("key")) + s.True((&Option{Key: "key"}).IsKey("KEY")) + s.True((&Option{Key: "KEY"}).IsKey("key")) + s.False((&Option{Key: "key"}).IsKey("other")) + s.False((&Option{Key: "key"}).IsKey("")) + s.False((&Option{Key: ""}).IsKey("key")) } diff --git a/plumbing/format/config/section_test.go b/plumbing/format/config/section_test.go index c7cc4a900..1ebe6b4ba 100644 --- a/plumbing/format/config/section_test.go +++ b/plumbing/format/config/section_test.go @@ -1,14 +1,20 @@ package config import ( - . "gopkg.in/check.v1" + "testing" + + "github.com/stretchr/testify/suite" ) -type SectionSuite struct{} +type SectionSuite struct { + suite.Suite +} -var _ = Suite(&SectionSuite{}) +func TestSectionSuite(t *testing.T) { + suite.Run(t, new(SectionSuite)) +} -func (s *SectionSuite) TestSections_GoString(c *C) { +func (s *SectionSuite) TestSections_GoString() { sects := Sections{ &Section{ Options: []*Option{ @@ -25,10 +31,10 @@ func (s *SectionSuite) TestSections_GoString(c *C) { } expected := "&config.Section{Name:\"\", Options:&config.Option{Key:\"key1\", Value:\"value1\"}, &config.Option{Key:\"key2\", Value:\"value2\"}, Subsections:}, &config.Section{Name:\"\", Options:&config.Option{Key:\"key1\", Value:\"value3\"}, &config.Option{Key:\"key2\", Value:\"value4\"}, Subsections:}" - c.Assert(sects.GoString(), Equals, expected) + s.Equal(expected, sects.GoString()) } -func (s *SectionSuite) TestSubsections_GoString(c *C) { +func (s *SectionSuite) TestSubsections_GoString() { sects := Subsections{ &Subsection{ Options: []*Option{ @@ -47,19 +53,19 @@ func (s *SectionSuite) TestSubsections_GoString(c *C) { } expected := "&config.Subsection{Name:\"\", Options:&config.Option{Key:\"key1\", Value:\"value1\"}, &config.Option{Key:\"key2\", Value:\"value2\"}, &config.Option{Key:\"key1\", Value:\"value3\"}}, &config.Subsection{Name:\"\", Options:&config.Option{Key:\"key1\", Value:\"value1\"}, &config.Option{Key:\"key2\", Value:\"value2\"}, &config.Option{Key:\"key1\", Value:\"value3\"}}" - c.Assert(sects.GoString(), Equals, expected) + s.Equal(expected, sects.GoString()) } -func (s *SectionSuite) TestSection_IsName(c *C) { +func (s *SectionSuite) TestSection_IsName() { sect := &Section{ Name: "name1", } - c.Assert(sect.IsName("name1"), Equals, true) - c.Assert(sect.IsName("Name1"), Equals, true) + s.True(sect.IsName("name1")) + s.True(sect.IsName("Name1")) } -func (s *SectionSuite) TestSection_Subsection(c *C) { +func (s *SectionSuite) TestSection_Subsection() { subSect1 := &Subsection{ Name: "name1", Options: Options{ @@ -72,15 +78,15 @@ func (s *SectionSuite) TestSection_Subsection(c *C) { }, } - c.Assert(sect.Subsection("name1"), DeepEquals, subSect1) + s.Equal(subSect1, sect.Subsection("name1")) subSect2 := &Subsection{ Name: "name2", } - c.Assert(sect.Subsection("name2"), DeepEquals, subSect2) + s.Equal(subSect2, sect.Subsection("name2")) } -func (s *SectionSuite) TestSection_HasSubsection(c *C) { +func (s *SectionSuite) TestSection_HasSubsection() { sect := &Section{ Subsections: Subsections{ &Subsection{ @@ -89,11 +95,11 @@ func (s *SectionSuite) TestSection_HasSubsection(c *C) { }, } - c.Assert(sect.HasSubsection("name1"), Equals, true) - c.Assert(sect.HasSubsection("name2"), Equals, false) + s.True(sect.HasSubsection("name1")) + s.False(sect.HasSubsection("name2")) } -func (s *SectionSuite) TestSection_RemoveSubsection(c *C) { +func (s *SectionSuite) TestSection_RemoveSubsection() { sect := &Section{ Subsections: Subsections{ &Subsection{ @@ -112,12 +118,12 @@ func (s *SectionSuite) TestSection_RemoveSubsection(c *C) { }, }, } - c.Assert(sect.RemoveSubsection("name1"), DeepEquals, expected) - c.Assert(sect.HasSubsection("name1"), Equals, false) - c.Assert(sect.HasSubsection("name2"), Equals, true) + s.Equal(expected, sect.RemoveSubsection("name1")) + s.False(sect.HasSubsection("name1")) + s.True(sect.HasSubsection("name2")) } -func (s *SectionSuite) TestSection_Option(c *C) { +func (s *SectionSuite) TestSection_Option() { sect := &Section{ Options: []*Option{ {Key: "key1", Value: "value1"}, @@ -125,12 +131,12 @@ func (s *SectionSuite) TestSection_Option(c *C) { {Key: "key1", Value: "value3"}, }, } - c.Assert(sect.Option("otherkey"), Equals, "") - c.Assert(sect.Option("key2"), Equals, "value2") - c.Assert(sect.Option("key1"), Equals, "value3") + s.Equal("", sect.Option("otherkey")) + s.Equal("value2", sect.Option("key2")) + s.Equal("value3", sect.Option("key1")) } -func (s *SectionSuite) TestSection_OptionAll(c *C) { +func (s *SectionSuite) TestSection_OptionAll() { sect := &Section{ Options: []*Option{ {Key: "key1", Value: "value1"}, @@ -138,12 +144,12 @@ func (s *SectionSuite) TestSection_OptionAll(c *C) { {Key: "key1", Value: "value3"}, }, } - c.Assert(sect.OptionAll("otherkey"), DeepEquals, []string{}) - c.Assert(sect.OptionAll("key2"), DeepEquals, []string{"value2"}) - c.Assert(sect.OptionAll("key1"), DeepEquals, []string{"value1", "value3"}) + s.Equal([]string{}, sect.OptionAll("otherkey")) + s.Equal([]string{"value2"}, sect.OptionAll("key2")) + s.Equal([]string{"value1", "value3"}, sect.OptionAll("key1")) } -func (s *SectionSuite) TestSection_HasOption(c *C) { +func (s *SectionSuite) TestSection_HasOption() { sect := &Section{ Options: []*Option{ {Key: "key1", Value: "value1"}, @@ -151,12 +157,12 @@ func (s *SectionSuite) TestSection_HasOption(c *C) { {Key: "key1", Value: "value3"}, }, } - c.Assert(sect.HasOption("otherkey"), Equals, false) - c.Assert(sect.HasOption("key2"), Equals, true) - c.Assert(sect.HasOption("key1"), Equals, true) + s.False(sect.HasOption("otherkey")) + s.True(sect.HasOption("key2")) + s.True(sect.HasOption("key1")) } -func (s *SectionSuite) TestSection_AddOption(c *C) { +func (s *SectionSuite) TestSection_AddOption() { sect := &Section{ Options: []*Option{ {"key1", "value1"}, @@ -168,7 +174,7 @@ func (s *SectionSuite) TestSection_AddOption(c *C) { {"key2", "value2"}, }, } - c.Assert(sect.AddOption("key2", "value2"), DeepEquals, sect1) + s.Equal(sect1, sect.AddOption("key2", "value2")) sect2 := &Section{ Options: []*Option{ @@ -177,10 +183,10 @@ func (s *SectionSuite) TestSection_AddOption(c *C) { {"key1", "value3"}, }, } - c.Assert(sect.AddOption("key1", "value3"), DeepEquals, sect2) + s.Equal(sect2, sect.AddOption("key1", "value3")) } -func (s *SectionSuite) TestSection_SetOption(c *C) { +func (s *SectionSuite) TestSection_SetOption() { sect := &Section{ Options: []*Option{ {Key: "key1", Value: "value1"}, @@ -194,10 +200,10 @@ func (s *SectionSuite) TestSection_SetOption(c *C) { {Key: "key1", Value: "value4"}, }, } - c.Assert(sect.SetOption("key1", "value4"), DeepEquals, expected) + s.Equal(expected, sect.SetOption("key1", "value4")) } -func (s *SectionSuite) TestSection_RemoveOption(c *C) { +func (s *SectionSuite) TestSection_RemoveOption() { sect := &Section{ Options: []*Option{ {Key: "key1", Value: "value1"}, @@ -205,26 +211,26 @@ func (s *SectionSuite) TestSection_RemoveOption(c *C) { {Key: "key1", Value: "value3"}, }, } - c.Assert(sect.RemoveOption("otherkey"), DeepEquals, sect) + s.Equal(sect, sect.RemoveOption("otherkey")) expected := &Section{ Options: []*Option{ {Key: "key2", Value: "value2"}, }, } - c.Assert(sect.RemoveOption("key1"), DeepEquals, expected) + s.Equal(expected, sect.RemoveOption("key1")) } -func (s *SectionSuite) TestSubsection_IsName(c *C) { +func (s *SectionSuite) TestSubsection_IsName() { sect := &Subsection{ Name: "name1", } - c.Assert(sect.IsName("name1"), Equals, true) - c.Assert(sect.IsName("Name1"), Equals, false) + s.True(sect.IsName("name1")) + s.False(sect.IsName("Name1")) } -func (s *SectionSuite) TestSubsection_Option(c *C) { +func (s *SectionSuite) TestSubsection_Option() { sect := &Subsection{ Options: []*Option{ {Key: "key1", Value: "value1"}, @@ -232,12 +238,12 @@ func (s *SectionSuite) TestSubsection_Option(c *C) { {Key: "key1", Value: "value3"}, }, } - c.Assert(sect.Option("otherkey"), Equals, "") - c.Assert(sect.Option("key2"), Equals, "value2") - c.Assert(sect.Option("key1"), Equals, "value3") + s.Equal("", sect.Option("otherkey")) + s.Equal("value2", sect.Option("key2")) + s.Equal("value3", sect.Option("key1")) } -func (s *SectionSuite) TestSubsection_OptionAll(c *C) { +func (s *SectionSuite) TestSubsection_OptionAll() { sect := &Subsection{ Options: []*Option{ {Key: "key1", Value: "value1"}, @@ -245,12 +251,12 @@ func (s *SectionSuite) TestSubsection_OptionAll(c *C) { {Key: "key1", Value: "value3"}, }, } - c.Assert(sect.OptionAll("otherkey"), DeepEquals, []string{}) - c.Assert(sect.OptionAll("key2"), DeepEquals, []string{"value2"}) - c.Assert(sect.OptionAll("key1"), DeepEquals, []string{"value1", "value3"}) + s.Equal([]string{}, sect.OptionAll("otherkey")) + s.Equal([]string{"value2"}, sect.OptionAll("key2")) + s.Equal([]string{"value1", "value3"}, sect.OptionAll("key1")) } -func (s *SectionSuite) TestSubsection_HasOption(c *C) { +func (s *SectionSuite) TestSubsection_HasOption() { sect := &Subsection{ Options: []*Option{ {Key: "key1", Value: "value1"}, @@ -258,12 +264,12 @@ func (s *SectionSuite) TestSubsection_HasOption(c *C) { {Key: "key1", Value: "value3"}, }, } - c.Assert(sect.HasOption("otherkey"), Equals, false) - c.Assert(sect.HasOption("key2"), Equals, true) - c.Assert(sect.HasOption("key1"), Equals, true) + s.False(sect.HasOption("otherkey")) + s.True(sect.HasOption("key2")) + s.True(sect.HasOption("key1")) } -func (s *SectionSuite) TestSubsection_AddOption(c *C) { +func (s *SectionSuite) TestSubsection_AddOption() { sect := &Subsection{ Options: []*Option{ {"key1", "value1"}, @@ -275,7 +281,7 @@ func (s *SectionSuite) TestSubsection_AddOption(c *C) { {"key2", "value2"}, }, } - c.Assert(sect.AddOption("key2", "value2"), DeepEquals, sect1) + s.Equal(sect1, sect.AddOption("key2", "value2")) sect2 := &Subsection{ Options: []*Option{ @@ -284,10 +290,10 @@ func (s *SectionSuite) TestSubsection_AddOption(c *C) { {"key1", "value3"}, }, } - c.Assert(sect.AddOption("key1", "value3"), DeepEquals, sect2) + s.Equal(sect2, sect.AddOption("key1", "value3")) } -func (s *SectionSuite) TestSubsection_SetOption(c *C) { +func (s *SectionSuite) TestSubsection_SetOption() { sect := &Subsection{ Options: []*Option{ {Key: "key1", Value: "value1"}, @@ -303,10 +309,10 @@ func (s *SectionSuite) TestSubsection_SetOption(c *C) { {Key: "key1", Value: "value4"}, }, } - c.Assert(sect.SetOption("key1", "value1", "value4"), DeepEquals, expected) + s.Equal(expected, sect.SetOption("key1", "value1", "value4")) } -func (s *SectionSuite) TestSubsection_RemoveOption(c *C) { +func (s *SectionSuite) TestSubsection_RemoveOption() { sect := &Subsection{ Options: []*Option{ {Key: "key1", Value: "value1"}, @@ -314,12 +320,12 @@ func (s *SectionSuite) TestSubsection_RemoveOption(c *C) { {Key: "key1", Value: "value3"}, }, } - c.Assert(sect.RemoveOption("otherkey"), DeepEquals, sect) + s.Equal(sect, sect.RemoveOption("otherkey")) expected := &Subsection{ Options: []*Option{ {Key: "key2", Value: "value2"}, }, } - c.Assert(sect.RemoveOption("key1"), DeepEquals, expected) + s.Equal(expected, sect.RemoveOption("key1")) } diff --git a/plumbing/format/diff/colorconfig.go b/plumbing/format/diff/colorconfig.go index 6fd415846..212401be7 100644 --- a/plumbing/format/diff/colorconfig.go +++ b/plumbing/format/diff/colorconfig.go @@ -1,6 +1,6 @@ package diff -import "github.com/go-git/go-git/v5/plumbing/color" +import "github.com/jesseduffield/go-git/v5/plumbing/color" // A ColorKey is a key into a ColorConfig map and also equal to the key in the // diff.color subsection of the config. See diff --git a/plumbing/format/diff/patch.go b/plumbing/format/diff/patch.go index c7678b01a..330f5dc1f 100644 --- a/plumbing/format/diff/patch.go +++ b/plumbing/format/diff/patch.go @@ -1,8 +1,8 @@ package diff import ( - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" ) // Operation defines the operation of a diff item. diff --git a/plumbing/format/diff/unified_encoder.go b/plumbing/format/diff/unified_encoder.go index fa605b198..7c811c078 100644 --- a/plumbing/format/diff/unified_encoder.go +++ b/plumbing/format/diff/unified_encoder.go @@ -7,7 +7,7 @@ import ( "strconv" "strings" - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" ) // DefaultContextLines is the default number of context lines. diff --git a/plumbing/format/diff/unified_encoder_test.go b/plumbing/format/diff/unified_encoder_test.go index 3eee333ee..6173dfc58 100644 --- a/plumbing/format/diff/unified_encoder_test.go +++ b/plumbing/format/diff/unified_encoder_test.go @@ -4,27 +4,28 @@ import ( "bytes" "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/color" - "github.com/go-git/go-git/v5/plumbing/filemode" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/color" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } - -type UnifiedEncoderTestSuite struct{} +type UnifiedEncoderTestSuite struct { + suite.Suite +} -var _ = Suite(&UnifiedEncoderTestSuite{}) +func TestUnifiedEncoderTestSuite(t *testing.T) { + suite.Run(t, new(UnifiedEncoderTestSuite)) +} -func (s *UnifiedEncoderTestSuite) TestBothFilesEmpty(c *C) { +func (s *UnifiedEncoderTestSuite) TestBothFilesEmpty() { buffer := bytes.NewBuffer(nil) e := NewUnifiedEncoder(buffer, 1) err := e.Encode(testPatch{filePatches: []testFilePatch{{}}}) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *UnifiedEncoderTestSuite) TestBinaryFile(c *C) { +func (s *UnifiedEncoderTestSuite) TestBinaryFile() { buffer := bytes.NewBuffer(nil) e := NewUnifiedEncoder(buffer, 1) p := testPatch{ @@ -44,15 +45,16 @@ func (s *UnifiedEncoderTestSuite) TestBinaryFile(c *C) { } err := e.Encode(p) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(buffer.String(), Equals, `diff --git a/binary b/binary + s.Equal(`diff --git a/binary b/binary index a459bc245bdbc45e1bca99e7fe61731da5c48da4..6879395eacf3cc7e5634064ccb617ac7aa62be7d 100644 Binary files a/binary and b/binary differ -`) +`, + buffer.String()) } -func (s *UnifiedEncoderTestSuite) TestCustomSrcDstPrefix(c *C) { +func (s *UnifiedEncoderTestSuite) TestCustomSrcDstPrefix() { buffer := bytes.NewBuffer(nil) e := NewUnifiedEncoder(buffer, 1).SetSrcPrefix("source/prefix/").SetDstPrefix("dest/prefix/") p := testPatch{ @@ -72,25 +74,26 @@ func (s *UnifiedEncoderTestSuite) TestCustomSrcDstPrefix(c *C) { } err := e.Encode(p) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(buffer.String(), Equals, `diff --git source/prefix/binary dest/prefix/binary + s.Equal(`diff --git source/prefix/binary dest/prefix/binary index a459bc245bdbc45e1bca99e7fe61731da5c48da4..6879395eacf3cc7e5634064ccb617ac7aa62be7d 100644 Binary files source/prefix/binary and dest/prefix/binary differ -`) +`, + buffer.String()) } -func (s *UnifiedEncoderTestSuite) TestEncode(c *C) { +func (s *UnifiedEncoderTestSuite) TestEncode() { for _, f := range fixtures { - c.Log("executing: ", f.desc) + s.T().Log("executing: ", f.desc) buffer := bytes.NewBuffer(nil) e := NewUnifiedEncoder(buffer, f.context).SetColor(f.color) err := e.Encode(f.patch) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(buffer.String(), Equals, f.diff) + s.Equal(f.diff, buffer.String()) } } diff --git a/plumbing/format/gitattributes/attributes_test.go b/plumbing/format/gitattributes/attributes_test.go index aea70bae9..857447242 100644 --- a/plumbing/format/gitattributes/attributes_test.go +++ b/plumbing/format/gitattributes/attributes_test.go @@ -2,15 +2,20 @@ package gitattributes import ( "strings" + "testing" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) -type AttributesSuite struct{} +type AttributesSuite struct { + suite.Suite +} -var _ = Suite(&AttributesSuite{}) +func TestAttributesSuite(t *testing.T) { + suite.Run(t, new(AttributesSuite)) +} -func (s *AttributesSuite) TestAttributes_ReadAttributes(c *C) { +func (s *AttributesSuite) TestAttributes_ReadAttributes() { lines := []string{ "[attr]sub -a", "[attr]add a", @@ -19,49 +24,49 @@ func (s *AttributesSuite) TestAttributes_ReadAttributes(c *C) { } mas, err := ReadAttributes(strings.NewReader(strings.Join(lines, "\n")), nil, true) - c.Assert(err, IsNil) - c.Assert(len(mas), Equals, 4) + s.NoError(err) + s.Len(mas, 4) - c.Assert(mas[0].Name, Equals, "sub") - c.Assert(mas[0].Pattern, IsNil) - c.Assert(mas[0].Attributes[0].IsUnset(), Equals, true) + s.Equal("sub", mas[0].Name) + s.Nil(mas[0].Pattern) + s.True(mas[0].Attributes[0].IsUnset()) - c.Assert(mas[1].Name, Equals, "add") - c.Assert(mas[1].Pattern, IsNil) - c.Assert(mas[1].Attributes[0].IsSet(), Equals, true) + s.Equal("add", mas[1].Name) + s.Nil(mas[1].Pattern) + s.True(mas[1].Attributes[0].IsSet()) - c.Assert(mas[2].Name, Equals, "*") - c.Assert(mas[2].Pattern, NotNil) - c.Assert(mas[2].Attributes[0].IsSet(), Equals, true) + s.Equal("*", mas[2].Name) + s.NotNil(mas[2].Pattern) + s.True(mas[2].Attributes[0].IsSet()) - c.Assert(mas[3].Name, Equals, "*") - c.Assert(mas[3].Pattern, NotNil) - c.Assert(mas[3].Attributes[0].IsUnspecified(), Equals, true) - c.Assert(mas[3].Attributes[1].IsValueSet(), Equals, true) - c.Assert(mas[3].Attributes[1].Value(), Equals, "bar") - c.Assert(mas[3].Attributes[2].IsUnset(), Equals, true) - c.Assert(mas[3].Attributes[3].IsSet(), Equals, true) - c.Assert(mas[3].Attributes[0].String(), Equals, "a: unspecified") - c.Assert(mas[3].Attributes[1].String(), Equals, "foo: bar") - c.Assert(mas[3].Attributes[2].String(), Equals, "b: unset") - c.Assert(mas[3].Attributes[3].String(), Equals, "c: set") + s.Equal("*", mas[3].Name) + s.NotNil(mas[3].Pattern) + s.True(mas[3].Attributes[0].IsUnspecified()) + s.True(mas[3].Attributes[1].IsValueSet()) + s.Equal("bar", mas[3].Attributes[1].Value()) + s.True(mas[3].Attributes[2].IsUnset()) + s.True(mas[3].Attributes[3].IsSet()) + s.Equal("a: unspecified", mas[3].Attributes[0].String()) + s.Equal("foo: bar", mas[3].Attributes[1].String()) + s.Equal("b: unset", mas[3].Attributes[2].String()) + s.Equal("c: set", mas[3].Attributes[3].String()) } -func (s *AttributesSuite) TestAttributes_ReadAttributesDisallowMacro(c *C) { +func (s *AttributesSuite) TestAttributes_ReadAttributesDisallowMacro() { lines := []string{ "[attr]sub -a", "* a add", } _, err := ReadAttributes(strings.NewReader(strings.Join(lines, "\n")), nil, false) - c.Assert(err, Equals, ErrMacroNotAllowed) + s.ErrorIs(err, ErrMacroNotAllowed) } -func (s *AttributesSuite) TestAttributes_ReadAttributesInvalidName(c *C) { +func (s *AttributesSuite) TestAttributes_ReadAttributesInvalidName() { lines := []string{ "[attr]foo!bar -a", } _, err := ReadAttributes(strings.NewReader(strings.Join(lines, "\n")), nil, true) - c.Assert(err, Equals, ErrInvalidAttributeName) + s.ErrorIs(err, ErrInvalidAttributeName) } diff --git a/plumbing/format/gitattributes/dir.go b/plumbing/format/gitattributes/dir.go index 42381965c..779476ab1 100644 --- a/plumbing/format/gitattributes/dir.go +++ b/plumbing/format/gitattributes/dir.go @@ -7,8 +7,8 @@ import ( "github.com/go-git/go-billy/v5" - "github.com/go-git/go-git/v5/plumbing/format/config" - gioutil "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/plumbing/format/config" + gioutil "github.com/jesseduffield/go-git/v5/utils/ioutil" ) const ( diff --git a/plumbing/format/gitattributes/dir_test.go b/plumbing/format/gitattributes/dir_test.go index 1b9a20df5..af94f7d4a 100644 --- a/plumbing/format/gitattributes/dir_test.go +++ b/plumbing/format/gitattributes/dir_test.go @@ -3,13 +3,15 @@ package gitattributes import ( "os" "strconv" + "testing" "github.com/go-git/go-billy/v5" "github.com/go-git/go-billy/v5/memfs" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) type MatcherSuite struct { + suite.Suite GFS billy.Filesystem // git repository root RFS billy.Filesystem // root that contains user home MCFS billy.Filesystem // root that contains user home, but missing ~/.gitattributes @@ -19,42 +21,44 @@ type MatcherSuite struct { SFS billy.Filesystem // root that contains /etc/gitattributes } -var _ = Suite(&MatcherSuite{}) +func TestMatcherSuite(t *testing.T) { + suite.Run(t, new(MatcherSuite)) +} -func (s *MatcherSuite) SetUpTest(c *C) { +func (s *MatcherSuite) SetupTest() { home, err := os.UserHomeDir() - c.Assert(err, IsNil) + s.NoError(err) gitAttributesGlobal := func(fs billy.Filesystem, filename string) { f, err := fs.Create(filename) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("# IntelliJ\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte(".idea/** text\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("*.iml -text\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) } // setup generic git repository root fs := memfs.New() f, err := fs.Create(".gitattributes") - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("vendor/g*/** foo=bar\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) err = fs.MkdirAll("vendor", os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create("vendor/.gitattributes") - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("github.com/** -foo\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) fs.MkdirAll("another", os.ModePerm) fs.MkdirAll("vendor/github.com", os.ModePerm) @@ -66,16 +70,16 @@ func (s *MatcherSuite) SetUpTest(c *C) { fs = memfs.New() err = fs.MkdirAll(home, os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create(fs.Join(home, gitconfigFile)) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("[core]\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte(" attributesfile = " + strconv.Quote(fs.Join(home, ".gitattributes_global")) + "\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) gitAttributesGlobal(fs, fs.Join(home, ".gitattributes_global")) @@ -90,14 +94,14 @@ func (s *MatcherSuite) SetUpTest(c *C) { // setup root that contains user home, but missing attributesfile entry fs = memfs.New() err = fs.MkdirAll(home, os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create(fs.Join(home, gitconfigFile)) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("[core]\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) gitAttributesGlobal(fs, fs.Join(home, ".gitattributes_global")) @@ -106,92 +110,92 @@ func (s *MatcherSuite) SetUpTest(c *C) { // setup root that contains user home, but missing .gitattributes fs = memfs.New() err = fs.MkdirAll(home, os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create(fs.Join(home, gitconfigFile)) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("[core]\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte(" attributesfile = " + strconv.Quote(fs.Join(home, ".gitattributes_global")) + "\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) s.MIFS = fs // setup root that contains user home fs = memfs.New() err = fs.MkdirAll("etc", os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create(systemFile) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("[core]\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte(" attributesfile = /etc/gitattributes_global\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) gitAttributesGlobal(fs, "/etc/gitattributes_global") s.SFS = fs } -func (s *MatcherSuite) TestDir_ReadPatterns(c *C) { +func (s *MatcherSuite) TestDir_ReadPatterns() { ps, err := ReadPatterns(s.GFS, nil) - c.Assert(err, IsNil) - c.Assert(ps, HasLen, 2) + s.NoError(err) + s.Len(ps, 2) m := NewMatcher(ps) results, _ := m.Match([]string{"vendor", "gopkg.in", "file"}, nil) - c.Assert(results["foo"].Value(), Equals, "bar") + s.Equal("bar", results["foo"].Value()) results, _ = m.Match([]string{"vendor", "github.com", "file"}, nil) - c.Assert(results["foo"].IsUnset(), Equals, false) + s.False(results["foo"].IsUnset()) } -func (s *MatcherSuite) TestDir_LoadGlobalPatterns(c *C) { +func (s *MatcherSuite) TestDir_LoadGlobalPatterns() { ps, err := LoadGlobalPatterns(s.RFS) - c.Assert(err, IsNil) - c.Assert(ps, HasLen, 2) + s.NoError(err) + s.Len(ps, 2) m := NewMatcher(ps) results, _ := m.Match([]string{"go-git.v4.iml"}, nil) - c.Assert(results["text"].IsUnset(), Equals, true) + s.True(results["text"].IsUnset()) results, _ = m.Match([]string{".idea", "file"}, nil) - c.Assert(results["text"].IsSet(), Equals, true) + s.True(results["text"].IsSet()) } -func (s *MatcherSuite) TestDir_LoadGlobalPatternsMissingGitconfig(c *C) { +func (s *MatcherSuite) TestDir_LoadGlobalPatternsMissingGitconfig() { ps, err := LoadGlobalPatterns(s.MCFS) - c.Assert(err, IsNil) - c.Assert(ps, HasLen, 0) + s.NoError(err) + s.Len(ps, 0) } -func (s *MatcherSuite) TestDir_LoadGlobalPatternsMissingAttributesfile(c *C) { +func (s *MatcherSuite) TestDir_LoadGlobalPatternsMissingAttributesfile() { ps, err := LoadGlobalPatterns(s.MEFS) - c.Assert(err, IsNil) - c.Assert(ps, HasLen, 0) + s.NoError(err) + s.Len(ps, 0) } -func (s *MatcherSuite) TestDir_LoadGlobalPatternsMissingGitattributes(c *C) { +func (s *MatcherSuite) TestDir_LoadGlobalPatternsMissingGitattributes() { ps, err := LoadGlobalPatterns(s.MIFS) - c.Assert(err, IsNil) - c.Assert(ps, HasLen, 0) + s.NoError(err) + s.Len(ps, 0) } -func (s *MatcherSuite) TestDir_LoadSystemPatterns(c *C) { +func (s *MatcherSuite) TestDir_LoadSystemPatterns() { ps, err := LoadSystemPatterns(s.SFS) - c.Assert(err, IsNil) - c.Assert(ps, HasLen, 2) + s.NoError(err) + s.Len(ps, 2) m := NewMatcher(ps) results, _ := m.Match([]string{"go-git.v4.iml"}, nil) - c.Assert(results["text"].IsUnset(), Equals, true) + s.True(results["text"].IsUnset()) results, _ = m.Match([]string{".idea", "file"}, nil) - c.Assert(results["text"].IsSet(), Equals, true) + s.True(results["text"].IsSet()) } diff --git a/plumbing/format/gitattributes/matcher_test.go b/plumbing/format/gitattributes/matcher_test.go index edb71a152..4c6ba55e6 100644 --- a/plumbing/format/gitattributes/matcher_test.go +++ b/plumbing/format/gitattributes/matcher_test.go @@ -2,11 +2,9 @@ package gitattributes import ( "strings" - - . "gopkg.in/check.v1" ) -func (s *MatcherSuite) TestMatcher_Match(c *C) { +func (s *MatcherSuite) TestMatcher_Match() { lines := []string{ "[attr]binary -diff -merge -text", "**/middle/v[uo]l?ano binary text eol=crlf", @@ -15,15 +13,15 @@ func (s *MatcherSuite) TestMatcher_Match(c *C) { } ma, err := ReadAttributes(strings.NewReader(strings.Join(lines, "\n")), nil, true) - c.Assert(err, IsNil) + s.NoError(err) m := NewMatcher(ma) results, matched := m.Match([]string{"head", "middle", "vulkano"}, nil) - c.Assert(matched, Equals, true) - c.Assert(results["binary"].IsSet(), Equals, true) - c.Assert(results["diff"].IsUnset(), Equals, true) - c.Assert(results["merge"].IsUnset(), Equals, true) - c.Assert(results["text"].IsSet(), Equals, true) - c.Assert(results["eol"].Value(), Equals, "crlf") + s.True(matched) + s.True(results["binary"].IsSet()) + s.True(results["diff"].IsUnset()) + s.True(results["merge"].IsUnset()) + s.True(results["text"].IsSet()) + s.Equal("crlf", results["eol"].Value()) } diff --git a/plumbing/format/gitattributes/pattern_test.go b/plumbing/format/gitattributes/pattern_test.go index 981d56f56..ad5ba8384 100644 --- a/plumbing/format/gitattributes/pattern_test.go +++ b/plumbing/format/gitattributes/pattern_test.go @@ -3,233 +3,235 @@ package gitattributes import ( "testing" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } - -type PatternSuite struct{} +type PatternSuite struct { + suite.Suite +} -var _ = Suite(&PatternSuite{}) +func TestPatternSuite(t *testing.T) { + suite.Run(t, new(PatternSuite)) +} -func (s *PatternSuite) TestMatch_domainLonger_mismatch(c *C) { +func (s *PatternSuite) TestMatch_domainLonger_mismatch() { p := ParsePattern("value", []string{"head", "middle", "tail"}) r := p.Match([]string{"head", "middle"}) - c.Assert(r, Equals, false) + s.False(r) } -func (s *PatternSuite) TestMatch_domainSameLength_mismatch(c *C) { +func (s *PatternSuite) TestMatch_domainSameLength_mismatch() { p := ParsePattern("value", []string{"head", "middle", "tail"}) r := p.Match([]string{"head", "middle", "tail"}) - c.Assert(r, Equals, false) + s.False(r) } -func (s *PatternSuite) TestMatch_domainMismatch_mismatch(c *C) { +func (s *PatternSuite) TestMatch_domainMismatch_mismatch() { p := ParsePattern("value", []string{"head", "middle", "tail"}) r := p.Match([]string{"head", "middle", "_tail_", "value"}) - c.Assert(r, Equals, false) + s.False(r) } -func (s *PatternSuite) TestSimpleMatch_match(c *C) { +func (s *PatternSuite) TestSimpleMatch_match() { p := ParsePattern("vul?ano", nil) r := p.Match([]string{"value", "vulkano"}) - c.Assert(r, Equals, true) + s.True(r) } -func (s *PatternSuite) TestSimpleMatch_withDomain(c *C) { +func (s *PatternSuite) TestSimpleMatch_withDomain() { p := ParsePattern("middle/tail", []string{"value", "volcano"}) r := p.Match([]string{"value", "volcano", "middle", "tail"}) - c.Assert(r, Equals, true) + s.True(r) } -func (s *PatternSuite) TestSimpleMatch_onlyMatchInDomain_mismatch(c *C) { +func (s *PatternSuite) TestSimpleMatch_onlyMatchInDomain_mismatch() { p := ParsePattern("value/volcano", []string{"value", "volcano"}) r := p.Match([]string{"value", "volcano", "tail"}) - c.Assert(r, Equals, false) + s.False(r) } -func (s *PatternSuite) TestSimpleMatch_atStart(c *C) { +func (s *PatternSuite) TestSimpleMatch_atStart() { p := ParsePattern("value", nil) r := p.Match([]string{"value", "tail"}) - c.Assert(r, Equals, false) + s.False(r) } -func (s *PatternSuite) TestSimpleMatch_inTheMiddle(c *C) { +func (s *PatternSuite) TestSimpleMatch_inTheMiddle() { p := ParsePattern("value", nil) r := p.Match([]string{"head", "value", "tail"}) - c.Assert(r, Equals, false) + s.False(r) } -func (s *PatternSuite) TestSimpleMatch_atEnd(c *C) { +func (s *PatternSuite) TestSimpleMatch_atEnd() { p := ParsePattern("value", nil) r := p.Match([]string{"head", "value"}) - c.Assert(r, Equals, true) + s.True(r) } -func (s *PatternSuite) TestSimpleMatch_mismatch(c *C) { +func (s *PatternSuite) TestSimpleMatch_mismatch() { p := ParsePattern("value", nil) r := p.Match([]string{"head", "val", "tail"}) - c.Assert(r, Equals, false) + s.False(r) } -func (s *PatternSuite) TestSimpleMatch_valueLonger_mismatch(c *C) { +func (s *PatternSuite) TestSimpleMatch_valueLonger_mismatch() { p := ParsePattern("tai", nil) r := p.Match([]string{"head", "value", "tail"}) - c.Assert(r, Equals, false) + s.False(r) } -func (s *PatternSuite) TestSimpleMatch_withAsterisk(c *C) { +func (s *PatternSuite) TestSimpleMatch_withAsterisk() { p := ParsePattern("t*l", nil) r := p.Match([]string{"value", "vulkano", "tail"}) - c.Assert(r, Equals, true) + s.True(r) } -func (s *PatternSuite) TestSimpleMatch_withQuestionMark(c *C) { +func (s *PatternSuite) TestSimpleMatch_withQuestionMark() { p := ParsePattern("ta?l", nil) r := p.Match([]string{"value", "vulkano", "tail"}) - c.Assert(r, Equals, true) + s.True(r) } -func (s *PatternSuite) TestSimpleMatch_magicChars(c *C) { +func (s *PatternSuite) TestSimpleMatch_magicChars() { p := ParsePattern("v[ou]l[kc]ano", nil) r := p.Match([]string{"value", "volcano"}) - c.Assert(r, Equals, true) + s.True(r) } -func (s *PatternSuite) TestSimpleMatch_wrongPattern_mismatch(c *C) { +func (s *PatternSuite) TestSimpleMatch_wrongPattern_mismatch() { p := ParsePattern("v[ou]l[", nil) r := p.Match([]string{"value", "vol["}) - c.Assert(r, Equals, false) + s.False(r) } -func (s *PatternSuite) TestGlobMatch_fromRootWithSlash(c *C) { +func (s *PatternSuite) TestGlobMatch_fromRootWithSlash() { p := ParsePattern("/value/vul?ano/tail", nil) r := p.Match([]string{"value", "vulkano", "tail"}) - c.Assert(r, Equals, true) + s.True(r) } -func (s *PatternSuite) TestGlobMatch_withDomain(c *C) { +func (s *PatternSuite) TestGlobMatch_withDomain() { p := ParsePattern("middle/tail", []string{"value", "volcano"}) r := p.Match([]string{"value", "volcano", "middle", "tail"}) - c.Assert(r, Equals, true) + s.True(r) } -func (s *PatternSuite) TestGlobMatch_onlyMatchInDomain_mismatch(c *C) { +func (s *PatternSuite) TestGlobMatch_onlyMatchInDomain_mismatch() { p := ParsePattern("volcano/tail", []string{"value", "volcano"}) r := p.Match([]string{"value", "volcano", "tail"}) - c.Assert(r, Equals, false) + s.False(r) } -func (s *PatternSuite) TestGlobMatch_fromRootWithoutSlash(c *C) { +func (s *PatternSuite) TestGlobMatch_fromRootWithoutSlash() { p := ParsePattern("value/vul?ano/tail", nil) r := p.Match([]string{"value", "vulkano", "tail"}) - c.Assert(r, Equals, true) + s.True(r) } -func (s *PatternSuite) TestGlobMatch_fromRoot_mismatch(c *C) { +func (s *PatternSuite) TestGlobMatch_fromRoot_mismatch() { p := ParsePattern("value/vulkano", nil) r := p.Match([]string{"value", "volcano"}) - c.Assert(r, Equals, false) + s.False(r) } -func (s *PatternSuite) TestGlobMatch_fromRoot_tooShort_mismatch(c *C) { +func (s *PatternSuite) TestGlobMatch_fromRoot_tooShort_mismatch() { p := ParsePattern("value/vul?ano", nil) r := p.Match([]string{"value"}) - c.Assert(r, Equals, false) + s.False(r) } -func (s *PatternSuite) TestGlobMatch_fromRoot_notAtRoot_mismatch(c *C) { +func (s *PatternSuite) TestGlobMatch_fromRoot_notAtRoot_mismatch() { p := ParsePattern("/value/volcano", nil) r := p.Match([]string{"value", "value", "volcano"}) - c.Assert(r, Equals, false) + s.False(r) } -func (s *PatternSuite) TestGlobMatch_leadingAsterisks_atStart(c *C) { +func (s *PatternSuite) TestGlobMatch_leadingAsterisks_atStart() { p := ParsePattern("**/*lue/vol?ano/ta?l", nil) r := p.Match([]string{"value", "volcano", "tail"}) - c.Assert(r, Equals, true) + s.True(r) } -func (s *PatternSuite) TestGlobMatch_leadingAsterisks_notAtStart(c *C) { +func (s *PatternSuite) TestGlobMatch_leadingAsterisks_notAtStart() { p := ParsePattern("**/*lue/vol?ano/tail", nil) r := p.Match([]string{"head", "value", "volcano", "tail"}) - c.Assert(r, Equals, true) + s.True(r) } -func (s *PatternSuite) TestGlobMatch_leadingAsterisks_mismatch(c *C) { +func (s *PatternSuite) TestGlobMatch_leadingAsterisks_mismatch() { p := ParsePattern("**/*lue/vol?ano/tail", nil) r := p.Match([]string{"head", "value", "Volcano", "tail"}) - c.Assert(r, Equals, false) + s.False(r) } -func (s *PatternSuite) TestGlobMatch_tailingAsterisks(c *C) { +func (s *PatternSuite) TestGlobMatch_tailingAsterisks() { p := ParsePattern("/*lue/vol?ano/**", nil) r := p.Match([]string{"value", "volcano", "tail", "moretail"}) - c.Assert(r, Equals, true) + s.True(r) } -func (s *PatternSuite) TestGlobMatch_tailingAsterisks_single(c *C) { +func (s *PatternSuite) TestGlobMatch_tailingAsterisks_single() { p := ParsePattern("/*lue/**", nil) r := p.Match([]string{"value", "volcano"}) - c.Assert(r, Equals, true) + s.True(r) } -func (s *PatternSuite) TestGlobMatch_tailingAsterisk_single(c *C) { +func (s *PatternSuite) TestGlobMatch_tailingAsterisk_single() { p := ParsePattern("/*lue/*", nil) r := p.Match([]string{"value", "volcano", "tail"}) - c.Assert(r, Equals, false) + s.False(r) } -func (s *PatternSuite) TestGlobMatch_tailingAsterisks_exactMatch(c *C) { +func (s *PatternSuite) TestGlobMatch_tailingAsterisks_exactMatch() { p := ParsePattern("/*lue/vol?ano/**", nil) r := p.Match([]string{"value", "volcano"}) - c.Assert(r, Equals, false) + s.False(r) } -func (s *PatternSuite) TestGlobMatch_middleAsterisks_emptyMatch(c *C) { +func (s *PatternSuite) TestGlobMatch_middleAsterisks_emptyMatch() { p := ParsePattern("/*lue/**/vol?ano", nil) r := p.Match([]string{"value", "volcano"}) - c.Assert(r, Equals, true) + s.True(r) } -func (s *PatternSuite) TestGlobMatch_middleAsterisks_oneMatch(c *C) { +func (s *PatternSuite) TestGlobMatch_middleAsterisks_oneMatch() { p := ParsePattern("/*lue/**/vol?ano", nil) r := p.Match([]string{"value", "middle", "volcano"}) - c.Assert(r, Equals, true) + s.True(r) } -func (s *PatternSuite) TestGlobMatch_middleAsterisks_multiMatch(c *C) { +func (s *PatternSuite) TestGlobMatch_middleAsterisks_multiMatch() { p := ParsePattern("/*lue/**/vol?ano", nil) r := p.Match([]string{"value", "middle1", "middle2", "volcano"}) - c.Assert(r, Equals, true) + s.True(r) } -func (s *PatternSuite) TestGlobMatch_wrongDoubleAsterisk_mismatch(c *C) { +func (s *PatternSuite) TestGlobMatch_wrongDoubleAsterisk_mismatch() { p := ParsePattern("/*lue/**foo/vol?ano/tail", nil) r := p.Match([]string{"value", "foo", "volcano", "tail"}) - c.Assert(r, Equals, false) + s.False(r) } -func (s *PatternSuite) TestGlobMatch_magicChars(c *C) { +func (s *PatternSuite) TestGlobMatch_magicChars() { p := ParsePattern("**/head/v[ou]l[kc]ano", nil) r := p.Match([]string{"value", "head", "volcano"}) - c.Assert(r, Equals, true) + s.True(r) } -func (s *PatternSuite) TestGlobMatch_wrongPattern_noTraversal_mismatch(c *C) { +func (s *PatternSuite) TestGlobMatch_wrongPattern_noTraversal_mismatch() { p := ParsePattern("**/head/v[ou]l[", nil) r := p.Match([]string{"value", "head", "vol["}) - c.Assert(r, Equals, false) + s.False(r) } -func (s *PatternSuite) TestGlobMatch_wrongPattern_onTraversal_mismatch(c *C) { +func (s *PatternSuite) TestGlobMatch_wrongPattern_onTraversal_mismatch() { p := ParsePattern("/value/**/v[ou]l[", nil) r := p.Match([]string{"value", "head", "vol["}) - c.Assert(r, Equals, false) + s.False(r) } -func (s *PatternSuite) TestGlobMatch_issue_923(c *C) { +func (s *PatternSuite) TestGlobMatch_issue_923() { p := ParsePattern("**/android/**/GeneratedPluginRegistrant.java", nil) r := p.Match([]string{"packages", "flutter_tools", "lib", "src", "android", "gradle.dart"}) - c.Assert(r, Equals, false) + s.False(r) } diff --git a/plumbing/format/gitignore/dir.go b/plumbing/format/gitignore/dir.go index 92df5a3de..af511d12f 100644 --- a/plumbing/format/gitignore/dir.go +++ b/plumbing/format/gitignore/dir.go @@ -8,9 +8,9 @@ import ( "strings" "github.com/go-git/go-billy/v5" - "github.com/go-git/go-git/v5/internal/path_util" - "github.com/go-git/go-git/v5/plumbing/format/config" - gioutil "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/internal/path_util" + "github.com/jesseduffield/go-git/v5/plumbing/format/config" + gioutil "github.com/jesseduffield/go-git/v5/utils/ioutil" ) const ( diff --git a/plumbing/format/gitignore/dir_test.go b/plumbing/format/gitignore/dir_test.go index ba8ad806e..4d1e452d5 100644 --- a/plumbing/format/gitignore/dir_test.go +++ b/plumbing/format/gitignore/dir_test.go @@ -5,13 +5,15 @@ import ( "os/user" "strconv" "strings" + "testing" "github.com/go-git/go-billy/v5" "github.com/go-git/go-billy/v5/memfs" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) type MatcherSuite struct { + suite.Suite GFS billy.Filesystem // git repository root RFS billy.Filesystem // root that contains user home RFSR billy.Filesystem // root that contains user home, but with relative ~/.gitignore_global @@ -23,332 +25,334 @@ type MatcherSuite struct { SFS billy.Filesystem // root that contains /etc/gitconfig } -var _ = Suite(&MatcherSuite{}) +func TestMatcherSuite(t *testing.T) { + suite.Run(t, new(MatcherSuite)) +} -func (s *MatcherSuite) SetUpTest(c *C) { +func (s *MatcherSuite) SetupTest() { // setup generic git repository root fs := memfs.New() err := fs.MkdirAll(".git/info", os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) f, err := fs.Create(".git/info/exclude") - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("exclude.crlf\r\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create(".gitignore") - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("vendor/g*/\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("ignore.crlf\r\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("ignore_dir\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) err = fs.MkdirAll("vendor", os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create("vendor/.gitignore") - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("!github.com/\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) err = fs.MkdirAll("ignore_dir", os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create("ignore_dir/.gitignore") - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("!file\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = fs.Create("ignore_dir/file") - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) err = fs.MkdirAll("another", os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) err = fs.MkdirAll("exclude.crlf", os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) err = fs.MkdirAll("ignore.crlf", os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) err = fs.MkdirAll("vendor/github.com", os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) err = fs.MkdirAll("vendor/gopkg.in", os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) err = fs.MkdirAll("multiple/sub/ignores/first", os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) err = fs.MkdirAll("multiple/sub/ignores/second", os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create("multiple/sub/ignores/first/.gitignore") - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("ignore_dir\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create("multiple/sub/ignores/second/.gitignore") - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("ignore_dir\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) err = fs.MkdirAll("multiple/sub/ignores/first/ignore_dir", os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) err = fs.MkdirAll("multiple/sub/ignores/second/ignore_dir", os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) s.GFS = fs // setup root that contains user home home, err := os.UserHomeDir() - c.Assert(err, IsNil) + s.NoError(err) fs = memfs.New() err = fs.MkdirAll(home, os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create(fs.Join(home, gitconfigFile)) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("[core]\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte(" excludesfile = " + strconv.Quote(fs.Join(home, ".gitignore_global")) + "\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create(fs.Join(home, ".gitignore_global")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("# IntelliJ\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte(".idea/\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("*.iml\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) s.RFS = fs // root that contains user home, but with relative ~/.gitignore_global fs = memfs.New() err = fs.MkdirAll(home, os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create(fs.Join(home, gitconfigFile)) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("[core]\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte(" excludesfile = ~/.gitignore_global" + "\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create(fs.Join(home, ".gitignore_global")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("# IntelliJ\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte(".idea/\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("*.iml\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) s.RFSR = fs // root that contains user home, but with relative ~user/.gitignore_global fs = memfs.New() err = fs.MkdirAll(home, os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create(fs.Join(home, gitconfigFile)) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("[core]\n")) - c.Assert(err, IsNil) + s.NoError(err) currentUser, err := user.Current() - c.Assert(err, IsNil) + s.NoError(err) // remove domain for windows username := currentUser.Username[strings.Index(currentUser.Username, "\\")+1:] _, err = f.Write([]byte(" excludesfile = ~" + username + "/.gitignore_global" + "\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create(fs.Join(home, ".gitignore_global")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("# IntelliJ\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte(".idea/\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("*.iml\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) s.RFSU = fs // root that contains user home, but missing ~/.gitconfig fs = memfs.New() err = fs.MkdirAll(home, os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create(fs.Join(home, ".gitignore_global")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("# IntelliJ\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte(".idea/\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("*.iml\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) s.MCFS = fs // setup root that contains user home, but missing excludesfile entry fs = memfs.New() err = fs.MkdirAll(home, os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create(fs.Join(home, gitconfigFile)) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("[core]\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create(fs.Join(home, ".gitignore_global")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("# IntelliJ\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte(".idea/\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("*.iml\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) s.MEFS = fs // setup root that contains user home, but missing .gitnignore fs = memfs.New() err = fs.MkdirAll(home, os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create(fs.Join(home, gitconfigFile)) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("[core]\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte(" excludesfile = " + strconv.Quote(fs.Join(home, ".gitignore_global")) + "\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) s.MIFS = fs // setup root that contains user home fs = memfs.New() err = fs.MkdirAll("etc", os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create(systemFile) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("[core]\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte(" excludesfile = /etc/gitignore_global\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) f, err = fs.Create("/etc/gitignore_global") - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("# IntelliJ\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte(".idea/\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("*.iml\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) s.SFS = fs } -func (s *MatcherSuite) TestDir_ReadPatterns(c *C) { +func (s *MatcherSuite) TestDir_ReadPatterns() { checkPatterns := func(ps []Pattern) { - c.Assert(ps, HasLen, 7) + s.Len(ps, 7) m := NewMatcher(ps) - c.Assert(m.Match([]string{"exclude.crlf"}, true), Equals, true) - c.Assert(m.Match([]string{"ignore.crlf"}, true), Equals, true) - c.Assert(m.Match([]string{"vendor", "gopkg.in"}, true), Equals, true) - c.Assert(m.Match([]string{"ignore_dir", "file"}, false), Equals, true) - c.Assert(m.Match([]string{"vendor", "github.com"}, true), Equals, false) - c.Assert(m.Match([]string{"multiple", "sub", "ignores", "first", "ignore_dir"}, true), Equals, true) - c.Assert(m.Match([]string{"multiple", "sub", "ignores", "second", "ignore_dir"}, true), Equals, true) + s.True(m.Match([]string{"exclude.crlf"}, true)) + s.True(m.Match([]string{"ignore.crlf"}, true)) + s.True(m.Match([]string{"vendor", "gopkg.in"}, true)) + s.True(m.Match([]string{"ignore_dir", "file"}, false)) + s.False(m.Match([]string{"vendor", "github.com"}, true)) + s.True(m.Match([]string{"multiple", "sub", "ignores", "first", "ignore_dir"}, true)) + s.True(m.Match([]string{"multiple", "sub", "ignores", "second", "ignore_dir"}, true)) } ps, err := ReadPatterns(s.GFS, nil) - c.Assert(err, IsNil) + s.NoError(err) checkPatterns(ps) // passing an empty slice with capacity to check we don't hit a bug where the extra capacity is reused incorrectly ps, err = ReadPatterns(s.GFS, make([]string, 0, 6)) - c.Assert(err, IsNil) + s.NoError(err) checkPatterns(ps) } -func (s *MatcherSuite) TestDir_ReadRelativeGlobalGitIgnore(c *C) { +func (s *MatcherSuite) TestDir_ReadRelativeGlobalGitIgnore() { for _, fs := range []billy.Filesystem{s.RFSR, s.RFSU} { ps, err := LoadGlobalPatterns(fs) - c.Assert(err, IsNil) - c.Assert(ps, HasLen, 2) + s.NoError(err) + s.Len(ps, 2) m := NewMatcher(ps) - c.Assert(m.Match([]string{".idea/"}, true), Equals, false) - c.Assert(m.Match([]string{"*.iml"}, true), Equals, true) - c.Assert(m.Match([]string{"IntelliJ"}, true), Equals, false) + s.False(m.Match([]string{".idea/"}, true)) + s.True(m.Match([]string{"*.iml"}, true)) + s.False(m.Match([]string{"IntelliJ"}, true)) } } -func (s *MatcherSuite) TestDir_LoadGlobalPatterns(c *C) { +func (s *MatcherSuite) TestDir_LoadGlobalPatterns() { ps, err := LoadGlobalPatterns(s.RFS) - c.Assert(err, IsNil) - c.Assert(ps, HasLen, 2) + s.NoError(err) + s.Len(ps, 2) m := NewMatcher(ps) - c.Assert(m.Match([]string{"go-git.v4.iml"}, true), Equals, true) - c.Assert(m.Match([]string{".idea"}, true), Equals, true) + s.True(m.Match([]string{"go-git.v4.iml"}, true)) + s.True(m.Match([]string{".idea"}, true)) } -func (s *MatcherSuite) TestDir_LoadGlobalPatternsMissingGitconfig(c *C) { +func (s *MatcherSuite) TestDir_LoadGlobalPatternsMissingGitconfig() { ps, err := LoadGlobalPatterns(s.MCFS) - c.Assert(err, IsNil) - c.Assert(ps, HasLen, 0) + s.NoError(err) + s.Len(ps, 0) } -func (s *MatcherSuite) TestDir_LoadGlobalPatternsMissingExcludesfile(c *C) { +func (s *MatcherSuite) TestDir_LoadGlobalPatternsMissingExcludesfile() { ps, err := LoadGlobalPatterns(s.MEFS) - c.Assert(err, IsNil) - c.Assert(ps, HasLen, 0) + s.NoError(err) + s.Len(ps, 0) } -func (s *MatcherSuite) TestDir_LoadGlobalPatternsMissingGitignore(c *C) { +func (s *MatcherSuite) TestDir_LoadGlobalPatternsMissingGitignore() { ps, err := LoadGlobalPatterns(s.MIFS) - c.Assert(err, IsNil) - c.Assert(ps, HasLen, 0) + s.NoError(err) + s.Len(ps, 0) } -func (s *MatcherSuite) TestDir_LoadSystemPatterns(c *C) { +func (s *MatcherSuite) TestDir_LoadSystemPatterns() { ps, err := LoadSystemPatterns(s.SFS) - c.Assert(err, IsNil) - c.Assert(ps, HasLen, 2) + s.NoError(err) + s.Len(ps, 2) m := NewMatcher(ps) - c.Assert(m.Match([]string{"go-git.v4.iml"}, true), Equals, true) - c.Assert(m.Match([]string{".idea"}, true), Equals, true) + s.True(m.Match([]string{"go-git.v4.iml"}, true)) + s.True(m.Match([]string{".idea"}, true)) } diff --git a/plumbing/format/gitignore/matcher_test.go b/plumbing/format/gitignore/matcher_test.go index 731104256..d3bfbcb64 100644 --- a/plumbing/format/gitignore/matcher_test.go +++ b/plumbing/format/gitignore/matcher_test.go @@ -1,16 +1,12 @@ package gitignore -import ( - . "gopkg.in/check.v1" -) - -func (s *MatcherSuite) TestMatcher_Match(c *C) { +func (s *MatcherSuite) TestMatcher_Match() { ps := []Pattern{ ParsePattern("**/middle/v[uo]l?ano", nil), ParsePattern("!volcano", nil), } m := NewMatcher(ps) - c.Assert(m.Match([]string{"head", "middle", "vulkano"}, false), Equals, true) - c.Assert(m.Match([]string{"head", "middle", "volcano"}, false), Equals, false) + s.True(m.Match([]string{"head", "middle", "vulkano"}, false)) + s.False(m.Match([]string{"head", "middle", "volcano"}, false)) } diff --git a/plumbing/format/gitignore/pattern_test.go b/plumbing/format/gitignore/pattern_test.go index c410442b6..54623c6ca 100644 --- a/plumbing/format/gitignore/pattern_test.go +++ b/plumbing/format/gitignore/pattern_test.go @@ -3,287 +3,289 @@ package gitignore import ( "testing" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } - -type PatternSuite struct{} +type PatternSuite struct { + suite.Suite +} -var _ = Suite(&PatternSuite{}) +func TestPatternSuite(t *testing.T) { + suite.Run(t, new(PatternSuite)) +} -func (s *PatternSuite) TestSimpleMatch_inclusion(c *C) { +func (s *PatternSuite) TestSimpleMatch_inclusion() { p := ParsePattern("!vul?ano", nil) r := p.Match([]string{"value", "vulkano", "tail"}, false) - c.Assert(r, Equals, Include) + s.Equal(Include, r) } -func (s *PatternSuite) TestMatch_domainLonger_mismatch(c *C) { +func (s *PatternSuite) TestMatch_domainLonger_mismatch() { p := ParsePattern("value", []string{"head", "middle", "tail"}) r := p.Match([]string{"head", "middle"}, false) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } -func (s *PatternSuite) TestMatch_domainSameLength_mismatch(c *C) { +func (s *PatternSuite) TestMatch_domainSameLength_mismatch() { p := ParsePattern("value", []string{"head", "middle", "tail"}) r := p.Match([]string{"head", "middle", "tail"}, false) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } -func (s *PatternSuite) TestMatch_domainMismatch_mismatch(c *C) { +func (s *PatternSuite) TestMatch_domainMismatch_mismatch() { p := ParsePattern("value", []string{"head", "middle", "tail"}) r := p.Match([]string{"head", "middle", "_tail_", "value"}, false) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } -func (s *PatternSuite) TestSimpleMatch_withDomain(c *C) { +func (s *PatternSuite) TestSimpleMatch_withDomain() { p := ParsePattern("middle/", []string{"value", "volcano"}) r := p.Match([]string{"value", "volcano", "middle", "tail"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestSimpleMatch_onlyMatchInDomain_mismatch(c *C) { +func (s *PatternSuite) TestSimpleMatch_onlyMatchInDomain_mismatch() { p := ParsePattern("volcano/", []string{"value", "volcano"}) r := p.Match([]string{"value", "volcano", "tail"}, true) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } -func (s *PatternSuite) TestSimpleMatch_atStart(c *C) { +func (s *PatternSuite) TestSimpleMatch_atStart() { p := ParsePattern("value", nil) r := p.Match([]string{"value", "tail"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestSimpleMatch_inTheMiddle(c *C) { +func (s *PatternSuite) TestSimpleMatch_inTheMiddle() { p := ParsePattern("value", nil) r := p.Match([]string{"head", "value", "tail"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestSimpleMatch_atEnd(c *C) { +func (s *PatternSuite) TestSimpleMatch_atEnd() { p := ParsePattern("value", nil) r := p.Match([]string{"head", "value"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestSimpleMatch_atStart_dirWanted(c *C) { +func (s *PatternSuite) TestSimpleMatch_atStart_dirWanted() { p := ParsePattern("value/", nil) r := p.Match([]string{"value", "tail"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestSimpleMatch_inTheMiddle_dirWanted(c *C) { +func (s *PatternSuite) TestSimpleMatch_inTheMiddle_dirWanted() { p := ParsePattern("value/", nil) r := p.Match([]string{"head", "value", "tail"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestSimpleMatch_atEnd_dirWanted(c *C) { +func (s *PatternSuite) TestSimpleMatch_atEnd_dirWanted() { p := ParsePattern("value/", nil) r := p.Match([]string{"head", "value"}, true) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestSimpleMatch_atEnd_dirWanted_notADir_mismatch(c *C) { +func (s *PatternSuite) TestSimpleMatch_atEnd_dirWanted_notADir_mismatch() { p := ParsePattern("value/", nil) r := p.Match([]string{"head", "value"}, false) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } -func (s *PatternSuite) TestSimpleMatch_mismatch(c *C) { +func (s *PatternSuite) TestSimpleMatch_mismatch() { p := ParsePattern("value", nil) r := p.Match([]string{"head", "val", "tail"}, false) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } -func (s *PatternSuite) TestSimpleMatch_valueLonger_mismatch(c *C) { +func (s *PatternSuite) TestSimpleMatch_valueLonger_mismatch() { p := ParsePattern("val", nil) r := p.Match([]string{"head", "value", "tail"}, false) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } -func (s *PatternSuite) TestSimpleMatch_withAsterisk(c *C) { +func (s *PatternSuite) TestSimpleMatch_withAsterisk() { p := ParsePattern("v*o", nil) r := p.Match([]string{"value", "vulkano", "tail"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestSimpleMatch_withQuestionMark(c *C) { +func (s *PatternSuite) TestSimpleMatch_withQuestionMark() { p := ParsePattern("vul?ano", nil) r := p.Match([]string{"value", "vulkano", "tail"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestSimpleMatch_magicChars(c *C) { +func (s *PatternSuite) TestSimpleMatch_magicChars() { p := ParsePattern("v[ou]l[kc]ano", nil) r := p.Match([]string{"value", "volcano"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestSimpleMatch_wrongPattern_mismatch(c *C) { +func (s *PatternSuite) TestSimpleMatch_wrongPattern_mismatch() { p := ParsePattern("v[ou]l[", nil) r := p.Match([]string{"value", "vol["}, false) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } -func (s *PatternSuite) TestGlobMatch_fromRootWithSlash(c *C) { +func (s *PatternSuite) TestGlobMatch_fromRootWithSlash() { p := ParsePattern("/value/vul?ano", nil) r := p.Match([]string{"value", "vulkano", "tail"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestGlobMatch_withDomain(c *C) { +func (s *PatternSuite) TestGlobMatch_withDomain() { p := ParsePattern("middle/tail/", []string{"value", "volcano"}) r := p.Match([]string{"value", "volcano", "middle", "tail"}, true) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestGlobMatch_onlyMatchInDomain_mismatch(c *C) { +func (s *PatternSuite) TestGlobMatch_onlyMatchInDomain_mismatch() { p := ParsePattern("volcano/tail", []string{"value", "volcano"}) r := p.Match([]string{"value", "volcano", "tail"}, false) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } -func (s *PatternSuite) TestGlobMatch_fromRootWithoutSlash(c *C) { +func (s *PatternSuite) TestGlobMatch_fromRootWithoutSlash() { p := ParsePattern("value/vul?ano", nil) r := p.Match([]string{"value", "vulkano", "tail"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestGlobMatch_fromRoot_mismatch(c *C) { +func (s *PatternSuite) TestGlobMatch_fromRoot_mismatch() { p := ParsePattern("value/vulkano", nil) r := p.Match([]string{"value", "volcano"}, false) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } -func (s *PatternSuite) TestGlobMatch_fromRoot_tooShort_mismatch(c *C) { +func (s *PatternSuite) TestGlobMatch_fromRoot_tooShort_mismatch() { p := ParsePattern("value/vul?ano", nil) r := p.Match([]string{"value"}, false) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } -func (s *PatternSuite) TestGlobMatch_fromRoot_notAtRoot_mismatch(c *C) { +func (s *PatternSuite) TestGlobMatch_fromRoot_notAtRoot_mismatch() { p := ParsePattern("/value/volcano", nil) r := p.Match([]string{"value", "value", "volcano"}, false) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } -func (s *PatternSuite) TestGlobMatch_leadingAsterisks_atStart(c *C) { +func (s *PatternSuite) TestGlobMatch_leadingAsterisks_atStart() { p := ParsePattern("**/*lue/vol?ano", nil) r := p.Match([]string{"value", "volcano", "tail"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestGlobMatch_leadingAsterisks_notAtStart(c *C) { +func (s *PatternSuite) TestGlobMatch_leadingAsterisks_notAtStart() { p := ParsePattern("**/*lue/vol?ano", nil) r := p.Match([]string{"head", "value", "volcano", "tail"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestGlobMatch_leadingAsterisks_mismatch(c *C) { +func (s *PatternSuite) TestGlobMatch_leadingAsterisks_mismatch() { p := ParsePattern("**/*lue/vol?ano", nil) r := p.Match([]string{"head", "value", "Volcano", "tail"}, false) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } -func (s *PatternSuite) TestGlobMatch_leadingAsterisks_isDir(c *C) { +func (s *PatternSuite) TestGlobMatch_leadingAsterisks_isDir() { p := ParsePattern("**/*lue/vol?ano/", nil) r := p.Match([]string{"head", "value", "volcano", "tail"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestGlobMatch_leadingAsterisks_isDirAtEnd(c *C) { +func (s *PatternSuite) TestGlobMatch_leadingAsterisks_isDirAtEnd() { p := ParsePattern("**/*lue/vol?ano/", nil) r := p.Match([]string{"head", "value", "volcano"}, true) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestGlobMatch_leadingAsterisks_isDir_mismatch(c *C) { +func (s *PatternSuite) TestGlobMatch_leadingAsterisks_isDir_mismatch() { p := ParsePattern("**/*lue/vol?ano/", nil) r := p.Match([]string{"head", "value", "Colcano"}, true) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } -func (s *PatternSuite) TestGlobMatch_leadingAsterisks_isDirNoDirAtEnd_mismatch(c *C) { +func (s *PatternSuite) TestGlobMatch_leadingAsterisks_isDirNoDirAtEnd_mismatch() { p := ParsePattern("**/*lue/vol?ano/", nil) r := p.Match([]string{"head", "value", "volcano"}, false) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } -func (s *PatternSuite) TestGlobMatch_tailingAsterisks(c *C) { +func (s *PatternSuite) TestGlobMatch_tailingAsterisks() { p := ParsePattern("/*lue/vol?ano/**", nil) r := p.Match([]string{"value", "volcano", "tail", "moretail"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestGlobMatch_tailingAsterisks_exactMatch(c *C) { +func (s *PatternSuite) TestGlobMatch_tailingAsterisks_exactMatch() { p := ParsePattern("/*lue/vol?ano/**", nil) r := p.Match([]string{"value", "volcano"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestGlobMatch_middleAsterisks_emptyMatch(c *C) { +func (s *PatternSuite) TestGlobMatch_middleAsterisks_emptyMatch() { p := ParsePattern("/*lue/**/vol?ano", nil) r := p.Match([]string{"value", "volcano"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestGlobMatch_middleAsterisks_oneMatch(c *C) { +func (s *PatternSuite) TestGlobMatch_middleAsterisks_oneMatch() { p := ParsePattern("/*lue/**/vol?ano", nil) r := p.Match([]string{"value", "middle", "volcano"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestGlobMatch_middleAsterisks_multiMatch(c *C) { +func (s *PatternSuite) TestGlobMatch_middleAsterisks_multiMatch() { p := ParsePattern("/*lue/**/vol?ano", nil) r := p.Match([]string{"value", "middle1", "middle2", "volcano"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestGlobMatch_middleAsterisks_isDir_trailing(c *C) { +func (s *PatternSuite) TestGlobMatch_middleAsterisks_isDir_trailing() { p := ParsePattern("/*lue/**/vol?ano/", nil) r := p.Match([]string{"value", "middle1", "middle2", "volcano"}, true) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestGlobMatch_middleAsterisks_isDir_trailing_mismatch(c *C) { +func (s *PatternSuite) TestGlobMatch_middleAsterisks_isDir_trailing_mismatch() { p := ParsePattern("/*lue/**/vol?ano/", nil) r := p.Match([]string{"value", "middle1", "middle2", "volcano"}, false) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } -func (s *PatternSuite) TestGlobMatch_middleAsterisks_isDir(c *C) { +func (s *PatternSuite) TestGlobMatch_middleAsterisks_isDir() { p := ParsePattern("/*lue/**/vol?ano/", nil) r := p.Match([]string{"value", "middle1", "middle2", "volcano", "tail"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestGlobMatch_wrongDoubleAsterisk_mismatch(c *C) { +func (s *PatternSuite) TestGlobMatch_wrongDoubleAsterisk_mismatch() { p := ParsePattern("/*lue/**foo/vol?ano", nil) r := p.Match([]string{"value", "foo", "volcano", "tail"}, false) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } -func (s *PatternSuite) TestGlobMatch_magicChars(c *C) { +func (s *PatternSuite) TestGlobMatch_magicChars() { p := ParsePattern("**/head/v[ou]l[kc]ano", nil) r := p.Match([]string{"value", "head", "volcano"}, false) - c.Assert(r, Equals, Exclude) + s.Equal(Exclude, r) } -func (s *PatternSuite) TestGlobMatch_wrongPattern_noTraversal_mismatch(c *C) { +func (s *PatternSuite) TestGlobMatch_wrongPattern_noTraversal_mismatch() { p := ParsePattern("**/head/v[ou]l[", nil) r := p.Match([]string{"value", "head", "vol["}, false) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } -func (s *PatternSuite) TestGlobMatch_wrongPattern_onTraversal_mismatch(c *C) { +func (s *PatternSuite) TestGlobMatch_wrongPattern_onTraversal_mismatch() { p := ParsePattern("/value/**/v[ou]l[", nil) r := p.Match([]string{"value", "head", "vol["}, false) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } -func (s *PatternSuite) TestGlobMatch_issue_923(c *C) { +func (s *PatternSuite) TestGlobMatch_issue_923() { p := ParsePattern("**/android/**/GeneratedPluginRegistrant.java", nil) r := p.Match([]string{"packages", "flutter_tools", "lib", "src", "android", "gradle.dart"}, false) - c.Assert(r, Equals, NoMatch) + s.Equal(NoMatch, r) } diff --git a/plumbing/format/idxfile/decoder.go b/plumbing/format/idxfile/decoder.go index 9afdce301..d38df328d 100644 --- a/plumbing/format/idxfile/decoder.go +++ b/plumbing/format/idxfile/decoder.go @@ -6,8 +6,8 @@ import ( "errors" "io" - "github.com/go-git/go-git/v5/plumbing/hash" - "github.com/go-git/go-git/v5/utils/binary" + "github.com/jesseduffield/go-git/v5/plumbing/hash" + "github.com/jesseduffield/go-git/v5/utils/binary" ) var ( diff --git a/plumbing/format/idxfile/decoder_test.go b/plumbing/format/idxfile/decoder_test.go index 2c4a801a7..f7562db40 100644 --- a/plumbing/format/idxfile/decoder_test.go +++ b/plumbing/format/idxfile/decoder_test.go @@ -7,57 +7,62 @@ import ( "io" "testing" - "github.com/go-git/go-git/v5/plumbing" - . "github.com/go-git/go-git/v5/plumbing/format/idxfile" + "github.com/jesseduffield/go-git/v5/plumbing" + . "github.com/jesseduffield/go-git/v5/plumbing/format/idxfile" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) -func Test(t *testing.T) { TestingT(t) } +type IdxfileFixtureSuite struct { + fixtures.Suite +} type IdxfileSuite struct { - fixtures.Suite + suite.Suite + IdxfileFixtureSuite } -var _ = Suite(&IdxfileSuite{}) +func TestIdxfileSuite(t *testing.T) { + suite.Run(t, new(IdxfileSuite)) +} -func (s *IdxfileSuite) TestDecode(c *C) { +func (s *IdxfileSuite) TestDecode() { f := fixtures.Basic().One() d := NewDecoder(f.Idx()) idx := new(MemoryIndex) err := d.Decode(idx) - c.Assert(err, IsNil) + s.NoError(err) count, _ := idx.Count() - c.Assert(count, Equals, int64(31)) + s.Equal(int64(31), count) hash := plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea") ok, err := idx.Contains(hash) - c.Assert(err, IsNil) - c.Assert(ok, Equals, true) + s.NoError(err) + s.True(ok) offset, err := idx.FindOffset(hash) - c.Assert(err, IsNil) - c.Assert(offset, Equals, int64(615)) + s.NoError(err) + s.Equal(int64(615), offset) crc32, err := idx.FindCRC32(hash) - c.Assert(err, IsNil) - c.Assert(crc32, Equals, uint32(3645019190)) + s.NoError(err) + s.Equal(uint32(3645019190), crc32) - c.Assert(fmt.Sprintf("%x", idx.IdxChecksum), Equals, "fb794f1ec720b9bc8e43257451bd99c4be6fa1c9") - c.Assert(fmt.Sprintf("%x", idx.PackfileChecksum), Equals, f.PackfileHash) + s.Equal("fb794f1ec720b9bc8e43257451bd99c4be6fa1c9", fmt.Sprintf("%x", idx.IdxChecksum)) + s.Equal(f.PackfileHash, fmt.Sprintf("%x", idx.PackfileChecksum)) } -func (s *IdxfileSuite) TestDecode64bitsOffsets(c *C) { +func (s *IdxfileSuite) TestDecode64bitsOffsets() { f := bytes.NewBufferString(fixtureLarge4GB) idx := new(MemoryIndex) d := NewDecoder(base64.NewDecoder(base64.StdEncoding, f)) err := d.Decode(idx) - c.Assert(err, IsNil) + s.NoError(err) expected := map[string]uint64{ "303953e5aa461c203a324821bc1717f9b4fff895": 12, @@ -72,7 +77,7 @@ func (s *IdxfileSuite) TestDecode64bitsOffsets(c *C) { } iter, err := idx.Entries() - c.Assert(err, IsNil) + s.NoError(err) var entries int for { @@ -80,13 +85,13 @@ func (s *IdxfileSuite) TestDecode64bitsOffsets(c *C) { if err == io.EOF { break } - c.Assert(err, IsNil) + s.NoError(err) entries++ - c.Assert(expected[e.Hash.String()], Equals, e.Offset) + s.Equal(e.Offset, expected[e.Hash.String()]) } - c.Assert(entries, Equals, len(expected)) + s.Len(expected, entries) } const fixtureLarge4GB = `/3RPYwAAAAIAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEA diff --git a/plumbing/format/idxfile/encoder.go b/plumbing/format/idxfile/encoder.go index 75147376b..9e293488e 100644 --- a/plumbing/format/idxfile/encoder.go +++ b/plumbing/format/idxfile/encoder.go @@ -3,8 +3,8 @@ package idxfile import ( "io" - "github.com/go-git/go-git/v5/plumbing/hash" - "github.com/go-git/go-git/v5/utils/binary" + "github.com/jesseduffield/go-git/v5/plumbing/hash" + "github.com/jesseduffield/go-git/v5/utils/binary" ) // Encoder writes MemoryIndex structs to an output stream. diff --git a/plumbing/format/idxfile/encoder_test.go b/plumbing/format/idxfile/encoder_test.go index b8ece8398..a88541518 100644 --- a/plumbing/format/idxfile/encoder_test.go +++ b/plumbing/format/idxfile/encoder_test.go @@ -4,28 +4,27 @@ import ( "bytes" "io" - . "github.com/go-git/go-git/v5/plumbing/format/idxfile" + . "github.com/jesseduffield/go-git/v5/plumbing/format/idxfile" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) -func (s *IdxfileSuite) TestDecodeEncode(c *C) { - fixtures.ByTag("packfile").Test(c, func(f *fixtures.Fixture) { +func (s *IdxfileSuite) TestDecodeEncode() { + for _, f := range fixtures.ByTag("packfile") { expected, err := io.ReadAll(f.Idx()) - c.Assert(err, IsNil) + s.NoError(err) idx := new(MemoryIndex) d := NewDecoder(bytes.NewBuffer(expected)) err = d.Decode(idx) - c.Assert(err, IsNil) + s.NoError(err) result := bytes.NewBuffer(nil) e := NewEncoder(result) size, err := e.Encode(idx) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(size, Equals, len(expected)) - c.Assert(result.Bytes(), DeepEquals, expected) - }) + s.Len(expected, size) + s.Equal(expected, result.Bytes()) + } } diff --git a/plumbing/format/idxfile/idxfile.go b/plumbing/format/idxfile/idxfile.go index 9237a7434..f762c97c6 100644 --- a/plumbing/format/idxfile/idxfile.go +++ b/plumbing/format/idxfile/idxfile.go @@ -4,11 +4,12 @@ import ( "bytes" "io" "sort" + "sync" encbin "encoding/binary" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/hash" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/hash" ) const ( @@ -59,6 +60,7 @@ type MemoryIndex struct { offsetHash map[int64]plumbing.Hash offsetHashIsFull bool + mu sync.RWMutex } var _ Index = (*MemoryIndex)(nil) @@ -128,10 +130,12 @@ func (idx *MemoryIndex) FindOffset(h plumbing.Hash) (int64, error) { if !idx.offsetHashIsFull { // Save the offset for reverse lookup + idx.mu.Lock() if idx.offsetHash == nil { idx.offsetHash = make(map[int64]plumbing.Hash) } idx.offsetHash[int64(offset)] = h + idx.mu.Unlock() } return int64(offset), nil @@ -173,11 +177,14 @@ func (idx *MemoryIndex) FindHash(o int64) (plumbing.Hash, error) { var hash plumbing.Hash var ok bool + idx.mu.RLock() if idx.offsetHash != nil { if hash, ok = idx.offsetHash[o]; ok { + idx.mu.RUnlock() return hash, nil } } + idx.mu.RUnlock() // Lazily generate the reverse offset/hash map if required. if !idx.offsetHashIsFull || idx.offsetHash == nil { @@ -197,6 +204,9 @@ func (idx *MemoryIndex) FindHash(o int64) (plumbing.Hash, error) { // genOffsetHash generates the offset/hash mapping for reverse search. func (idx *MemoryIndex) genOffsetHash() error { + defer idx.mu.Unlock() + idx.mu.Lock() + count, err := idx.Count() if err != nil { return err diff --git a/plumbing/format/idxfile/idxfile_test.go b/plumbing/format/idxfile/idxfile_test.go index 7a3d6bbb8..a7d10ef46 100644 --- a/plumbing/format/idxfile/idxfile_test.go +++ b/plumbing/format/idxfile/idxfile_test.go @@ -7,17 +7,17 @@ import ( "io" "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/idxfile" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/idxfile" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) func BenchmarkFindOffset(b *testing.B) { idx, err := fixtureIndex() if err != nil { - b.Fatalf(err.Error()) + b.Fatal(err.Error()) } for i := 0; i < b.N; i++ { @@ -33,7 +33,7 @@ func BenchmarkFindOffset(b *testing.B) { func BenchmarkFindCRC32(b *testing.B) { idx, err := fixtureIndex() if err != nil { - b.Fatalf(err.Error()) + b.Fatal(err.Error()) } for i := 0; i < b.N; i++ { @@ -49,7 +49,7 @@ func BenchmarkFindCRC32(b *testing.B) { func BenchmarkContains(b *testing.B) { idx, err := fixtureIndex() if err != nil { - b.Fatalf(err.Error()) + b.Fatal(err.Error()) } for i := 0; i < b.N; i++ { @@ -69,7 +69,7 @@ func BenchmarkContains(b *testing.B) { func BenchmarkEntries(b *testing.B) { idx, err := fixtureIndex() if err != nil { - b.Fatalf(err.Error()) + b.Fatal(err.Error()) } for i := 0; i < b.N; i++ { @@ -98,35 +98,42 @@ func BenchmarkEntries(b *testing.B) { } } -type IndexSuite struct { +type IndexFixtureSuite struct { fixtures.Suite } -var _ = Suite(&IndexSuite{}) +type IndexSuite struct { + suite.Suite + IndexFixtureSuite +} + +func TestIndexSuite(t *testing.T) { + suite.Run(t, new(IndexSuite)) +} -func (s *IndexSuite) TestFindHash(c *C) { +func (s *IndexSuite) TestFindHash() { idx, err := fixtureIndex() - c.Assert(err, IsNil) + s.NoError(err) for i, pos := range fixtureOffsets { hash, err := idx.FindHash(pos) - c.Assert(err, IsNil) - c.Assert(hash, Equals, fixtureHashes[i]) + s.NoError(err) + s.Equal(fixtureHashes[i], hash) } } -func (s *IndexSuite) TestEntriesByOffset(c *C) { +func (s *IndexSuite) TestEntriesByOffset() { idx, err := fixtureIndex() - c.Assert(err, IsNil) + s.NoError(err) entries, err := idx.EntriesByOffset() - c.Assert(err, IsNil) + s.NoError(err) for _, pos := range fixtureOffsets { e, err := entries.Next() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(e.Offset, Equals, uint64(pos)) + s.Equal(uint64(pos), e.Offset) } } diff --git a/plumbing/format/idxfile/writer.go b/plumbing/format/idxfile/writer.go index c4c21e167..baa2ac37a 100644 --- a/plumbing/format/idxfile/writer.go +++ b/plumbing/format/idxfile/writer.go @@ -7,8 +7,8 @@ import ( "sort" "sync" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/utils/binary" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/utils/binary" ) // objects implements sort.Interface and uses hash as sorting key. diff --git a/plumbing/format/idxfile/writer_test.go b/plumbing/format/idxfile/writer_test.go index eaa8605f7..876487b8d 100644 --- a/plumbing/format/idxfile/writer_test.go +++ b/plumbing/format/idxfile/writer_test.go @@ -4,77 +4,84 @@ import ( "bytes" "encoding/base64" "io" + "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/idxfile" - "github.com/go-git/go-git/v5/plumbing/format/packfile" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/idxfile" + "github.com/jesseduffield/go-git/v5/plumbing/format/packfile" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) -type WriterSuite struct { +type WriterFixtureSuite struct { fixtures.Suite } -var _ = Suite(&WriterSuite{}) +type WriterSuite struct { + suite.Suite + WriterFixtureSuite +} + +func TestWriterSuite(t *testing.T) { + suite.Run(t, new(WriterSuite)) +} -func (s *WriterSuite) TestWriter(c *C) { +func (s *WriterSuite) TestWriter() { f := fixtures.Basic().One() scanner := packfile.NewScanner(f.Packfile()) obs := new(idxfile.Writer) - parser, err := packfile.NewParser(scanner, obs) - c.Assert(err, IsNil) + parser := packfile.NewParser(scanner, packfile.WithScannerObservers(obs)) - _, err = parser.Parse() - c.Assert(err, IsNil) + _, err := parser.Parse() + s.NoError(err) idx, err := obs.Index() - c.Assert(err, IsNil) + s.NoError(err) idxFile := f.Idx() expected, err := io.ReadAll(idxFile) - c.Assert(err, IsNil) + s.NoError(err) idxFile.Close() buf := new(bytes.Buffer) encoder := idxfile.NewEncoder(buf) n, err := encoder.Encode(idx) - c.Assert(err, IsNil) - c.Assert(n, Equals, len(expected)) + s.NoError(err) + s.Len(expected, n) - c.Assert(buf.Bytes(), DeepEquals, expected) + s.Equal(expected, buf.Bytes()) } -func (s *WriterSuite) TestWriterLarge(c *C) { +func (s *WriterSuite) TestWriterLarge() { writer := new(idxfile.Writer) err := writer.OnHeader(uint32(len(fixture4GbEntries))) - c.Assert(err, IsNil) + s.NoError(err) for _, o := range fixture4GbEntries { err = writer.OnInflatedObjectContent(plumbing.NewHash(o.hash), o.offset, o.crc, nil) - c.Assert(err, IsNil) + s.NoError(err) } err = writer.OnFooter(fixture4GbChecksum) - c.Assert(err, IsNil) + s.NoError(err) idx, err := writer.Index() - c.Assert(err, IsNil) + s.NoError(err) // load fixture index f := bytes.NewBufferString(fixtureLarge4GB) expected, err := io.ReadAll(base64.NewDecoder(base64.StdEncoding, f)) - c.Assert(err, IsNil) + s.NoError(err) buf := new(bytes.Buffer) encoder := idxfile.NewEncoder(buf) n, err := encoder.Encode(idx) - c.Assert(err, IsNil) - c.Assert(n, Equals, len(expected)) + s.NoError(err) + s.Len(expected, n) - c.Assert(buf.Bytes(), DeepEquals, expected) + s.Equal(expected, buf.Bytes()) } var ( diff --git a/plumbing/format/index/decoder.go b/plumbing/format/index/decoder.go index fc25d3702..6bd26206d 100644 --- a/plumbing/format/index/decoder.go +++ b/plumbing/format/index/decoder.go @@ -9,9 +9,9 @@ import ( "strconv" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/hash" - "github.com/go-git/go-git/v5/utils/binary" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/hash" + "github.com/jesseduffield/go-git/v5/utils/binary" ) var ( diff --git a/plumbing/format/index/decoder_test.go b/plumbing/format/index/decoder_test.go index 4adddda09..0a918295e 100644 --- a/plumbing/format/index/decoder_test.go +++ b/plumbing/format/index/decoder_test.go @@ -3,89 +3,95 @@ package index import ( "bytes" "crypto" - "github.com/go-git/go-git/v5/plumbing/hash" - "github.com/go-git/go-git/v5/utils/binary" "io" "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/plumbing/hash" + "github.com/jesseduffield/go-git/v5/utils/binary" + "github.com/stretchr/testify/suite" + + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) -func Test(t *testing.T) { TestingT(t) } +type IndexFixtureSuite struct { + fixtures.Suite +} type IndexSuite struct { - fixtures.Suite + suite.Suite + IndexFixtureSuite } -var _ = Suite(&IndexSuite{}) +func TestIndexSuite(t *testing.T) { + suite.Run(t, new(IndexSuite)) +} -func (s *IndexSuite) TestDecode(c *C) { +func (s *IndexSuite) TestDecode() { f, err := fixtures.Basic().One().DotGit().Open("index") - c.Assert(err, IsNil) - defer func() { c.Assert(f.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(f.Close()) }() idx := &Index{} d := NewDecoder(f) err = d.Decode(idx) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(idx.Version, Equals, uint32(2)) - c.Assert(idx.Entries, HasLen, 9) + s.Equal(uint32(2), idx.Version) + s.Len(idx.Entries, 9) } -func (s *IndexSuite) TestDecodeEntries(c *C) { +func (s *IndexSuite) TestDecodeEntries() { f, err := fixtures.Basic().One().DotGit().Open("index") - c.Assert(err, IsNil) - defer func() { c.Assert(f.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(f.Close()) }() idx := &Index{} d := NewDecoder(f) err = d.Decode(idx) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(idx.Entries, HasLen, 9) + s.Len(idx.Entries, 9) e := idx.Entries[0] - c.Assert(e.CreatedAt.Unix(), Equals, int64(1480626693)) - c.Assert(e.CreatedAt.Nanosecond(), Equals, 498593596) - c.Assert(e.ModifiedAt.Unix(), Equals, int64(1480626693)) - c.Assert(e.ModifiedAt.Nanosecond(), Equals, 498593596) - c.Assert(e.Dev, Equals, uint32(39)) - c.Assert(e.Inode, Equals, uint32(140626)) - c.Assert(e.UID, Equals, uint32(1000)) - c.Assert(e.GID, Equals, uint32(100)) - c.Assert(e.Size, Equals, uint32(189)) - c.Assert(e.Hash.String(), Equals, "32858aad3c383ed1ff0a0f9bdf231d54a00c9e88") - c.Assert(e.Name, Equals, ".gitignore") - c.Assert(e.Mode, Equals, filemode.Regular) + s.Equal(int64(1480626693), e.CreatedAt.Unix()) + s.Equal(498593596, e.CreatedAt.Nanosecond()) + s.Equal(int64(1480626693), e.ModifiedAt.Unix()) + s.Equal(498593596, e.ModifiedAt.Nanosecond()) + s.Equal(uint32(39), e.Dev) + s.Equal(uint32(140626), e.Inode) + s.Equal(uint32(1000), e.UID) + s.Equal(uint32(100), e.GID) + s.Equal(uint32(189), e.Size) + s.Equal("32858aad3c383ed1ff0a0f9bdf231d54a00c9e88", e.Hash.String()) + s.Equal(".gitignore", e.Name) + s.Equal(filemode.Regular, e.Mode) e = idx.Entries[1] - c.Assert(e.Name, Equals, "CHANGELOG") + s.Equal("CHANGELOG", e.Name) } -func (s *IndexSuite) TestDecodeCacheTree(c *C) { +func (s *IndexSuite) TestDecodeCacheTree() { f, err := fixtures.Basic().One().DotGit().Open("index") - c.Assert(err, IsNil) - defer func() { c.Assert(f.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(f.Close()) }() idx := &Index{} d := NewDecoder(f) err = d.Decode(idx) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(idx.Entries, HasLen, 9) - c.Assert(idx.Cache.Entries, HasLen, 5) + s.Len(idx.Entries, 9) + s.Len(idx.Cache.Entries, 5) for i, expected := range expectedEntries { - c.Assert(idx.Cache.Entries[i].Path, Equals, expected.Path) - c.Assert(idx.Cache.Entries[i].Entries, Equals, expected.Entries) - c.Assert(idx.Cache.Entries[i].Trees, Equals, expected.Trees) - c.Assert(idx.Cache.Entries[i].Hash.String(), Equals, expected.Hash.String()) + s.Equal(expected.Path, idx.Cache.Entries[i].Path) + s.Equal(expected.Entries, idx.Cache.Entries[i].Entries) + s.Equal(expected.Trees, idx.Cache.Entries[i].Trees) + s.Equal(expected.Hash.String(), idx.Cache.Entries[i].Hash.String()) } } @@ -98,18 +104,18 @@ var expectedEntries = []TreeEntry{ {Path: "vendor", Entries: 1, Trees: 0, Hash: plumbing.NewHash("cf4aa3b38974fb7d81f367c0830f7d78d65ab86b")}, } -func (s *IndexSuite) TestDecodeMergeConflict(c *C) { +func (s *IndexSuite) TestDecodeMergeConflict() { f, err := fixtures.Basic().ByTag("merge-conflict").One().DotGit().Open("index") - c.Assert(err, IsNil) - defer func() { c.Assert(f.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(f.Close()) }() idx := &Index{} d := NewDecoder(f) err = d.Decode(idx) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(idx.Version, Equals, uint32(2)) - c.Assert(idx.Entries, HasLen, 13) + s.Equal(uint32(2), idx.Version) + s.Len(idx.Entries, 13) expected := []struct { Stage Stage @@ -122,76 +128,76 @@ func (s *IndexSuite) TestDecodeMergeConflict(c *C) { // staged files for i, e := range idx.Entries[4:7] { - c.Assert(e.Stage, Equals, expected[i].Stage) - c.Assert(e.CreatedAt.IsZero(), Equals, true) - c.Assert(e.ModifiedAt.IsZero(), Equals, true) - c.Assert(e.Dev, Equals, uint32(0)) - c.Assert(e.Inode, Equals, uint32(0)) - c.Assert(e.UID, Equals, uint32(0)) - c.Assert(e.GID, Equals, uint32(0)) - c.Assert(e.Size, Equals, uint32(0)) - c.Assert(e.Hash.String(), Equals, expected[i].Hash) - c.Assert(e.Name, Equals, "go/example.go") + s.Equal(expected[i].Stage, e.Stage) + s.True(e.CreatedAt.IsZero()) + s.True(e.ModifiedAt.IsZero()) + s.Equal(uint32(0), e.Dev) + s.Equal(uint32(0), e.Inode) + s.Equal(uint32(0), e.UID) + s.Equal(uint32(0), e.GID) + s.Equal(uint32(0), e.Size) + s.Equal(expected[i].Hash, e.Hash.String()) + s.Equal("go/example.go", e.Name) } } -func (s *IndexSuite) TestDecodeExtendedV3(c *C) { +func (s *IndexSuite) TestDecodeExtendedV3() { f, err := fixtures.Basic().ByTag("intent-to-add").One().DotGit().Open("index") - c.Assert(err, IsNil) - defer func() { c.Assert(f.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(f.Close()) }() idx := &Index{} d := NewDecoder(f) err = d.Decode(idx) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(idx.Version, Equals, uint32(3)) - c.Assert(idx.Entries, HasLen, 11) + s.Equal(uint32(3), idx.Version) + s.Len(idx.Entries, 11) - c.Assert(idx.Entries[6].Name, Equals, "intent-to-add") - c.Assert(idx.Entries[6].IntentToAdd, Equals, true) - c.Assert(idx.Entries[6].SkipWorktree, Equals, false) + s.Equal("intent-to-add", idx.Entries[6].Name) + s.True(idx.Entries[6].IntentToAdd) + s.False(idx.Entries[6].SkipWorktree) } -func (s *IndexSuite) TestDecodeResolveUndo(c *C) { +func (s *IndexSuite) TestDecodeResolveUndo() { f, err := fixtures.Basic().ByTag("resolve-undo").One().DotGit().Open("index") - c.Assert(err, IsNil) - defer func() { c.Assert(f.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(f.Close()) }() idx := &Index{} d := NewDecoder(f) err = d.Decode(idx) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(idx.Version, Equals, uint32(2)) - c.Assert(idx.Entries, HasLen, 8) + s.Equal(uint32(2), idx.Version) + s.Len(idx.Entries, 8) ru := idx.ResolveUndo - c.Assert(ru.Entries, HasLen, 2) - c.Assert(ru.Entries[0].Path, Equals, "go/example.go") - c.Assert(ru.Entries[0].Stages, HasLen, 3) - c.Assert(ru.Entries[0].Stages[AncestorMode], Not(Equals), plumbing.ZeroHash) - c.Assert(ru.Entries[0].Stages[OurMode], Not(Equals), plumbing.ZeroHash) - c.Assert(ru.Entries[0].Stages[TheirMode], Not(Equals), plumbing.ZeroHash) - c.Assert(ru.Entries[1].Path, Equals, "haskal/haskal.hs") - c.Assert(ru.Entries[1].Stages, HasLen, 2) - c.Assert(ru.Entries[1].Stages[OurMode], Not(Equals), plumbing.ZeroHash) - c.Assert(ru.Entries[1].Stages[TheirMode], Not(Equals), plumbing.ZeroHash) + s.Len(ru.Entries, 2) + s.Equal("go/example.go", ru.Entries[0].Path) + s.Len(ru.Entries[0].Stages, 3) + s.NotEqual(plumbing.ZeroHash, ru.Entries[0].Stages[AncestorMode]) + s.NotEqual(plumbing.ZeroHash, ru.Entries[0].Stages[OurMode]) + s.NotEqual(plumbing.ZeroHash, ru.Entries[0].Stages[TheirMode]) + s.Equal("haskal/haskal.hs", ru.Entries[1].Path) + s.Len(ru.Entries[1].Stages, 2) + s.NotEqual(plumbing.ZeroHash, ru.Entries[1].Stages[OurMode]) + s.NotEqual(plumbing.ZeroHash, ru.Entries[1].Stages[TheirMode]) } -func (s *IndexSuite) TestDecodeV4(c *C) { +func (s *IndexSuite) TestDecodeV4() { f, err := fixtures.Basic().ByTag("index-v4").One().DotGit().Open("index") - c.Assert(err, IsNil) - defer func() { c.Assert(f.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(f.Close()) }() idx := &Index{} d := NewDecoder(f) err = d.Decode(idx) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(idx.Version, Equals, uint32(4)) - c.Assert(idx.Entries, HasLen, 11) + s.Equal(uint32(4), idx.Version) + s.Len(idx.Entries, 11) names := []string{ ".gitignore", "CHANGELOG", "LICENSE", "binary.jpg", "go/example.go", @@ -200,123 +206,123 @@ func (s *IndexSuite) TestDecodeV4(c *C) { } for i, e := range idx.Entries { - c.Assert(e.Name, Equals, names[i]) + s.Equal(names[i], e.Name) } - c.Assert(idx.Entries[6].Name, Equals, "intent-to-add") - c.Assert(idx.Entries[6].IntentToAdd, Equals, true) - c.Assert(idx.Entries[6].SkipWorktree, Equals, false) + s.Equal("intent-to-add", idx.Entries[6].Name) + s.True(idx.Entries[6].IntentToAdd) + s.False(idx.Entries[6].SkipWorktree) } -func (s *IndexSuite) TestDecodeEndOfIndexEntry(c *C) { +func (s *IndexSuite) TestDecodeEndOfIndexEntry() { f, err := fixtures.Basic().ByTag("end-of-index-entry").One().DotGit().Open("index") - c.Assert(err, IsNil) - defer func() { c.Assert(f.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(f.Close()) }() idx := &Index{} d := NewDecoder(f) err = d.Decode(idx) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(idx.Version, Equals, uint32(2)) - c.Assert(idx.EndOfIndexEntry, NotNil) - c.Assert(idx.EndOfIndexEntry.Offset, Equals, uint32(716)) - c.Assert(idx.EndOfIndexEntry.Hash.String(), Equals, "922e89d9ffd7cefce93a211615b2053c0f42bd78") + s.Equal(uint32(2), idx.Version) + s.NotNil(idx.EndOfIndexEntry) + s.Equal(uint32(716), idx.EndOfIndexEntry.Offset) + s.Equal("922e89d9ffd7cefce93a211615b2053c0f42bd78", idx.EndOfIndexEntry.Hash.String()) } -func (s *IndexSuite) readSimpleIndex(c *C) *Index { +func (s *IndexSuite) readSimpleIndex() *Index { f, err := fixtures.Basic().One().DotGit().Open("index") - c.Assert(err, IsNil) - defer func() { c.Assert(f.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(f.Close()) }() idx := &Index{} d := NewDecoder(f) err = d.Decode(idx) - c.Assert(err, IsNil) + s.NoError(err) return idx } -func (s *IndexSuite) buildIndexWithExtension(c *C, signature string, data string) []byte { - idx := s.readSimpleIndex(c) +func (s *IndexSuite) buildIndexWithExtension(signature string, data string) []byte { + idx := s.readSimpleIndex() buf := bytes.NewBuffer(nil) e := NewEncoder(buf) err := e.encode(idx, false) - c.Assert(err, IsNil) + s.NoError(err) err = e.encodeRawExtension(signature, []byte(data)) - c.Assert(err, IsNil) + s.NoError(err) err = e.encodeFooter() - c.Assert(err, IsNil) + s.NoError(err) return buf.Bytes() } -func (s *IndexSuite) TestDecodeUnknownOptionalExt(c *C) { - f := bytes.NewReader(s.buildIndexWithExtension(c, "TEST", "testdata")) +func (s *IndexSuite) TestDecodeUnknownOptionalExt() { + f := bytes.NewReader(s.buildIndexWithExtension("TEST", "testdata")) idx := &Index{} d := NewDecoder(f) err := d.Decode(idx) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *IndexSuite) TestDecodeUnknownMandatoryExt(c *C) { - f := bytes.NewReader(s.buildIndexWithExtension(c, "test", "testdata")) +func (s *IndexSuite) TestDecodeUnknownMandatoryExt() { + f := bytes.NewReader(s.buildIndexWithExtension("test", "testdata")) idx := &Index{} d := NewDecoder(f) err := d.Decode(idx) - c.Assert(err, ErrorMatches, ErrUnknownExtension.Error()) + s.ErrorContains(err, ErrUnknownExtension.Error()) } -func (s *IndexSuite) TestDecodeTruncatedExt(c *C) { - idx := s.readSimpleIndex(c) +func (s *IndexSuite) TestDecodeTruncatedExt() { + idx := s.readSimpleIndex() buf := bytes.NewBuffer(nil) e := NewEncoder(buf) err := e.encode(idx, false) - c.Assert(err, IsNil) + s.NoError(err) _, err = e.w.Write([]byte("TEST")) - c.Assert(err, IsNil) + s.NoError(err) err = binary.WriteUint32(e.w, uint32(100)) - c.Assert(err, IsNil) + s.NoError(err) _, err = e.w.Write([]byte("truncated")) - c.Assert(err, IsNil) + s.NoError(err) err = e.encodeFooter() - c.Assert(err, IsNil) + s.NoError(err) idx = &Index{} d := NewDecoder(buf) err = d.Decode(idx) - c.Assert(err, ErrorMatches, io.EOF.Error()) + s.ErrorContains(err, io.EOF.Error()) } -func (s *IndexSuite) TestDecodeInvalidHash(c *C) { - idx := s.readSimpleIndex(c) +func (s *IndexSuite) TestDecodeInvalidHash() { + idx := s.readSimpleIndex() buf := bytes.NewBuffer(nil) e := NewEncoder(buf) err := e.encode(idx, false) - c.Assert(err, IsNil) + s.NoError(err) err = e.encodeRawExtension("TEST", []byte("testdata")) - c.Assert(err, IsNil) + s.NoError(err) h := hash.New(crypto.SHA1) err = binary.Write(e.w, h.Sum(nil)) - c.Assert(err, IsNil) + s.NoError(err) idx = &Index{} d := NewDecoder(buf) err = d.Decode(idx) - c.Assert(err, ErrorMatches, ErrInvalidChecksum.Error()) + s.ErrorContains(err, ErrInvalidChecksum.Error()) } diff --git a/plumbing/format/index/encoder.go b/plumbing/format/index/encoder.go index c292c2cd6..ffa818288 100644 --- a/plumbing/format/index/encoder.go +++ b/plumbing/format/index/encoder.go @@ -5,16 +5,18 @@ import ( "errors" "fmt" "io" + "path" "sort" + "strings" "time" - "github.com/go-git/go-git/v5/plumbing/hash" - "github.com/go-git/go-git/v5/utils/binary" + "github.com/jesseduffield/go-git/v5/plumbing/hash" + "github.com/jesseduffield/go-git/v5/utils/binary" ) var ( // EncodeVersionSupported is the range of supported index versions - EncodeVersionSupported uint32 = 3 + EncodeVersionSupported uint32 = 4 // ErrInvalidTimestamp is returned by Encode if a Index with a Entry with // negative timestamp values @@ -23,15 +25,16 @@ var ( // An Encoder writes an Index to an output stream. type Encoder struct { - w io.Writer - hash hash.Hash + w io.Writer + hash hash.Hash + lastEntry *Entry } // NewEncoder returns a new encoder that writes to w. func NewEncoder(w io.Writer) *Encoder { h := hash.New(hash.CryptoType) mw := io.MultiWriter(w, h) - return &Encoder{mw, h} + return &Encoder{mw, h, nil} } // Encode writes the Index to the stream of the encoder. @@ -40,8 +43,6 @@ func (e *Encoder) Encode(idx *Index) error { } func (e *Encoder) encode(idx *Index, footer bool) error { - - // TODO: support v4 // TODO: support extensions if idx.Version > EncodeVersionSupported { return ErrUnsupportedVersion @@ -73,7 +74,7 @@ func (e *Encoder) encodeEntries(idx *Index) error { sort.Sort(byName(idx.Entries)) for _, entry := range idx.Entries { - if err := e.encodeEntry(entry); err != nil { + if err := e.encodeEntry(idx, entry); err != nil { return err } entryLength := entryHeaderLength @@ -82,7 +83,7 @@ func (e *Encoder) encodeEntries(idx *Index) error { } wrote := entryLength + len(entry.Name) - if err := e.padEntry(wrote); err != nil { + if err := e.padEntry(idx, wrote); err != nil { return err } } @@ -90,7 +91,7 @@ func (e *Encoder) encodeEntries(idx *Index) error { return nil } -func (e *Encoder) encodeEntry(entry *Entry) error { +func (e *Encoder) encodeEntry(idx *Index, entry *Entry) error { sec, nsec, err := e.timeToUint32(&entry.CreatedAt) if err != nil { return err @@ -141,9 +142,45 @@ func (e *Encoder) encodeEntry(entry *Entry) error { return err } + switch idx.Version { + case 2, 3: + err = e.encodeEntryName(entry) + case 4: + err = e.encodeEntryNameV4(entry) + default: + err = ErrUnsupportedVersion + } + + return err +} + +func (e *Encoder) encodeEntryName(entry *Entry) error { return binary.Write(e.w, []byte(entry.Name)) } +func (e *Encoder) encodeEntryNameV4(entry *Entry) error { + name := entry.Name + l := 0 + if e.lastEntry != nil { + dir := path.Dir(e.lastEntry.Name) + "/" + if strings.HasPrefix(entry.Name, dir) { + l = len(e.lastEntry.Name) - len(dir) + name = strings.TrimPrefix(entry.Name, dir) + } else { + l = len(e.lastEntry.Name) + } + } + + e.lastEntry = entry + + err := binary.WriteVariableWidthInt(e.w, int64(l)) + if err != nil { + return err + } + + return binary.Write(e.w, []byte(name+string('\x00'))) +} + func (e *Encoder) encodeRawExtension(signature string, data []byte) error { if len(signature) != 4 { return fmt.Errorf("invalid signature length") @@ -179,7 +216,11 @@ func (e *Encoder) timeToUint32(t *time.Time) (uint32, uint32, error) { return uint32(t.Unix()), uint32(t.Nanosecond()), nil } -func (e *Encoder) padEntry(wrote int) error { +func (e *Encoder) padEntry(idx *Index, wrote int) error { + if idx.Version == 4 { + return nil + } + padLen := 8 - wrote%8 _, err := e.w.Write(bytes.Repeat([]byte{'\x00'}, padLen)) diff --git a/plumbing/format/index/encoder_test.go b/plumbing/format/index/encoder_test.go index 25c24f14f..a82c293ed 100644 --- a/plumbing/format/index/encoder_test.go +++ b/plumbing/format/index/encoder_test.go @@ -3,15 +3,15 @@ package index import ( "bytes" "strings" + "testing" "time" - "github.com/go-git/go-git/v5/plumbing" - - "github.com/google/go-cmp/cmp" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) -func (s *IndexSuite) TestEncode(c *C) { +func TestEncode(t *testing.T) { idx := &Index{ Version: 2, Entries: []*Entry{{ @@ -41,31 +41,87 @@ func (s *IndexSuite) TestEncode(c *C) { buf := bytes.NewBuffer(nil) e := NewEncoder(buf) err := e.Encode(idx) - c.Assert(err, IsNil) + assert.NoError(t, err) output := &Index{} d := NewDecoder(buf) err = d.Decode(output) - c.Assert(err, IsNil) + assert.NoError(t, err) + + assert.EqualExportedValues(t, idx, output) + + assert.Equal(t, strings.Repeat(" ", 20), output.Entries[0].Name) + assert.Equal(t, "bar", output.Entries[1].Name) + assert.Equal(t, "foo", output.Entries[2].Name) - c.Assert(cmp.Equal(idx, output), Equals, true) +} + +func TestEncodeV4(t *testing.T) { + idx := &Index{ + Version: 4, + Entries: []*Entry{{ + CreatedAt: time.Now(), + ModifiedAt: time.Now(), + Dev: 4242, + Inode: 424242, + UID: 84, + GID: 8484, + Size: 42, + Stage: TheirMode, + Hash: plumbing.NewHash("e25b29c8946e0e192fae2edc1dabf7be71e8ecf3"), + Name: "foo", + }, { + CreatedAt: time.Now(), + ModifiedAt: time.Now(), + Name: "bar", + Size: 82, + }, { + CreatedAt: time.Now(), + ModifiedAt: time.Now(), + Name: strings.Repeat(" ", 20), + Size: 82, + }, { + CreatedAt: time.Now(), + ModifiedAt: time.Now(), + Name: "baz/bar", + Size: 82, + }, { + CreatedAt: time.Now(), + ModifiedAt: time.Now(), + Name: "baz/bar/bar", + Size: 82, + }}, + } + + buf := bytes.NewBuffer(nil) + e := NewEncoder(buf) + err := e.Encode(idx) + require.NoError(t, err) + + output := &Index{} + d := NewDecoder(buf) + err = d.Decode(output) + require.NoError(t, err) - c.Assert(output.Entries[0].Name, Equals, strings.Repeat(" ", 20)) - c.Assert(output.Entries[1].Name, Equals, "bar") - c.Assert(output.Entries[2].Name, Equals, "foo") + assert.EqualExportedValues(t, idx, output) + assert.Equal(t, strings.Repeat(" ", 20), output.Entries[0].Name) + assert.Equal(t, "bar", output.Entries[1].Name) + assert.Equal(t, "baz/bar", output.Entries[2].Name) + assert.Equal(t, "baz/bar/bar", output.Entries[3].Name) + assert.Equal(t, "foo", output.Entries[4].Name) } -func (s *IndexSuite) TestEncodeUnsupportedVersion(c *C) { - idx := &Index{Version: 4} +func TestEncodeUnsupportedVersion(t *testing.T) { + idx := &Index{Version: 5} buf := bytes.NewBuffer(nil) e := NewEncoder(buf) err := e.Encode(idx) - c.Assert(err, Equals, ErrUnsupportedVersion) + assert.Equal(t, ErrUnsupportedVersion, err) } -func (s *IndexSuite) TestEncodeWithIntentToAddUnsupportedVersion(c *C) { +func TestEncodeWithIntentToAddUnsupportedVersion(t *testing.T) { idx := &Index{ Version: 3, Entries: []*Entry{{IntentToAdd: true}}, @@ -74,18 +130,18 @@ func (s *IndexSuite) TestEncodeWithIntentToAddUnsupportedVersion(c *C) { buf := bytes.NewBuffer(nil) e := NewEncoder(buf) err := e.Encode(idx) - c.Assert(err, IsNil) + assert.NoError(t, err) output := &Index{} d := NewDecoder(buf) err = d.Decode(output) - c.Assert(err, IsNil) + assert.NoError(t, err) - c.Assert(cmp.Equal(idx, output), Equals, true) - c.Assert(output.Entries[0].IntentToAdd, Equals, true) + assert.EqualExportedValues(t, idx, output) + assert.Equal(t, true, output.Entries[0].IntentToAdd) } -func (s *IndexSuite) TestEncodeWithSkipWorktreeUnsupportedVersion(c *C) { +func TestEncodeWithSkipWorktreeUnsupportedVersion(t *testing.T) { idx := &Index{ Version: 3, Entries: []*Entry{{SkipWorktree: true}}, @@ -94,13 +150,13 @@ func (s *IndexSuite) TestEncodeWithSkipWorktreeUnsupportedVersion(c *C) { buf := bytes.NewBuffer(nil) e := NewEncoder(buf) err := e.Encode(idx) - c.Assert(err, IsNil) + assert.NoError(t, err) output := &Index{} d := NewDecoder(buf) err = d.Decode(output) - c.Assert(err, IsNil) + assert.NoError(t, err) - c.Assert(cmp.Equal(idx, output), Equals, true) - c.Assert(output.Entries[0].SkipWorktree, Equals, true) + assert.EqualExportedValues(t, idx, output) + assert.Equal(t, true, output.Entries[0].SkipWorktree) } diff --git a/plumbing/format/index/index.go b/plumbing/format/index/index.go index f4c7647d3..2f68ae978 100644 --- a/plumbing/format/index/index.go +++ b/plumbing/format/index/index.go @@ -8,8 +8,8 @@ import ( "strings" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" ) var ( diff --git a/plumbing/format/index/index_test.go b/plumbing/format/index/index_test.go index ecf3c0d72..58dfeb4e7 100644 --- a/plumbing/format/index/index_test.go +++ b/plumbing/format/index/index_test.go @@ -2,22 +2,20 @@ package index import ( "path/filepath" - - . "gopkg.in/check.v1" ) -func (s *IndexSuite) TestIndexAdd(c *C) { +func (s *IndexSuite) TestIndexAdd() { idx := &Index{} e := idx.Add("foo") e.Size = 42 e, err := idx.Entry("foo") - c.Assert(err, IsNil) - c.Assert(e.Name, Equals, "foo") - c.Assert(e.Size, Equals, uint32(42)) + s.NoError(err) + s.Equal("foo", e.Name) + s.Equal(uint32(42), e.Size) } -func (s *IndexSuite) TestIndexEntry(c *C) { +func (s *IndexSuite) TestIndexEntry() { idx := &Index{ Entries: []*Entry{ {Name: "foo", Size: 42}, @@ -26,15 +24,15 @@ func (s *IndexSuite) TestIndexEntry(c *C) { } e, err := idx.Entry("foo") - c.Assert(err, IsNil) - c.Assert(e.Name, Equals, "foo") + s.NoError(err) + s.Equal("foo", e.Name) e, err = idx.Entry("missing") - c.Assert(e, IsNil) - c.Assert(err, Equals, ErrEntryNotFound) + s.Nil(e) + s.ErrorIs(err, ErrEntryNotFound) } -func (s *IndexSuite) TestIndexRemove(c *C) { +func (s *IndexSuite) TestIndexRemove() { idx := &Index{ Entries: []*Entry{ {Name: "foo", Size: 42}, @@ -43,15 +41,15 @@ func (s *IndexSuite) TestIndexRemove(c *C) { } e, err := idx.Remove("foo") - c.Assert(err, IsNil) - c.Assert(e.Name, Equals, "foo") + s.NoError(err) + s.Equal("foo", e.Name) e, err = idx.Remove("foo") - c.Assert(e, IsNil) - c.Assert(err, Equals, ErrEntryNotFound) + s.Nil(e) + s.ErrorIs(err, ErrEntryNotFound) } -func (s *IndexSuite) TestIndexGlob(c *C) { +func (s *IndexSuite) TestIndexGlob() { idx := &Index{ Entries: []*Entry{ {Name: "foo/bar/bar", Size: 42}, @@ -61,16 +59,16 @@ func (s *IndexSuite) TestIndexGlob(c *C) { } m, err := idx.Glob(filepath.Join("foo", "b*")) - c.Assert(err, IsNil) - c.Assert(m, HasLen, 2) - c.Assert(m[0].Name, Equals, "foo/bar/bar") - c.Assert(m[1].Name, Equals, "foo/baz/qux") + s.NoError(err) + s.Len(m, 2) + s.Equal("foo/bar/bar", m[0].Name) + s.Equal("foo/baz/qux", m[1].Name) m, err = idx.Glob("f*") - c.Assert(err, IsNil) - c.Assert(m, HasLen, 3) + s.NoError(err) + s.Len(m, 3) m, err = idx.Glob("f*/baz/q*") - c.Assert(err, IsNil) - c.Assert(m, HasLen, 1) + s.NoError(err) + s.Len(m, 1) } diff --git a/plumbing/format/objfile/common_test.go b/plumbing/format/objfile/common_test.go index de769024f..20226df0c 100644 --- a/plumbing/format/objfile/common_test.go +++ b/plumbing/format/objfile/common_test.go @@ -2,11 +2,8 @@ package objfile import ( "encoding/base64" - "testing" - "github.com/go-git/go-git/v5/plumbing" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" ) type objfileFixture struct { @@ -66,5 +63,3 @@ var objfileFixtures = []objfileFixture{ "eAGtjksOgjAUAF33FO8CktZ+aBNjTNy51Qs8Xl8FAjSh5f4SvILLmcVkKM/zUOEi3amuzMDBxE6mkBKhMZHaDiM71DaoZI1RXutgsSWBW+3zCs9c+g3hNeY4LB+4jgc35cf3QiNO04ALcUN5voEy1lmtrNdwll5Ksdt9oPIfUuLNpcLjCIov3ApFmQ==", }, } - -func Test(t *testing.T) { TestingT(t) } diff --git a/plumbing/format/objfile/reader.go b/plumbing/format/objfile/reader.go index d7932f4ea..433942805 100644 --- a/plumbing/format/objfile/reader.go +++ b/plumbing/format/objfile/reader.go @@ -5,9 +5,9 @@ import ( "io" "strconv" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/packfile" - "github.com/go-git/go-git/v5/utils/sync" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/packfile" + "github.com/jesseduffield/go-git/v5/utils/sync" ) var ( diff --git a/plumbing/format/objfile/reader_test.go b/plumbing/format/objfile/reader_test.go index 5526f7f4e..6115f7a93 100644 --- a/plumbing/format/objfile/reader_test.go +++ b/plumbing/format/objfile/reader_test.go @@ -5,63 +5,68 @@ import ( "encoding/base64" "fmt" "io" + "testing" - "github.com/go-git/go-git/v5/plumbing" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" ) -type SuiteReader struct{} +type SuiteReader struct { + suite.Suite +} -var _ = Suite(&SuiteReader{}) +func TestSuiteReader(t *testing.T) { + suite.Run(t, new(SuiteReader)) +} -func (s *SuiteReader) TestReadObjfile(c *C) { +func (s *SuiteReader) TestReadObjfile() { for k, fixture := range objfileFixtures { com := fmt.Sprintf("test %d: ", k) hash := plumbing.NewHash(fixture.hash) content, _ := base64.StdEncoding.DecodeString(fixture.content) data, _ := base64.StdEncoding.DecodeString(fixture.data) - testReader(c, bytes.NewReader(data), hash, fixture.t, content, com) + testReader(s.T(), bytes.NewReader(data), hash, fixture.t, content, com) } } -func testReader(c *C, source io.Reader, hash plumbing.Hash, t plumbing.ObjectType, content []byte, com string) { +func testReader(t *testing.T, source io.Reader, hash plumbing.Hash, o plumbing.ObjectType, content []byte, com string) { r, err := NewReader(source) - c.Assert(err, IsNil) + assert.NoError(t, err) typ, size, err := r.Header() - c.Assert(err, IsNil) - c.Assert(typ, Equals, t) - c.Assert(content, HasLen, int(size)) + assert.NoError(t, err) + assert.Equal(t, typ, o) + assert.Len(t, content, int(size)) rc, err := io.ReadAll(r) - c.Assert(err, IsNil) - c.Assert(rc, DeepEquals, content, Commentf("%scontent=%s, expected=%s", base64.StdEncoding.EncodeToString(rc), base64.StdEncoding.EncodeToString(content))) + assert.NoError(t, err) + assert.Equal(t, content, rc, fmt.Sprintf("content=%s, expected=%s", base64.StdEncoding.EncodeToString(rc), base64.StdEncoding.EncodeToString(content))) - c.Assert(r.Hash(), Equals, hash) // Test Hash() before close - c.Assert(r.Close(), IsNil) + assert.Equal(t, hash, r.Hash()) // Test Hash() before close + assert.NoError(t, r.Close()) } -func (s *SuiteReader) TestReadEmptyObjfile(c *C) { +func (s *SuiteReader) TestReadEmptyObjfile() { source := bytes.NewReader([]byte{}) _, err := NewReader(source) - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *SuiteReader) TestReadGarbage(c *C) { +func (s *SuiteReader) TestReadGarbage() { source := bytes.NewReader([]byte("!@#$RO!@NROSADfinq@o#irn@oirfn")) _, err := NewReader(source) - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *SuiteReader) TestReadCorruptZLib(c *C) { +func (s *SuiteReader) TestReadCorruptZLib() { data, _ := base64.StdEncoding.DecodeString("eAFLysaalPUjBgAAAJsAHw") source := bytes.NewReader(data) r, err := NewReader(source) - c.Assert(err, IsNil) + s.NoError(err) _, _, err = r.Header() - c.Assert(err, NotNil) + s.NotNil(err) } diff --git a/plumbing/format/objfile/writer.go b/plumbing/format/objfile/writer.go index 0d0f15492..0d9fae321 100644 --- a/plumbing/format/objfile/writer.go +++ b/plumbing/format/objfile/writer.go @@ -6,8 +6,8 @@ import ( "io" "strconv" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/utils/sync" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/utils/sync" ) var ( diff --git a/plumbing/format/objfile/writer_test.go b/plumbing/format/objfile/writer_test.go index 35a951034..c792fd685 100644 --- a/plumbing/format/objfile/writer_test.go +++ b/plumbing/format/objfile/writer_test.go @@ -5,17 +5,22 @@ import ( "encoding/base64" "fmt" "io" + "testing" - "github.com/go-git/go-git/v5/plumbing" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" ) -type SuiteWriter struct{} +type SuiteWriter struct { + suite.Suite +} -var _ = Suite(&SuiteWriter{}) +func TestSuiteWriter(t *testing.T) { + suite.Run(t, new(SuiteWriter)) +} -func (s *SuiteWriter) TestWriteObjfile(c *C) { +func (s *SuiteWriter) TestWriteObjfile() { for k, fixture := range objfileFixtures { buffer := bytes.NewBuffer(nil) @@ -24,58 +29,58 @@ func (s *SuiteWriter) TestWriteObjfile(c *C) { content, _ := base64.StdEncoding.DecodeString(fixture.content) // Write the data out to the buffer - testWriter(c, buffer, hash, fixture.t, content) + testWriter(s.T(), buffer, hash, fixture.t, content) // Read the data back in from the buffer to be sure it matches - testReader(c, buffer, hash, fixture.t, content, com) + testReader(s.T(), buffer, hash, fixture.t, content, com) } } -func testWriter(c *C, dest io.Writer, hash plumbing.Hash, t plumbing.ObjectType, content []byte) { +func testWriter(t *testing.T, dest io.Writer, hash plumbing.Hash, o plumbing.ObjectType, content []byte) { size := int64(len(content)) w := NewWriter(dest) - err := w.WriteHeader(t, size) - c.Assert(err, IsNil) + err := w.WriteHeader(o, size) + assert.NoError(t, err) written, err := io.Copy(w, bytes.NewReader(content)) - c.Assert(err, IsNil) - c.Assert(written, Equals, size) + assert.NoError(t, err) + assert.Equal(t, size, written) - c.Assert(w.Hash(), Equals, hash) - c.Assert(w.Close(), IsNil) + assert.Equal(t, hash, w.Hash()) + assert.NoError(t, w.Close()) } -func (s *SuiteWriter) TestWriteOverflow(c *C) { +func (s *SuiteWriter) TestWriteOverflow() { buf := bytes.NewBuffer(nil) w := NewWriter(buf) err := w.WriteHeader(plumbing.BlobObject, 8) - c.Assert(err, IsNil) + s.NoError(err) n, err := w.Write([]byte("1234")) - c.Assert(err, IsNil) - c.Assert(n, Equals, 4) + s.NoError(err) + s.Equal(4, n) n, err = w.Write([]byte("56789")) - c.Assert(err, Equals, ErrOverflow) - c.Assert(n, Equals, 4) + s.ErrorIs(err, ErrOverflow) + s.Equal(4, n) } -func (s *SuiteWriter) TestNewWriterInvalidType(c *C) { +func (s *SuiteWriter) TestNewWriterInvalidType() { buf := bytes.NewBuffer(nil) w := NewWriter(buf) err := w.WriteHeader(plumbing.InvalidObject, 8) - c.Assert(err, Equals, plumbing.ErrInvalidType) + s.ErrorIs(err, plumbing.ErrInvalidType) } -func (s *SuiteWriter) TestNewWriterInvalidSize(c *C) { +func (s *SuiteWriter) TestNewWriterInvalidSize() { buf := bytes.NewBuffer(nil) w := NewWriter(buf) err := w.WriteHeader(plumbing.BlobObject, -1) - c.Assert(err, Equals, ErrNegativeSize) + s.ErrorIs(err, ErrNegativeSize) err = w.WriteHeader(plumbing.BlobObject, -1651860) - c.Assert(err, Equals, ErrNegativeSize) + s.ErrorIs(err, ErrNegativeSize) } diff --git a/plumbing/format/packfile/common.go b/plumbing/format/packfile/common.go index 36c5ef5b8..a533f977d 100644 --- a/plumbing/format/packfile/common.go +++ b/plumbing/format/packfile/common.go @@ -2,9 +2,12 @@ package packfile import ( "io" + "time" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/utils/sync" + "github.com/jesseduffield/go-git/v5/utils/trace" ) var signature = []byte{'P', 'A', 'C', 'K'} @@ -24,16 +27,18 @@ const ( // UpdateObjectStorage updates the storer with the objects in the given // packfile. func UpdateObjectStorage(s storer.Storer, packfile io.Reader) error { + start := time.Now() + defer func() { + trace.Performance.Printf("performance: %.9f s: update_obj_storage", time.Since(start).Seconds()) + }() + if pw, ok := s.(storer.PackfileWriter); ok { return WritePackfileToObjectStorage(pw, packfile) } - p, err := NewParserWithStorage(NewScanner(packfile), s) - if err != nil { - return err - } + p := NewParser(packfile, WithStorage(s)) - _, err = p.Parse() + _, err := p.Parse() return err } @@ -49,9 +54,12 @@ func WritePackfileToObjectStorage( } defer ioutil.CheckClose(w, &err) - var n int64 - n, err = io.Copy(w, packfile) + + buf := sync.GetByteSlice() + n, err = io.CopyBuffer(w, packfile, *buf) + sync.PutByteSlice(buf) + if err == nil && n == 0 { return ErrEmptyPackfile } diff --git a/plumbing/format/packfile/common_test.go b/plumbing/format/packfile/common_test.go index c6d1038d3..1ff560547 100644 --- a/plumbing/format/packfile/common_test.go +++ b/plumbing/format/packfile/common_test.go @@ -4,24 +4,17 @@ import ( "bytes" "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/storage/memory" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/assert" ) -func Test(t *testing.T) { TestingT(t) } - -type CommonSuite struct{} - -var _ = Suite(&CommonSuite{}) - -func (s *CommonSuite) TestEmptyUpdateObjectStorage(c *C) { +func TestEmptyUpdateObjectStorage(t *testing.T) { var buf bytes.Buffer sto := memory.NewStorage() err := UpdateObjectStorage(sto, &buf) - c.Assert(err, Equals, ErrEmptyPackfile) + assert.ErrorIs(t, err, ErrEmptyPackfile) } func newObject(t plumbing.ObjectType, cont []byte) plumbing.EncodedObject { diff --git a/plumbing/format/packfile/delta_selector.go b/plumbing/format/packfile/delta_selector.go index 4b60ff394..1741fbd22 100644 --- a/plumbing/format/packfile/delta_selector.go +++ b/plumbing/format/packfile/delta_selector.go @@ -4,8 +4,8 @@ import ( "sort" "sync" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" ) const ( diff --git a/plumbing/format/packfile/delta_selector_test.go b/plumbing/format/packfile/delta_selector_test.go index 3d196d35f..e097f8010 100644 --- a/plumbing/format/packfile/delta_selector_test.go +++ b/plumbing/format/packfile/delta_selector_test.go @@ -1,27 +1,31 @@ package packfile import ( - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/storage/memory" + "testing" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/suite" ) type DeltaSelectorSuite struct { + suite.Suite ds *deltaSelector store *memory.Storage hashes map[string]plumbing.Hash } -var _ = Suite(&DeltaSelectorSuite{}) +func TestDeltaSelectorSuite(t *testing.T) { + suite.Run(t, new(DeltaSelectorSuite)) +} -func (s *DeltaSelectorSuite) SetUpTest(c *C) { +func (s *DeltaSelectorSuite) SetupTest() { s.store = memory.NewStorage() s.createTestObjects() s.ds = newDeltaSelector(s.store) } -func (s *DeltaSelectorSuite) TestSort(c *C) { +func (s *DeltaSelectorSuite) TestSort() { var o1 = newObjectToPack(newObject(plumbing.BlobObject, []byte("00000"))) var o4 = newObjectToPack(newObject(plumbing.BlobObject, []byte("0000"))) var o6 = newObjectToPack(newObject(plumbing.BlobObject, []byte("00"))) @@ -35,7 +39,7 @@ func (s *DeltaSelectorSuite) TestSort(c *C) { toSort := []*ObjectToPack{o1, o2, o3, o4, o5, o6, o7, o8, o9} s.ds.sort(toSort) expected := []*ObjectToPack{o1, o4, o6, o9, o8, o2, o3, o5, o7} - c.Assert(toSort, DeepEquals, expected) + s.Equal(expected, toSort) } type testObject struct { @@ -143,42 +147,42 @@ func (s *DeltaSelectorSuite) createTestObjects() { } } -func (s *DeltaSelectorSuite) TestObjectsToPack(c *C) { +func (s *DeltaSelectorSuite) TestObjectsToPack() { // Different type hashes := []plumbing.Hash{s.hashes["base"], s.hashes["treeType"]} deltaWindowSize := uint(10) otp, err := s.ds.ObjectsToPack(hashes, deltaWindowSize) - c.Assert(err, IsNil) - c.Assert(len(otp), Equals, 2) - c.Assert(otp[0].Object, Equals, s.store.Objects[s.hashes["base"]]) - c.Assert(otp[1].Object, Equals, s.store.Objects[s.hashes["treeType"]]) + s.NoError(err) + s.Len(otp, 2) + s.Equal(s.store.Objects[s.hashes["base"]], otp[0].Object) + s.Equal(s.store.Objects[s.hashes["treeType"]], otp[1].Object) // Size radically different hashes = []plumbing.Hash{s.hashes["bigBase"], s.hashes["target"]} otp, err = s.ds.ObjectsToPack(hashes, deltaWindowSize) - c.Assert(err, IsNil) - c.Assert(len(otp), Equals, 2) - c.Assert(otp[0].Object, Equals, s.store.Objects[s.hashes["bigBase"]]) - c.Assert(otp[1].Object, Equals, s.store.Objects[s.hashes["target"]]) + s.NoError(err) + s.Len(otp, 2) + s.Equal(s.store.Objects[s.hashes["bigBase"]], otp[0].Object) + s.Equal(s.store.Objects[s.hashes["target"]], otp[1].Object) // Delta Size Limit with no best delta yet hashes = []plumbing.Hash{s.hashes["smallBase"], s.hashes["smallTarget"]} otp, err = s.ds.ObjectsToPack(hashes, deltaWindowSize) - c.Assert(err, IsNil) - c.Assert(len(otp), Equals, 2) - c.Assert(otp[0].Object, Equals, s.store.Objects[s.hashes["smallBase"]]) - c.Assert(otp[1].Object, Equals, s.store.Objects[s.hashes["smallTarget"]]) + s.NoError(err) + s.Len(otp, 2) + s.Equal(s.store.Objects[s.hashes["smallBase"]], otp[0].Object) + s.Equal(s.store.Objects[s.hashes["smallTarget"]], otp[1].Object) // It will create the delta hashes = []plumbing.Hash{s.hashes["base"], s.hashes["target"]} otp, err = s.ds.ObjectsToPack(hashes, deltaWindowSize) - c.Assert(err, IsNil) - c.Assert(len(otp), Equals, 2) - c.Assert(otp[0].Object, Equals, s.store.Objects[s.hashes["target"]]) - c.Assert(otp[0].IsDelta(), Equals, false) - c.Assert(otp[1].Original, Equals, s.store.Objects[s.hashes["base"]]) - c.Assert(otp[1].IsDelta(), Equals, true) - c.Assert(otp[1].Depth, Equals, 1) + s.NoError(err) + s.Len(otp, 2) + s.Equal(s.store.Objects[s.hashes["target"]], otp[0].Object) + s.False(otp[0].IsDelta()) + s.Equal(s.store.Objects[s.hashes["base"]], otp[1].Original) + s.True(otp[1].IsDelta()) + s.Equal(1, otp[1].Depth) // If our base is another delta, the depth will increase by one hashes = []plumbing.Hash{ @@ -187,16 +191,16 @@ func (s *DeltaSelectorSuite) TestObjectsToPack(c *C) { s.hashes["o3"], } otp, err = s.ds.ObjectsToPack(hashes, deltaWindowSize) - c.Assert(err, IsNil) - c.Assert(len(otp), Equals, 3) - c.Assert(otp[0].Object, Equals, s.store.Objects[s.hashes["o1"]]) - c.Assert(otp[0].IsDelta(), Equals, false) - c.Assert(otp[1].Original, Equals, s.store.Objects[s.hashes["o2"]]) - c.Assert(otp[1].IsDelta(), Equals, true) - c.Assert(otp[1].Depth, Equals, 1) - c.Assert(otp[2].Original, Equals, s.store.Objects[s.hashes["o3"]]) - c.Assert(otp[2].IsDelta(), Equals, true) - c.Assert(otp[2].Depth, Equals, 2) + s.NoError(err) + s.Len(otp, 3) + s.Equal(s.store.Objects[s.hashes["o1"]], otp[0].Object) + s.False(otp[0].IsDelta()) + s.Equal(s.store.Objects[s.hashes["o2"]], otp[1].Original) + s.True(otp[1].IsDelta()) + s.Equal(1, otp[1].Depth) + s.Equal(s.store.Objects[s.hashes["o3"]], otp[2].Original) + s.True(otp[2].IsDelta()) + s.Equal(2, otp[2].Depth) // Check that objects outside of the sliding window don't produce // a delta. @@ -210,27 +214,27 @@ func (s *DeltaSelectorSuite) TestObjectsToPack(c *C) { // Don't sort so we can easily check the sliding window without // creating a bunch of new objects. otp, err = s.ds.objectsToPack(hashes, deltaWindowSize) - c.Assert(err, IsNil) + s.NoError(err) err = s.ds.walk(otp, deltaWindowSize) - c.Assert(err, IsNil) - c.Assert(len(otp), Equals, int(deltaWindowSize)+2) + s.NoError(err) + s.Len(otp, int(deltaWindowSize)+2) targetIdx := len(otp) - 1 - c.Assert(otp[targetIdx].IsDelta(), Equals, false) + s.False(otp[targetIdx].IsDelta()) // Check that no deltas are created, and the objects are unsorted, // if compression is off. hashes = []plumbing.Hash{s.hashes["base"], s.hashes["target"]} otp, err = s.ds.ObjectsToPack(hashes, 0) - c.Assert(err, IsNil) - c.Assert(len(otp), Equals, 2) - c.Assert(otp[0].Object, Equals, s.store.Objects[s.hashes["base"]]) - c.Assert(otp[0].IsDelta(), Equals, false) - c.Assert(otp[1].Original, Equals, s.store.Objects[s.hashes["target"]]) - c.Assert(otp[1].IsDelta(), Equals, false) - c.Assert(otp[1].Depth, Equals, 0) + s.NoError(err) + s.Len(otp, 2) + s.Equal(s.store.Objects[s.hashes["base"]], otp[0].Object) + s.False(otp[0].IsDelta()) + s.Equal(s.store.Objects[s.hashes["target"]], otp[1].Original) + s.False(otp[1].IsDelta()) + s.Equal(0, otp[1].Depth) } -func (s *DeltaSelectorSuite) TestMaxDepth(c *C) { +func (s *DeltaSelectorSuite) TestMaxDepth() { dsl := s.ds.deltaSizeLimit(0, 0, int(maxDepth), true) - c.Assert(dsl, Equals, int64(0)) + s.Equal(int64(0), dsl) } diff --git a/plumbing/format/packfile/delta_test.go b/plumbing/format/packfile/delta_test.go index 9417e558a..43ae7b195 100644 --- a/plumbing/format/packfile/delta_test.go +++ b/plumbing/format/packfile/delta_test.go @@ -6,15 +6,18 @@ import ( "math/rand" "testing" - "github.com/go-git/go-git/v5/plumbing" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/stretchr/testify/suite" ) type DeltaSuite struct { + suite.Suite testCases []deltaTest } -var _ = Suite(&DeltaSuite{}) +func TestDeltaSuite(t *testing.T) { + suite.Run(t, new(DeltaSuite)) +} type deltaTest struct { description string @@ -22,7 +25,7 @@ type deltaTest struct { target []piece } -func (s *DeltaSuite) SetUpSuite(c *C) { +func (s *DeltaSuite) SetupSuite() { s.testCases = []deltaTest{{ description: "distinct file", base: []piece{{"0", 300}}, @@ -88,20 +91,20 @@ func randStringBytes(n int) string { return string(randBytes(n)) } -func (s *DeltaSuite) TestAddDelta(c *C) { +func (s *DeltaSuite) TestAddDelta() { for _, t := range s.testCases { baseBuf := genBytes(t.base) targetBuf := genBytes(t.target) delta := DiffDelta(baseBuf, targetBuf) result, err := PatchDelta(baseBuf, delta) - c.Log("Executing test case:", t.description) - c.Assert(err, IsNil) - c.Assert(result, DeepEquals, targetBuf) + s.T().Log("Executing test case:", t.description) + s.NoError(err) + s.Equal(targetBuf, result) } } -func (s *DeltaSuite) TestAddDeltaReader(c *C) { +func (s *DeltaSuite) TestAddDeltaReader() { for _, t := range s.testCases { baseBuf := genBytes(t.base) baseObj := &plumbing.MemoryObject{} @@ -112,51 +115,51 @@ func (s *DeltaSuite) TestAddDeltaReader(c *C) { delta := DiffDelta(baseBuf, targetBuf) deltaRC := io.NopCloser(bytes.NewReader(delta)) - c.Log("Executing test case:", t.description) + s.T().Log("Executing test case:", t.description) resultRC, err := ReaderFromDelta(baseObj, deltaRC) - c.Assert(err, IsNil) + s.NoError(err) result, err := io.ReadAll(resultRC) - c.Assert(err, IsNil) + s.NoError(err) err = resultRC.Close() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(result, DeepEquals, targetBuf) + s.Equal(targetBuf, result) } } -func (s *DeltaSuite) TestIncompleteDelta(c *C) { +func (s *DeltaSuite) TestIncompleteDelta() { for _, t := range s.testCases { - c.Log("Incomplete delta on:", t.description) + s.T().Log("Incomplete delta on:", t.description) baseBuf := genBytes(t.base) targetBuf := genBytes(t.target) delta := DiffDelta(baseBuf, targetBuf) delta = delta[:len(delta)-2] result, err := PatchDelta(baseBuf, delta) - c.Assert(err, NotNil) - c.Assert(result, IsNil) + s.NotNil(err) + s.Nil(result) } // check nil input too result, err := PatchDelta(nil, nil) - c.Assert(err, NotNil) - c.Assert(result, IsNil) + s.NotNil(err) + s.Nil(result) } -func (s *DeltaSuite) TestMaxCopySizeDelta(c *C) { +func (s *DeltaSuite) TestMaxCopySizeDelta() { baseBuf := randBytes(maxCopySize) targetBuf := baseBuf[0:] targetBuf = append(targetBuf, byte(1)) delta := DiffDelta(baseBuf, targetBuf) result, err := PatchDelta(baseBuf, delta) - c.Assert(err, IsNil) - c.Assert(result, DeepEquals, targetBuf) + s.NoError(err) + s.Equal(targetBuf, result) } -func (s *DeltaSuite) TestMaxCopySizeDeltaReader(c *C) { +func (s *DeltaSuite) TestMaxCopySizeDeltaReader() { baseBuf := randBytes(maxCopySize) baseObj := &plumbing.MemoryObject{} baseObj.Write(baseBuf) @@ -168,23 +171,23 @@ func (s *DeltaSuite) TestMaxCopySizeDeltaReader(c *C) { deltaRC := io.NopCloser(bytes.NewReader(delta)) resultRC, err := ReaderFromDelta(baseObj, deltaRC) - c.Assert(err, IsNil) + s.NoError(err) result, err := io.ReadAll(resultRC) - c.Assert(err, IsNil) + s.NoError(err) err = resultRC.Close() - c.Assert(err, IsNil) - c.Assert(result, DeepEquals, targetBuf) + s.NoError(err) + s.Equal(targetBuf, result) } func FuzzPatchDelta(f *testing.F) { + f.Add([]byte("some value"), []byte("\n\f\fsomenewvalue")) + f.Add([]byte("some value"), []byte("\n\x0e\x0evalue")) + f.Add([]byte("some value"), []byte("\n\x0e\x0eva")) + f.Add([]byte("some value"), []byte("\n\x80\x80\x80\x80\x80\x802\x7fvalue")) - f.Fuzz(func(t *testing.T, input []byte) { - - input_0 := input[:len(input)/2] - input_1 := input[len(input)/2:] - - PatchDelta(input_0, input_1) + f.Fuzz(func(t *testing.T, input1, input2 []byte) { + PatchDelta(input1, input2) }) } diff --git a/plumbing/format/packfile/diff_delta.go b/plumbing/format/packfile/diff_delta.go index 8898e5830..bbb36cf26 100644 --- a/plumbing/format/packfile/diff_delta.go +++ b/plumbing/format/packfile/diff_delta.go @@ -3,9 +3,9 @@ package packfile import ( "bytes" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/utils/ioutil" - "github.com/go-git/go-git/v5/utils/sync" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/utils/sync" ) // See https://github.com/jelmer/dulwich/blob/master/dulwich/pack.py and diff --git a/plumbing/format/packfile/encoder.go b/plumbing/format/packfile/encoder.go index 804f5a876..1d228b5c0 100644 --- a/plumbing/format/packfile/encoder.go +++ b/plumbing/format/packfile/encoder.go @@ -5,11 +5,11 @@ import ( "fmt" "io" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/hash" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/utils/binary" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/hash" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/utils/binary" + "github.com/jesseduffield/go-git/v5/utils/ioutil" ) // Encoder gets the data from the storage and write it into the writer in PACK diff --git a/plumbing/format/packfile/encoder_advanced_test.go b/plumbing/format/packfile/encoder_advanced_test.go index 15c0fba40..09686a0d1 100644 --- a/plumbing/format/packfile/encoder_advanced_test.go +++ b/plumbing/format/packfile/encoder_advanced_test.go @@ -6,59 +6,67 @@ import ( "math/rand" "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/format/idxfile" - . "github.com/go-git/go-git/v5/plumbing/format/packfile" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/format/idxfile" + . "github.com/jesseduffield/go-git/v5/plumbing/format/packfile" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/stretchr/testify/suite" "github.com/go-git/go-billy/v5/memfs" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) -type EncoderAdvancedSuite struct { +type EncoderAdvancedFixtureSuite struct { fixtures.Suite } -var _ = Suite(&EncoderAdvancedSuite{}) +type EncoderAdvancedSuite struct { + suite.Suite + EncoderAdvancedFixtureSuite +} + +func TestEncoderAdvancedSuite(t *testing.T) { + suite.Run(t, new(EncoderAdvancedSuite)) +} -func (s *EncoderAdvancedSuite) TestEncodeDecode(c *C) { +func (s *EncoderAdvancedSuite) TestEncodeDecode() { if testing.Short() { - c.Skip("skipping test in short mode.") + s.T().Skip("skipping test in short mode.") } fixs := fixtures.Basic().ByTag("packfile").ByTag(".git") fixs = append(fixs, fixtures.ByURL("https://github.com/src-d/go-git.git"). ByTag("packfile").ByTag(".git").One()) - fixs.Test(c, func(f *fixtures.Fixture) { + + for _, f := range fixs { storage := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) - s.testEncodeDecode(c, storage, 10) - }) + s.testEncodeDecode(storage, 10) + } } -func (s *EncoderAdvancedSuite) TestEncodeDecodeNoDeltaCompression(c *C) { +func (s *EncoderAdvancedSuite) TestEncodeDecodeNoDeltaCompression() { if testing.Short() { - c.Skip("skipping test in short mode.") + s.T().Skip("skipping test in short mode.") } fixs := fixtures.Basic().ByTag("packfile").ByTag(".git") fixs = append(fixs, fixtures.ByURL("https://github.com/src-d/go-git.git"). ByTag("packfile").ByTag(".git").One()) - fixs.Test(c, func(f *fixtures.Fixture) { + + for _, f := range fixs { storage := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) - s.testEncodeDecode(c, storage, 0) - }) + s.testEncodeDecode(storage, 0) + } } func (s *EncoderAdvancedSuite) testEncodeDecode( - c *C, storage storer.Storer, packWindow uint, ) { objIter, err := storage.IterEncodedObjects(plumbing.AnyObject) - c.Assert(err, IsNil) + s.NoError(err) expectedObjects := map[plumbing.Hash]bool{} var hashes []plumbing.Hash @@ -68,7 +76,7 @@ func (s *EncoderAdvancedSuite) testEncodeDecode( return err }) - c.Assert(err, IsNil) + s.NoError(err) // Shuffle hashes to avoid delta selector getting order right just because // the initial order is correct. @@ -81,55 +89,54 @@ func (s *EncoderAdvancedSuite) testEncodeDecode( buf := bytes.NewBuffer(nil) enc := NewEncoder(buf, storage, false) encodeHash, err := enc.Encode(hashes, packWindow) - c.Assert(err, IsNil) + s.NoError(err) fs := memfs.New() f, err := fs.Create("packfile") - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write(buf.Bytes()) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Seek(0, io.SeekStart) - c.Assert(err, IsNil) + s.NoError(err) w := new(idxfile.Writer) - parser, err := NewParser(NewScanner(f), w) - c.Assert(err, IsNil) + parser := NewParser(NewScanner(f), WithScannerObservers(w)) _, err = parser.Parse() - c.Assert(err, IsNil) + s.NoError(err) index, err := w.Index() - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Seek(0, io.SeekStart) - c.Assert(err, IsNil) + s.NoError(err) - p := NewPackfile(index, fs, f, 0) + p := NewPackfile(f, WithIdx(index), WithFs(fs)) decodeHash, err := p.ID() - c.Assert(err, IsNil) - c.Assert(encodeHash, Equals, decodeHash) + s.NoError(err) + s.Equal(decodeHash, encodeHash) objIter, err = p.GetAll() - c.Assert(err, IsNil) + s.NoError(err) obtainedObjects := map[plumbing.Hash]bool{} err = objIter.ForEach(func(o plumbing.EncodedObject) error { obtainedObjects[o.Hash()] = true return nil }) - c.Assert(err, IsNil) - c.Assert(obtainedObjects, DeepEquals, expectedObjects) + s.NoError(err) + s.Equal(expectedObjects, obtainedObjects) for h := range obtainedObjects { if !expectedObjects[h] { - c.Errorf("obtained unexpected object: %s", h) + s.T().Errorf("obtained unexpected object: %s", h) } } for h := range expectedObjects { if !obtainedObjects[h] { - c.Errorf("missing object: %s", h) + s.T().Errorf("missing object: %s", h) } } } diff --git a/plumbing/format/packfile/encoder_test.go b/plumbing/format/packfile/encoder_test.go index 6719f376a..e94e0657e 100644 --- a/plumbing/format/packfile/encoder_test.go +++ b/plumbing/format/packfile/encoder_test.go @@ -3,35 +3,43 @@ package packfile import ( "bytes" "io" + "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/idxfile" - "github.com/go-git/go-git/v5/plumbing/hash" - "github.com/go-git/go-git/v5/storage/memory" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/idxfile" + "github.com/jesseduffield/go-git/v5/plumbing/hash" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/suite" "github.com/go-git/go-billy/v5/memfs" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) -type EncoderSuite struct { +type EncoderFixtureSuite struct { fixtures.Suite +} + +type EncoderSuite struct { + suite.Suite + EncoderFixtureSuite buf *bytes.Buffer store *memory.Storage enc *Encoder } -var _ = Suite(&EncoderSuite{}) +func TestEncoderSuite(t *testing.T) { + suite.Run(t, new(EncoderSuite)) +} -func (s *EncoderSuite) SetUpTest(c *C) { +func (s *EncoderSuite) SetupTest() { s.buf = bytes.NewBuffer(nil) s.store = memory.NewStorage() s.enc = NewEncoder(s.buf, s.store, false) } -func (s *EncoderSuite) TestCorrectPackHeader(c *C) { +func (s *EncoderSuite) TestCorrectPackHeader() { h, err := s.enc.Encode([]plumbing.Hash{}, 10) - c.Assert(err, IsNil) + s.NoError(err) hb := [hash.Size]byte(h) @@ -41,18 +49,18 @@ func (s *EncoderSuite) TestCorrectPackHeader(c *C) { result := s.buf.Bytes() - c.Assert(result, DeepEquals, expectedResult) + s.Equal(expectedResult, result) } -func (s *EncoderSuite) TestCorrectPackWithOneEmptyObject(c *C) { +func (s *EncoderSuite) TestCorrectPackWithOneEmptyObject() { o := &plumbing.MemoryObject{} o.SetType(plumbing.CommitObject) o.SetSize(0) _, err := s.store.SetEncodedObject(o) - c.Assert(err, IsNil) + s.NoError(err) h, err := s.enc.Encode([]plumbing.Hash{o.Hash()}, 10) - c.Assert(err, IsNil) + s.NoError(err) // PACK + VERSION(2) + OBJECT NUMBER(1) expectedResult := []byte{'P', 'A', 'C', 'K', 0, 0, 0, 2, 0, 0, 0, 1} @@ -69,99 +77,99 @@ func (s *EncoderSuite) TestCorrectPackWithOneEmptyObject(c *C) { result := s.buf.Bytes() - c.Assert(result, DeepEquals, expectedResult) + s.Equal(expectedResult, result) } -func (s *EncoderSuite) TestMaxObjectSize(c *C) { +func (s *EncoderSuite) TestMaxObjectSize() { o := s.store.NewEncodedObject() o.SetSize(9223372036854775807) o.SetType(plumbing.CommitObject) _, err := s.store.SetEncodedObject(o) - c.Assert(err, IsNil) + s.NoError(err) hash, err := s.enc.Encode([]plumbing.Hash{o.Hash()}, 10) - c.Assert(err, IsNil) - c.Assert(hash.IsZero(), Not(Equals), true) + s.NoError(err) + s.NotEqual(true, hash.IsZero()) } -func (s *EncoderSuite) TestHashNotFound(c *C) { +func (s *EncoderSuite) TestHashNotFound() { h, err := s.enc.Encode([]plumbing.Hash{plumbing.NewHash("BAD")}, 10) - c.Assert(h, Equals, plumbing.ZeroHash) - c.Assert(err, NotNil) - c.Assert(err, Equals, plumbing.ErrObjectNotFound) + s.Equal(plumbing.ZeroHash, h) + s.NotNil(err) + s.ErrorIs(err, plumbing.ErrObjectNotFound) } -func (s *EncoderSuite) TestDecodeEncodeWithDeltaDecodeREF(c *C) { +func (s *EncoderSuite) TestDecodeEncodeWithDeltaDecodeREF() { s.enc = NewEncoder(s.buf, s.store, true) - s.simpleDeltaTest(c) + s.simpleDeltaTest() } -func (s *EncoderSuite) TestDecodeEncodeWithDeltaDecodeOFS(c *C) { +func (s *EncoderSuite) TestDecodeEncodeWithDeltaDecodeOFS() { s.enc = NewEncoder(s.buf, s.store, false) - s.simpleDeltaTest(c) + s.simpleDeltaTest() } -func (s *EncoderSuite) TestDecodeEncodeWithDeltasDecodeREF(c *C) { +func (s *EncoderSuite) TestDecodeEncodeWithDeltasDecodeREF() { s.enc = NewEncoder(s.buf, s.store, true) - s.deltaOverDeltaTest(c) + s.deltaOverDeltaTest() } -func (s *EncoderSuite) TestDecodeEncodeWithDeltasDecodeOFS(c *C) { +func (s *EncoderSuite) TestDecodeEncodeWithDeltasDecodeOFS() { s.enc = NewEncoder(s.buf, s.store, false) - s.deltaOverDeltaTest(c) + s.deltaOverDeltaTest() } -func (s *EncoderSuite) TestDecodeEncodeWithCycleREF(c *C) { +func (s *EncoderSuite) TestDecodeEncodeWithCycleREF() { s.enc = NewEncoder(s.buf, s.store, true) - s.deltaOverDeltaCyclicTest(c) + s.deltaOverDeltaCyclicTest() } -func (s *EncoderSuite) TestDecodeEncodeWithCycleOFS(c *C) { +func (s *EncoderSuite) TestDecodeEncodeWithCycleOFS() { s.enc = NewEncoder(s.buf, s.store, false) - s.deltaOverDeltaCyclicTest(c) + s.deltaOverDeltaCyclicTest() } -func (s *EncoderSuite) simpleDeltaTest(c *C) { +func (s *EncoderSuite) simpleDeltaTest() { srcObject := newObject(plumbing.BlobObject, []byte("0")) targetObject := newObject(plumbing.BlobObject, []byte("01")) deltaObject, err := GetDelta(srcObject, targetObject) - c.Assert(err, IsNil) + s.NoError(err) srcToPack := newObjectToPack(srcObject) encHash, err := s.enc.encode([]*ObjectToPack{ srcToPack, newDeltaObjectToPack(srcToPack, targetObject, deltaObject), }) - c.Assert(err, IsNil) + s.NoError(err) - p, cleanup := packfileFromReader(c, s.buf) + p, cleanup := packfileFromReader(s, s.buf) defer cleanup() decHash, err := p.ID() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(encHash, Equals, decHash) + s.Equal(decHash, encHash) decSrc, err := p.Get(srcObject.Hash()) - c.Assert(err, IsNil) - objectsEqual(c, decSrc, srcObject) + s.NoError(err) + objectsEqual(s, decSrc, srcObject) decTarget, err := p.Get(targetObject.Hash()) - c.Assert(err, IsNil) - objectsEqual(c, decTarget, targetObject) + s.NoError(err) + objectsEqual(s, decTarget, targetObject) } -func (s *EncoderSuite) deltaOverDeltaTest(c *C) { +func (s *EncoderSuite) deltaOverDeltaTest() { srcObject := newObject(plumbing.BlobObject, []byte("0")) targetObject := newObject(plumbing.BlobObject, []byte("01")) otherTargetObject := newObject(plumbing.BlobObject, []byte("011111")) deltaObject, err := GetDelta(srcObject, targetObject) - c.Assert(err, IsNil) - c.Assert(deltaObject.Hash(), Not(Equals), plumbing.ZeroHash) + s.NoError(err) + s.NotEqual(plumbing.ZeroHash, deltaObject.Hash()) otherDeltaObject, err := GetDelta(targetObject, otherTargetObject) - c.Assert(err, IsNil) - c.Assert(otherDeltaObject.Hash(), Not(Equals), plumbing.ZeroHash) + s.NoError(err) + s.NotEqual(plumbing.ZeroHash, otherDeltaObject.Hash()) srcToPack := newObjectToPack(srcObject) targetToPack := newObjectToPack(targetObject) @@ -171,51 +179,51 @@ func (s *EncoderSuite) deltaOverDeltaTest(c *C) { newDeltaObjectToPack(srcToPack, targetObject, deltaObject), newDeltaObjectToPack(targetToPack, otherTargetObject, otherDeltaObject), }) - c.Assert(err, IsNil) + s.NoError(err) - p, cleanup := packfileFromReader(c, s.buf) + p, cleanup := packfileFromReader(s, s.buf) defer cleanup() decHash, err := p.ID() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(encHash, Equals, decHash) + s.Equal(decHash, encHash) decSrc, err := p.Get(srcObject.Hash()) - c.Assert(err, IsNil) - objectsEqual(c, decSrc, srcObject) + s.NoError(err) + objectsEqual(s, decSrc, srcObject) decTarget, err := p.Get(targetObject.Hash()) - c.Assert(err, IsNil) - objectsEqual(c, decTarget, targetObject) + s.NoError(err) + objectsEqual(s, decTarget, targetObject) decOtherTarget, err := p.Get(otherTargetObject.Hash()) - c.Assert(err, IsNil) - objectsEqual(c, decOtherTarget, otherTargetObject) + s.NoError(err) + objectsEqual(s, decOtherTarget, otherTargetObject) } -func (s *EncoderSuite) deltaOverDeltaCyclicTest(c *C) { +func (s *EncoderSuite) deltaOverDeltaCyclicTest() { o1 := newObject(plumbing.BlobObject, []byte("0")) o2 := newObject(plumbing.BlobObject, []byte("01")) o3 := newObject(plumbing.BlobObject, []byte("011111")) o4 := newObject(plumbing.BlobObject, []byte("01111100000")) _, err := s.store.SetEncodedObject(o1) - c.Assert(err, IsNil) + s.NoError(err) _, err = s.store.SetEncodedObject(o2) - c.Assert(err, IsNil) + s.NoError(err) _, err = s.store.SetEncodedObject(o3) - c.Assert(err, IsNil) + s.NoError(err) _, err = s.store.SetEncodedObject(o4) - c.Assert(err, IsNil) + s.NoError(err) d2, err := GetDelta(o1, o2) - c.Assert(err, IsNil) + s.NoError(err) d3, err := GetDelta(o4, o3) - c.Assert(err, IsNil) + s.NoError(err) d4, err := GetDelta(o3, o4) - c.Assert(err, IsNil) + s.NoError(err) po1 := newObjectToPack(o1) pd2 := newDeltaObjectToPack(po1, o2, d2) @@ -243,82 +251,84 @@ func (s *EncoderSuite) deltaOverDeltaCyclicTest(c *C) { pd3, pd4, }) - c.Assert(err, IsNil) + s.NoError(err) - p, cleanup := packfileFromReader(c, s.buf) + p, cleanup := packfileFromReader(s, s.buf) defer cleanup() decHash, err := p.ID() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(encHash, Equals, decHash) + s.Equal(decHash, encHash) decSrc, err := p.Get(o1.Hash()) - c.Assert(err, IsNil) - objectsEqual(c, decSrc, o1) + s.NoError(err) + objectsEqual(s, decSrc, o1) decTarget, err := p.Get(o2.Hash()) - c.Assert(err, IsNil) - objectsEqual(c, decTarget, o2) + s.NoError(err) + objectsEqual(s, decTarget, o2) decOtherTarget, err := p.Get(o3.Hash()) - c.Assert(err, IsNil) - objectsEqual(c, decOtherTarget, o3) + s.NoError(err) + objectsEqual(s, decOtherTarget, o3) decAnotherTarget, err := p.Get(o4.Hash()) - c.Assert(err, IsNil) - objectsEqual(c, decAnotherTarget, o4) + s.NoError(err) + objectsEqual(s, decAnotherTarget, o4) } -func objectsEqual(c *C, o1, o2 plumbing.EncodedObject) { - c.Assert(o1.Type(), Equals, o2.Type()) - c.Assert(o1.Hash(), Equals, o2.Hash()) - c.Assert(o1.Size(), Equals, o2.Size()) +func objectsEqual(s *EncoderSuite, o1, o2 plumbing.EncodedObject) { + s.Equal(o2.Type(), o1.Type()) + s.Equal(o2.Hash(), o1.Hash()) + s.Equal(o2.Size(), o1.Size()) r1, err := o1.Reader() - c.Assert(err, IsNil) + s.NoError(err) b1, err := io.ReadAll(r1) - c.Assert(err, IsNil) + s.NoError(err) r2, err := o2.Reader() - c.Assert(err, IsNil) + s.NoError(err) b2, err := io.ReadAll(r2) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(bytes.Compare(b1, b2), Equals, 0) + s.Equal(0, bytes.Compare(b1, b2)) err = r2.Close() - c.Assert(err, IsNil) + s.NoError(err) err = r1.Close() - c.Assert(err, IsNil) + s.NoError(err) } -func packfileFromReader(c *C, buf *bytes.Buffer) (*Packfile, func()) { +func packfileFromReader(s *EncoderSuite, buf *bytes.Buffer) (*Packfile, func()) { fs := memfs.New() file, err := fs.Create("packfile") - c.Assert(err, IsNil) + s.NoError(err) _, err = file.Write(buf.Bytes()) - c.Assert(err, IsNil) + s.NoError(err) _, err = file.Seek(0, io.SeekStart) - c.Assert(err, IsNil) + s.NoError(err) scanner := NewScanner(file) w := new(idxfile.Writer) - p, err := NewParser(scanner, w) - c.Assert(err, IsNil) + p := NewParser(scanner, WithScannerObservers(w)) _, err = p.Parse() - c.Assert(err, IsNil) + s.NoError(err) index, err := w.Index() - c.Assert(err, IsNil) + s.NoError(err) + + _, err = file.Seek(0, io.SeekStart) + s.NoError(err) - return NewPackfile(index, fs, file, 0), func() { - c.Assert(file.Close(), IsNil) + return NewPackfile(file, WithIdx(index), WithFs(fs)), func() { + s.NoError(file.Close()) } } diff --git a/plumbing/format/packfile/fsobject.go b/plumbing/format/packfile/fsobject.go index 238339daf..861ebe231 100644 --- a/plumbing/format/packfile/fsobject.go +++ b/plumbing/format/packfile/fsobject.go @@ -1,26 +1,28 @@ package packfile import ( + "errors" "io" + "os" billy "github.com/go-git/go-billy/v5" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/format/idxfile" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/format/idxfile" + "github.com/jesseduffield/go-git/v5/utils/sync" ) // FSObject is an object from the packfile on the filesystem. type FSObject struct { - hash plumbing.Hash - offset int64 - size int64 - typ plumbing.ObjectType - index idxfile.Index - fs billy.Filesystem - path string - cache cache.Object - largeObjectThreshold int64 + hash plumbing.Hash + offset int64 + size int64 + typ plumbing.ObjectType + index idxfile.Index + fs billy.Filesystem + pack billy.File + packPath string + cache cache.Object } // NewFSObject creates a new filesystem object. @@ -31,20 +33,20 @@ func NewFSObject( contentSize int64, index idxfile.Index, fs billy.Filesystem, - path string, + pack billy.File, + packPath string, cache cache.Object, - largeObjectThreshold int64, ) *FSObject { return &FSObject{ - hash: hash, - offset: offset, - size: contentSize, - typ: finalType, - index: index, - fs: fs, - path: path, - cache: cache, - largeObjectThreshold: largeObjectThreshold, + hash: hash, + offset: offset, + size: contentSize, + typ: finalType, + index: index, + fs: fs, + pack: pack, + packPath: packPath, + cache: cache, } } @@ -60,37 +62,50 @@ func (o *FSObject) Reader() (io.ReadCloser, error) { return reader, nil } - f, err := o.fs.Open(o.path) - if err != nil { - return nil, err - } - - p := NewPackfileWithCache(o.index, nil, f, o.cache, o.largeObjectThreshold) - if o.largeObjectThreshold > 0 && o.size > o.largeObjectThreshold { - // We have a big object - h, err := p.objectHeaderAtOffset(o.offset) - if err != nil { - return nil, err - } - - r, err := p.getReaderDirect(h) + var closer io.Closer + _, err := o.pack.Seek(o.offset, io.SeekStart) + // fsobject aims to reuse an existing file descriptor to the packfile. + // In some cases that descriptor would already be closed, in such cases, + // open the packfile again and close it when the reader is closed. + if err != nil && errors.Is(err, os.ErrClosed) { + o.pack, err = o.fs.Open(o.packPath) if err != nil { - _ = f.Close() return nil, err } - return ioutil.NewReadCloserWithCloser(r, f.Close), nil + closer = o.pack + _, err = o.pack.Seek(o.offset, io.SeekStart) } - r, err := p.getObjectContent(o.offset) if err != nil { - _ = f.Close() return nil, err } - if err := f.Close(); err != nil { + dict := sync.GetByteSlice() + zr := sync.NewZlibReader(dict) + err = zr.Reset(o.pack) + if err != nil { return nil, err } + return &zlibReadCloser{zr, dict, closer}, nil +} + +type zlibReadCloser struct { + r sync.ZLibReader + dict *[]byte + f io.Closer +} - return r, nil +// Read reads up to len(p) bytes into p from the data. +func (r *zlibReadCloser) Read(p []byte) (int, error) { + return r.r.Reader.Read(p) +} + +func (r *zlibReadCloser) Close() error { + sync.PutByteSlice(r.dict) + sync.PutZlibReader(r.r) + if r.f != nil { + r.f.Close() + } + return nil } // SetSize implements the plumbing.EncodedObject interface. This method diff --git a/plumbing/format/packfile/object_pack.go b/plumbing/format/packfile/object_pack.go index 8ce29ef8b..a54c40f71 100644 --- a/plumbing/format/packfile/object_pack.go +++ b/plumbing/format/packfile/object_pack.go @@ -1,16 +1,16 @@ package packfile import ( - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" ) // ObjectToPack is a representation of an object that is going to be into a // pack file. type ObjectToPack struct { - // The main object to pack, it could be any object, including deltas + // The main object to pack, it could be any object, including deltas. Object plumbing.EncodedObject - // Base is the object that a delta is based on (it could be also another delta). - // If the main object is not a delta, Base will be null + // Base is the object that a delta is based on, which could also be another delta. + // Nil when the main object is not a delta. Base *ObjectToPack // Original is the object that we can generate applying the delta to // Base, or the same object as Object in the case of a non-delta diff --git a/plumbing/format/packfile/object_pack_test.go b/plumbing/format/packfile/object_pack_test.go index dc1a285a7..e8855504c 100644 --- a/plumbing/format/packfile/object_pack_test.go +++ b/plumbing/format/packfile/object_pack_test.go @@ -2,31 +2,35 @@ package packfile import ( "io" + "testing" - "github.com/go-git/go-git/v5/plumbing" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/stretchr/testify/suite" ) -type ObjectToPackSuite struct{} +type ObjectToPackSuite struct { + suite.Suite +} -var _ = Suite(&ObjectToPackSuite{}) +func TestObjectToPackSuite(t *testing.T) { + suite.Run(t, new(ObjectToPackSuite)) +} -func (s *ObjectToPackSuite) TestObjectToPack(c *C) { +func (s *ObjectToPackSuite) TestObjectToPack() { obj := &dummyObject{} otp := newObjectToPack(obj) - c.Assert(obj, Equals, otp.Object) - c.Assert(obj, Equals, otp.Original) - c.Assert(otp.Base, IsNil) - c.Assert(otp.IsDelta(), Equals, false) + s.Equal(otp.Object, obj) + s.Equal(otp.Original, obj) + s.Nil(otp.Base) + s.False(otp.IsDelta()) original := &dummyObject{} delta := &dummyObject{} deltaToPack := newDeltaObjectToPack(otp, original, delta) - c.Assert(obj, Equals, deltaToPack.Object) - c.Assert(original, Equals, deltaToPack.Original) - c.Assert(otp, Equals, deltaToPack.Base) - c.Assert(deltaToPack.IsDelta(), Equals, true) + s.Equal(deltaToPack.Object, obj) + s.Equal(deltaToPack.Original, original) + s.Equal(deltaToPack.Base, otp) + s.True(deltaToPack.IsDelta()) } type dummyObject struct{} diff --git a/plumbing/format/packfile/packfile.go b/plumbing/format/packfile/packfile.go index 685270225..4e5d2f0b1 100644 --- a/plumbing/format/packfile/packfile.go +++ b/plumbing/format/packfile/packfile.go @@ -1,18 +1,18 @@ package packfile import ( - "bytes" "fmt" "io" "os" + "sync" billy "github.com/go-git/go-billy/v5" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/format/idxfile" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/utils/ioutil" - "github.com/go-git/go-git/v5/utils/sync" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/format/idxfile" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/utils/binary" + "github.com/jesseduffield/go-git/v5/utils/ioutil" ) var ( @@ -24,602 +24,316 @@ var ( ErrZLib = NewError("zlib reading error") ) -// When reading small objects from packfile it is beneficial to do so at -// once to exploit the buffered I/O. In many cases the objects are so small -// that they were already loaded to memory when the object header was -// loaded from the packfile. Wrapping in FSObject would cause this buffered -// data to be thrown away and then re-read later, with the additional -// seeking causing reloads from disk. Objects smaller than this threshold -// are now always read into memory and stored in cache instead of being -// wrapped in FSObject. -const smallObjectThreshold = 16 * 1024 - // Packfile allows retrieving information from inside a packfile. type Packfile struct { idxfile.Index - fs billy.Filesystem - file billy.File - s *Scanner - deltaBaseCache cache.Object - offsetToType map[int64]plumbing.ObjectType - largeObjectThreshold int64 + fs billy.Filesystem + file billy.File + scanner *Scanner + + cache cache.Object + + id plumbing.Hash + m sync.Mutex + + once sync.Once + onceErr error } -// NewPackfileWithCache creates a new Packfile with the given object cache. +// NewPackfile returns a packfile representation for the given packfile file +// and packfile idx. // If the filesystem is provided, the packfile will return FSObjects, otherwise // it will return MemoryObjects. -func NewPackfileWithCache( - index idxfile.Index, - fs billy.Filesystem, +func NewPackfile( file billy.File, - cache cache.Object, - largeObjectThreshold int64, + opts ...PackfileOption, ) *Packfile { - s := NewScanner(file) - return &Packfile{ - index, - fs, - file, - s, - cache, - make(map[int64]plumbing.ObjectType), - largeObjectThreshold, + p := &Packfile{ + file: file, + } + for _, opt := range opts { + opt(p) } -} -// NewPackfile returns a packfile representation for the given packfile file -// and packfile idx. -// If the filesystem is provided, the packfile will return FSObjects, otherwise -// it will return MemoryObjects. -func NewPackfile(index idxfile.Index, fs billy.Filesystem, file billy.File, largeObjectThreshold int64) *Packfile { - return NewPackfileWithCache(index, fs, file, cache.NewObjectLRUDefault(), largeObjectThreshold) + return p } // Get retrieves the encoded object in the packfile with the given hash. func (p *Packfile) Get(h plumbing.Hash) (plumbing.EncodedObject, error) { - offset, err := p.FindOffset(h) - if err != nil { + if err := p.init(); err != nil { return nil, err } + p.m.Lock() + defer p.m.Unlock() - return p.objectAtOffset(offset, h) + return p.get(h) } // GetByOffset retrieves the encoded object from the packfile at the given // offset. -func (p *Packfile) GetByOffset(o int64) (plumbing.EncodedObject, error) { - hash, err := p.FindHash(o) - if err != nil { +func (p *Packfile) GetByOffset(offset int64) (plumbing.EncodedObject, error) { + if err := p.init(); err != nil { return nil, err } + p.m.Lock() + defer p.m.Unlock() - return p.objectAtOffset(o, hash) + return p.getByOffset(offset) } // GetSizeByOffset retrieves the size of the encoded object from the // packfile with the given offset. -func (p *Packfile) GetSizeByOffset(o int64) (size int64, err error) { - if _, err := p.s.SeekFromStart(o); err != nil { - if err == io.EOF || isInvalid(err) { - return 0, plumbing.ErrObjectNotFound - } - +func (p *Packfile) GetSizeByOffset(offset int64) (size int64, err error) { + if err := p.init(); err != nil { return 0, err } - h, err := p.nextObjectHeader() + d, err := p.GetByOffset(offset) if err != nil { return 0, err } - return p.getObjectSize(h) -} - -func (p *Packfile) objectHeaderAtOffset(offset int64) (*ObjectHeader, error) { - h, err := p.s.SeekObjectHeader(offset) - p.s.pendingObject = nil - return h, err -} -func (p *Packfile) nextObjectHeader() (*ObjectHeader, error) { - h, err := p.s.NextObjectHeader() - p.s.pendingObject = nil - return h, err + return d.Size(), nil } -func (p *Packfile) getDeltaObjectSize(buf *bytes.Buffer) int64 { - delta := buf.Bytes() - _, delta = decodeLEB128(delta) // skip src size - sz, _ := decodeLEB128(delta) - return int64(sz) +// GetAll returns an iterator with all encoded objects in the packfile. +// The iterator returned is not thread-safe, it should be used in the same +// thread as the Packfile instance. +func (p *Packfile) GetAll() (storer.EncodedObjectIter, error) { + return p.GetByType(plumbing.AnyObject) } -func (p *Packfile) getObjectSize(h *ObjectHeader) (int64, error) { - switch h.Type { - case plumbing.CommitObject, plumbing.TreeObject, plumbing.BlobObject, plumbing.TagObject: - return h.Length, nil - case plumbing.REFDeltaObject, plumbing.OFSDeltaObject: - buf := sync.GetBytesBuffer() - defer sync.PutBytesBuffer(buf) - - if _, _, err := p.s.NextObject(buf); err != nil { - return 0, err - } - - return p.getDeltaObjectSize(buf), nil - default: - return 0, ErrInvalidObject.AddDetails("type %q", h.Type) +// GetByType returns all the objects of the given type. +func (p *Packfile) GetByType(typ plumbing.ObjectType) (storer.EncodedObjectIter, error) { + if err := p.init(); err != nil { + return nil, err } -} -func (p *Packfile) getObjectType(h *ObjectHeader) (typ plumbing.ObjectType, err error) { - switch h.Type { - case plumbing.CommitObject, plumbing.TreeObject, plumbing.BlobObject, plumbing.TagObject: - return h.Type, nil - case plumbing.REFDeltaObject, plumbing.OFSDeltaObject: - var offset int64 - if h.Type == plumbing.REFDeltaObject { - offset, err = p.FindOffset(h.Reference) - if err != nil { - return - } - } else { - offset = h.OffsetReference + switch typ { + case plumbing.AnyObject, + plumbing.BlobObject, + plumbing.TreeObject, + plumbing.CommitObject, + plumbing.TagObject: + entries, err := p.EntriesByOffset() + if err != nil { + return nil, err } - if baseType, ok := p.offsetToType[offset]; ok { - typ = baseType - } else { - h, err = p.objectHeaderAtOffset(offset) - if err != nil { - return - } - - typ, err = p.getObjectType(h) - if err != nil { - return - } - } + return &objectIter{ + p: p, + iter: entries, + typ: typ, + }, nil default: - err = ErrInvalidObject.AddDetails("type %q", h.Type) + return nil, plumbing.ErrInvalidType } - - p.offsetToType[h.Offset] = typ - - return } -func (p *Packfile) objectAtOffset(offset int64, hash plumbing.Hash) (plumbing.EncodedObject, error) { - if obj, ok := p.cacheGet(hash); ok { - return obj, nil - } - - h, err := p.objectHeaderAtOffset(offset) - if err != nil { - if err == io.EOF || isInvalid(err) { - return nil, plumbing.ErrObjectNotFound - } +// Returns the Packfile's inner scanner. +// +// Deprecated: this will be removed in future versions of the packfile package +// to avoid exposing the package internals and to improve its thread-safety. +func (p *Packfile) Scanner() (*Scanner, error) { + if err := p.init(); err != nil { return nil, err } - return p.getNextObject(h, hash) + return p.scanner, nil } -func (p *Packfile) getNextObject(h *ObjectHeader, hash plumbing.Hash) (plumbing.EncodedObject, error) { - var err error - - // If we have no filesystem, we will return a MemoryObject instead - // of an FSObject. - if p.fs == nil { - return p.getNextMemoryObject(h) +// ID returns the ID of the packfile, which is the checksum at the end of it. +func (p *Packfile) ID() (plumbing.Hash, error) { + if err := p.init(); err != nil { + return plumbing.ZeroHash, err } - // If the object is small enough then read it completely into memory now since - // it is already read from disk into buffer anyway. For delta objects we want - // to perform the optimization too, but we have to be careful about applying - // small deltas on big objects. - var size int64 - if h.Length <= smallObjectThreshold { - if h.Type != plumbing.OFSDeltaObject && h.Type != plumbing.REFDeltaObject { - return p.getNextMemoryObject(h) - } - - // For delta objects we read the delta data and apply the small object - // optimization only if the expanded version of the object still meets - // the small object threshold condition. - buf := sync.GetBytesBuffer() - defer sync.PutBytesBuffer(buf) - - if _, _, err := p.s.NextObject(buf); err != nil { - return nil, err - } - - size = p.getDeltaObjectSize(buf) - if size <= smallObjectThreshold { - var obj = new(plumbing.MemoryObject) - obj.SetSize(size) - if h.Type == plumbing.REFDeltaObject { - err = p.fillREFDeltaObjectContentWithBuffer(obj, h.Reference, buf) - } else { - err = p.fillOFSDeltaObjectContentWithBuffer(obj, h.OffsetReference, buf) - } - return obj, err - } - } else { - size, err = p.getObjectSize(h) - if err != nil { - return nil, err - } - } + return p.id, nil +} - typ, err := p.getObjectType(h) - if err != nil { - return nil, err +// get is not threat-safe, and should only be called within packfile.go. +func (p *Packfile) get(h plumbing.Hash) (plumbing.EncodedObject, error) { + if obj, ok := p.cache.Get(h); ok { + return obj, nil } - p.offsetToType[h.Offset] = typ - - return NewFSObject( - hash, - typ, - h.Offset, - size, - p.Index, - p.fs, - p.file.Name(), - p.deltaBaseCache, - p.largeObjectThreshold, - ), nil -} - -func (p *Packfile) getObjectContent(offset int64) (io.ReadCloser, error) { - h, err := p.objectHeaderAtOffset(offset) + offset, err := p.Index.FindOffset(h) if err != nil { return nil, err } - // getObjectContent is called from FSObject, so we have to explicitly - // get memory object here to avoid recursive cycle - obj, err := p.getNextMemoryObject(h) + oh, err := p.headerFromOffset(offset) if err != nil { return nil, err } - return obj.Reader() + return p.objectFromHeader(oh) } -func asyncReader(p *Packfile) (io.ReadCloser, error) { - reader := ioutil.NewReaderUsingReaderAt(p.file, p.s.r.offset) - zr, err := sync.GetZlibReader(reader) +// getByOffset is not threat-safe, and should only be called within packfile.go. +func (p *Packfile) getByOffset(offset int64) (plumbing.EncodedObject, error) { + h, err := p.FindHash(offset) if err != nil { - return nil, fmt.Errorf("zlib reset error: %s", err) - } - - return ioutil.NewReadCloserWithCloser(zr.Reader, func() error { - sync.PutZlibReader(zr) - return nil - }), nil - -} - -func (p *Packfile) getReaderDirect(h *ObjectHeader) (io.ReadCloser, error) { - switch h.Type { - case plumbing.CommitObject, plumbing.TreeObject, plumbing.BlobObject, plumbing.TagObject: - return asyncReader(p) - case plumbing.REFDeltaObject: - deltaRc, err := asyncReader(p) - if err != nil { - return nil, err - } - r, err := p.readREFDeltaObjectContent(h, deltaRc) - if err != nil { - return nil, err - } - return r, nil - case plumbing.OFSDeltaObject: - deltaRc, err := asyncReader(p) - if err != nil { - return nil, err - } - r, err := p.readOFSDeltaObjectContent(h, deltaRc) - if err != nil { - return nil, err - } - return r, nil - default: - return nil, ErrInvalidObject.AddDetails("type %q", h.Type) + return nil, err } -} - -func (p *Packfile) getNextMemoryObject(h *ObjectHeader) (plumbing.EncodedObject, error) { - var obj = new(plumbing.MemoryObject) - obj.SetSize(h.Length) - obj.SetType(h.Type) - var err error - switch h.Type { - case plumbing.CommitObject, plumbing.TreeObject, plumbing.BlobObject, plumbing.TagObject: - err = p.fillRegularObjectContent(obj) - case plumbing.REFDeltaObject: - err = p.fillREFDeltaObjectContent(obj, h.Reference) - case plumbing.OFSDeltaObject: - err = p.fillOFSDeltaObjectContent(obj, h.OffsetReference) - default: - err = ErrInvalidObject.AddDetails("type %q", h.Type) + if obj, ok := p.cache.Get(h); ok { + return obj, nil } + oh, err := p.headerFromOffset(offset) if err != nil { return nil, err } - p.offsetToType[h.Offset] = obj.Type() - - return obj, nil + return p.objectFromHeader(oh) } -func (p *Packfile) fillRegularObjectContent(obj plumbing.EncodedObject) (err error) { - w, err := obj.Writer() - if err != nil { - return err - } - - defer ioutil.CheckClose(w, &err) - - _, _, err = p.s.NextObject(w) - p.cachePut(obj) - - return err -} - -func (p *Packfile) fillREFDeltaObjectContent(obj plumbing.EncodedObject, ref plumbing.Hash) error { - buf := sync.GetBytesBuffer() - defer sync.PutBytesBuffer(buf) - - _, _, err := p.s.NextObject(buf) - if err != nil { - return err - } +func (p *Packfile) init() error { + p.once.Do(func() { + if p.file == nil { + p.onceErr = fmt.Errorf("file is not set") + return + } - return p.fillREFDeltaObjectContentWithBuffer(obj, ref, buf) -} + if p.Index == nil { + p.onceErr = fmt.Errorf("index is not set") + return + } -func (p *Packfile) readREFDeltaObjectContent(h *ObjectHeader, deltaRC io.Reader) (io.ReadCloser, error) { - var err error + p.scanner = NewScanner(p.file) + // Validate packfile signature. + if !p.scanner.Scan() { + p.onceErr = p.scanner.Error() + return + } - base, ok := p.cacheGet(h.Reference) - if !ok { - base, err = p.Get(h.Reference) + _, err := p.scanner.Seek(-20, io.SeekEnd) if err != nil { - return nil, err + p.onceErr = err + return } - } - - return ReaderFromDelta(base, deltaRC) -} - -func (p *Packfile) fillREFDeltaObjectContentWithBuffer(obj plumbing.EncodedObject, ref plumbing.Hash, buf *bytes.Buffer) error { - var err error - base, ok := p.cacheGet(ref) - if !ok { - base, err = p.Get(ref) + id, err := binary.ReadHash(p.scanner) if err != nil { - return err + p.onceErr = err } - } - - obj.SetType(base.Type()) - err = ApplyDelta(obj, base, buf.Bytes()) - p.cachePut(obj) - - return err -} - -func (p *Packfile) fillOFSDeltaObjectContent(obj plumbing.EncodedObject, offset int64) error { - buf := sync.GetBytesBuffer() - defer sync.PutBytesBuffer(buf) + p.id = id - _, _, err := p.s.NextObject(buf) - if err != nil { - return err - } + if p.cache == nil { + p.cache = cache.NewObjectLRUDefault() + } + }) - return p.fillOFSDeltaObjectContentWithBuffer(obj, offset, buf) + return p.onceErr } -func (p *Packfile) readOFSDeltaObjectContent(h *ObjectHeader, deltaRC io.Reader) (io.ReadCloser, error) { - hash, err := p.FindHash(h.OffsetReference) +func (p *Packfile) headerFromOffset(offset int64) (*ObjectHeader, error) { + err := p.scanner.SeekFromStart(offset) if err != nil { return nil, err } - base, err := p.objectAtOffset(h.OffsetReference, hash) - if err != nil { - return nil, err + if !p.scanner.Scan() { + return nil, plumbing.ErrObjectNotFound } - return ReaderFromDelta(base, deltaRC) + oh := p.scanner.Data().Value().(ObjectHeader) + return &oh, nil } -func (p *Packfile) fillOFSDeltaObjectContentWithBuffer(obj plumbing.EncodedObject, offset int64, buf *bytes.Buffer) error { - hash, err := p.FindHash(offset) - if err != nil { - return err - } +// Close the packfile and its resources. +func (p *Packfile) Close() error { + p.m.Lock() + defer p.m.Unlock() - base, err := p.objectAtOffset(offset, hash) - if err != nil { - return err + closer, ok := p.file.(io.Closer) + if !ok { + return nil } - obj.SetType(base.Type()) - err = ApplyDelta(obj, base, buf.Bytes()) - p.cachePut(obj) - - return err + return closer.Close() } -func (p *Packfile) cacheGet(h plumbing.Hash) (plumbing.EncodedObject, bool) { - if p.deltaBaseCache == nil { - return nil, false +func (p *Packfile) objectFromHeader(oh *ObjectHeader) (plumbing.EncodedObject, error) { + if oh == nil { + return nil, plumbing.ErrObjectNotFound } - return p.deltaBaseCache.Get(h) -} + // If we have filesystem, and the object is not a delta type, return a FSObject. + // This avoids having to inflate the object more than once. + if !oh.Type.IsDelta() && p.fs != nil { + fs := NewFSObject( + oh.Hash, + oh.Type, + oh.ContentOffset, + oh.Size, + p.Index, + p.fs, + p.file, + p.file.Name(), + p.cache, + ) -func (p *Packfile) cachePut(obj plumbing.EncodedObject) { - if p.deltaBaseCache == nil { - return + p.cache.Put(fs) + return fs, nil } - p.deltaBaseCache.Put(obj) + return p.getMemoryObject(oh) } -// GetAll returns an iterator with all encoded objects in the packfile. -// The iterator returned is not thread-safe, it should be used in the same -// thread as the Packfile instance. -func (p *Packfile) GetAll() (storer.EncodedObjectIter, error) { - return p.GetByType(plumbing.AnyObject) -} - -// GetByType returns all the objects of the given type. -func (p *Packfile) GetByType(typ plumbing.ObjectType) (storer.EncodedObjectIter, error) { - switch typ { - case plumbing.AnyObject, - plumbing.BlobObject, - plumbing.TreeObject, - plumbing.CommitObject, - plumbing.TagObject: - entries, err := p.EntriesByOffset() - if err != nil { - return nil, err - } - - return &objectIter{ - // Easiest way to provide an object decoder is just to pass a Packfile - // instance. To not mess with the seeks, it's a new instance with a - // different scanner but the same cache and offset to hash map for - // reusing as much cache as possible. - p: p, - iter: entries, - typ: typ, - }, nil - default: - return nil, plumbing.ErrInvalidType - } -} +func (p *Packfile) getMemoryObject(oh *ObjectHeader) (plumbing.EncodedObject, error) { + var obj = new(plumbing.MemoryObject) + obj.SetSize(oh.Size) + obj.SetType(oh.Type) -// ID returns the ID of the packfile, which is the checksum at the end of it. -func (p *Packfile) ID() (plumbing.Hash, error) { - prev, err := p.file.Seek(-20, io.SeekEnd) + w, err := obj.Writer() if err != nil { - return plumbing.ZeroHash, err - } - - var hash plumbing.Hash - if _, err := io.ReadFull(p.file, hash[:]); err != nil { - return plumbing.ZeroHash, err - } - - if _, err := p.file.Seek(prev, io.SeekStart); err != nil { - return plumbing.ZeroHash, err - } - - return hash, nil -} - -// Scanner returns the packfile's Scanner -func (p *Packfile) Scanner() *Scanner { - return p.s -} - -// Close the packfile and its resources. -func (p *Packfile) Close() error { - closer, ok := p.file.(io.Closer) - if !ok { - return nil + return nil, err } + defer ioutil.CheckClose(w, &err) - return closer.Close() -} - -type objectIter struct { - p *Packfile - typ plumbing.ObjectType - iter idxfile.EntryIter -} - -func (i *objectIter) Next() (plumbing.EncodedObject, error) { - for { - e, err := i.iter.Next() - if err != nil { - return nil, err - } + switch oh.Type { + case plumbing.CommitObject, plumbing.TreeObject, plumbing.BlobObject, plumbing.TagObject: + err = p.scanner.inflateContent(oh.ContentOffset, w) - if i.typ != plumbing.AnyObject { - if typ, ok := i.p.offsetToType[int64(e.Offset)]; ok { - if typ != i.typ { - continue - } - } else if obj, ok := i.p.cacheGet(e.Hash); ok { - if obj.Type() != i.typ { - i.p.offsetToType[int64(e.Offset)] = obj.Type() - continue - } - return obj, nil - } else { - h, err := i.p.objectHeaderAtOffset(int64(e.Offset)) - if err != nil { - return nil, err - } - - if h.Type == plumbing.REFDeltaObject || h.Type == plumbing.OFSDeltaObject { - typ, err := i.p.getObjectType(h) - if err != nil { - return nil, err - } - if typ != i.typ { - i.p.offsetToType[int64(e.Offset)] = typ - continue - } - // getObjectType will seek in the file so we cannot use getNextObject safely - return i.p.objectAtOffset(int64(e.Offset), e.Hash) - } else { - if h.Type != i.typ { - i.p.offsetToType[int64(e.Offset)] = h.Type - continue - } - return i.p.getNextObject(h, e.Hash) - } + case plumbing.REFDeltaObject, plumbing.OFSDeltaObject: + var parent plumbing.EncodedObject + + switch oh.Type { + case plumbing.REFDeltaObject: + var ok bool + parent, ok = p.cache.Get(oh.Reference) + if !ok { + parent, err = p.get(oh.Reference) } + case plumbing.OFSDeltaObject: + parent, err = p.getByOffset(oh.OffsetReference) } - obj, err := i.p.objectAtOffset(int64(e.Offset), e.Hash) if err != nil { - return nil, err + return nil, fmt.Errorf("cannot find base object: %w", err) } - return obj, nil - } -} - -func (i *objectIter) ForEach(f func(plumbing.EncodedObject) error) error { - for { - o, err := i.Next() + err = p.scanner.inflateContent(oh.ContentOffset, &oh.content) if err != nil { - if err == io.EOF { - return nil - } - return err + return nil, fmt.Errorf("cannot inflate content: %w", err) } - if err := f(o); err != nil { - return err - } + obj.SetType(parent.Type()) + err = ApplyDelta(obj, parent, oh.content.Bytes()) //nolint:ineffassign + + default: + err = ErrInvalidObject.AddDetails("type %q", oh.Type) } -} -func (i *objectIter) Close() { - i.iter.Close() + if err != nil { + return nil, err + } + + p.cache.Put(obj) + + return obj, nil } // isInvalid checks whether an error is an os.PathError with an os.ErrInvalid diff --git a/plumbing/format/packfile/packfile_iter.go b/plumbing/format/packfile/packfile_iter.go new file mode 100644 index 000000000..ca17560fa --- /dev/null +++ b/plumbing/format/packfile/packfile_iter.go @@ -0,0 +1,90 @@ +package packfile + +import ( + "io" + + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/idxfile" +) + +type objectIter struct { + p *Packfile + typ plumbing.ObjectType + iter idxfile.EntryIter +} + +func (i *objectIter) Next() (plumbing.EncodedObject, error) { + if err := i.p.init(); err != nil { + return nil, err + } + + i.p.m.Lock() + defer i.p.m.Unlock() + + return i.next() +} + +func (i *objectIter) next() (plumbing.EncodedObject, error) { + for { + e, err := i.iter.Next() + if err != nil { + return nil, err + } + + oh, err := i.p.headerFromOffset(int64(e.Offset)) + if err != nil { + return nil, err + } + + if i.typ == plumbing.AnyObject { + return i.p.objectFromHeader(oh) + } + + // Current object header type is a delta, get the actual object to + // assess the actual type. + if oh.Type.IsDelta() { + o, err := i.p.objectFromHeader(oh) + if o.Type() == i.typ { + return o, err + } + + continue + } + + if oh.Type == i.typ { + return i.p.objectFromHeader(oh) + } + + continue + } +} + +func (i *objectIter) ForEach(f func(plumbing.EncodedObject) error) error { + if err := i.p.init(); err != nil { + return err + } + + i.p.m.Lock() + defer i.p.m.Unlock() + + for { + o, err := i.next() + if err != nil { + if err == io.EOF { + return nil + } + return err + } + + if err := f(o); err != nil { + return err + } + } +} + +func (i *objectIter) Close() { + i.p.m.Lock() + defer i.p.m.Unlock() + + i.iter.Close() +} diff --git a/plumbing/format/packfile/packfile_options.go b/plumbing/format/packfile/packfile_options.go new file mode 100644 index 000000000..bc6897164 --- /dev/null +++ b/plumbing/format/packfile/packfile_options.go @@ -0,0 +1,32 @@ +package packfile + +import ( + billy "github.com/go-git/go-billy/v5" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/format/idxfile" +) + +type PackfileOption func(*Packfile) + +// WithCache sets the cache to be used throughout Packfile operations. +// Use this to share existing caches with the Packfile. If not used, a +// new cache instance will be created. +func WithCache(cache cache.Object) PackfileOption { + return func(p *Packfile) { + p.cache = cache + } +} + +// WithIdx sets the idxfile for the packfile. +func WithIdx(idx idxfile.Index) PackfileOption { + return func(p *Packfile) { + p.Index = idx + } +} + +// WithFs sets the filesystem to be used. +func WithFs(fs billy.Filesystem) PackfileOption { + return func(p *Packfile) { + p.fs = fs + } +} diff --git a/plumbing/format/packfile/packfile_test.go b/plumbing/format/packfile/packfile_test.go index 2eb099df6..06a2a5445 100644 --- a/plumbing/format/packfile/packfile_test.go +++ b/plumbing/format/packfile/packfile_test.go @@ -3,56 +3,76 @@ package packfile_test import ( "io" "math" - - fixtures "github.com/go-git/go-git-fixtures/v4" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/idxfile" - "github.com/go-git/go-git/v5/plumbing/format/packfile" - . "gopkg.in/check.v1" + "testing" + + fixtures "github.com/go-git/go-git-fixtures/v5" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/format/idxfile" + "github.com/jesseduffield/go-git/v5/plumbing/format/packfile" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) -type PackfileSuite struct { - fixtures.Suite - p *packfile.Packfile - idx *idxfile.MemoryIndex - f *fixtures.Fixture -} +func TestGet(t *testing.T) { + t.Parallel() + + f := fixtures.Basic().One() + idx := getIndexFromIdxFile(f.Idx()) -var _ = Suite(&PackfileSuite{}) + p := packfile.NewPackfile(f.Packfile(), + packfile.WithIdx(idx), packfile.WithFs(fixtures.Filesystem), + ) -func (s *PackfileSuite) TestGet(c *C) { for h := range expectedEntries { - obj, err := s.p.Get(h) - c.Assert(err, IsNil) - c.Assert(obj, Not(IsNil)) - c.Assert(obj.Hash(), Equals, h) + obj, err := p.Get(h) + + assert.NoError(t, err) + assert.NotNil(t, obj) + assert.Equal(t, h.String(), obj.Hash().String()) } - _, err := s.p.Get(plumbing.ZeroHash) - c.Assert(err, Equals, plumbing.ErrObjectNotFound) + _, err := p.Get(plumbing.ZeroHash) + assert.ErrorIs(t, err, plumbing.ErrObjectNotFound) + + id, err := p.ID() + assert.NoError(t, err) + assert.Equal(t, f.PackfileHash, id.String()) } -func (s *PackfileSuite) TestGetByOffset(c *C) { +func TestGetByOffset(t *testing.T) { + t.Parallel() + + f := fixtures.Basic().One() + idx := getIndexFromIdxFile(f.Idx()) + + p := packfile.NewPackfile(f.Packfile(), + packfile.WithIdx(idx), packfile.WithFs(fixtures.Filesystem), + ) + for h, o := range expectedEntries { - obj, err := s.p.GetByOffset(o) - c.Assert(err, IsNil) - c.Assert(obj, Not(IsNil)) - c.Assert(obj.Hash(), Equals, h) + obj, err := p.GetByOffset(o) + assert.NoError(t, err) + assert.NotNil(t, obj) + assert.Equal(t, h.String(), obj.Hash().String()) } - _, err := s.p.GetByOffset(math.MaxInt64) - c.Assert(err, Equals, plumbing.ErrObjectNotFound) + _, err := p.GetByOffset(math.MaxInt64) + assert.ErrorIs(t, err, plumbing.ErrObjectNotFound) } -func (s *PackfileSuite) TestID(c *C) { - id, err := s.p.ID() - c.Assert(err, IsNil) - c.Assert(id.String(), Equals, s.f.PackfileHash) -} +func TestGetAll(t *testing.T) { + t.Parallel() -func (s *PackfileSuite) TestGetAll(c *C) { - iter, err := s.p.GetAll() - c.Assert(err, IsNil) + f := fixtures.Basic().One() + idx := getIndexFromIdxFile(f.Idx()) + + p := packfile.NewPackfile(f.Packfile(), + packfile.WithIdx(idx), + packfile.WithFs(fixtures.Filesystem)) + + iter, err := p.GetAll() + assert.NoError(t, err) var objects int for { @@ -60,88 +80,58 @@ func (s *PackfileSuite) TestGetAll(c *C) { if err == io.EOF { break } - c.Assert(err, IsNil) + assert.NoError(t, err) objects++ - _, ok := expectedEntries[o.Hash()] - c.Assert(ok, Equals, true) + h := o.Hash() + _, ok := expectedEntries[h] + assert.True(t, ok, "%s not found", h) } - c.Assert(objects, Equals, len(expectedEntries)) -} + assert.Len(t, expectedEntries, objects) -var expectedEntries = map[plumbing.Hash]int64{ - plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea"): 615, - plumbing.NewHash("32858aad3c383ed1ff0a0f9bdf231d54a00c9e88"): 1524, - plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"): 1063, - plumbing.NewHash("49c6bb89b17060d7b4deacb7b338fcc6ea2352a9"): 78882, - plumbing.NewHash("4d081c50e250fa32ea8b1313cf8bb7c2ad7627fd"): 84688, - plumbing.NewHash("586af567d0bb5e771e49bdd9434f5e0fb76d25fa"): 84559, - plumbing.NewHash("5a877e6a906a2743ad6e45d99c1793642aaf8eda"): 84479, - plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"): 186, - plumbing.NewHash("7e59600739c96546163833214c36459e324bad0a"): 84653, - plumbing.NewHash("880cd14280f4b9b6ed3986d6671f907d7cc2a198"): 78050, - plumbing.NewHash("8dcef98b1d52143e1e2dbc458ffe38f925786bf2"): 84741, - plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"): 286, - plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492"): 80998, - plumbing.NewHash("9dea2395f5403188298c1dabe8bdafe562c491e3"): 84032, - plumbing.NewHash("a39771a7651f97faf5c72e08224d857fc35133db"): 84430, - plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69"): 838, - plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c"): 84375, - plumbing.NewHash("aa9b383c260e1d05fbbf6b30a02914555e20c725"): 84760, - plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"): 449, - plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"): 1392, - plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"): 1230, - plumbing.NewHash("c192bd6a24ea1ab01d78686e417c8bdc7c3d197f"): 1713, - plumbing.NewHash("c2d30fa8ef288618f65f6eed6e168e0d514886f4"): 84725, - plumbing.NewHash("c8f1d8c61f9da76f4cb49fd86322b6e685dba956"): 80725, - plumbing.NewHash("cf4aa3b38974fb7d81f367c0830f7d78d65ab86b"): 84608, - plumbing.NewHash("d3ff53e0564a9f87d8e84b6e28e5060e517008aa"): 1685, - plumbing.NewHash("d5c0f4ab811897cadf03aec358ae60d21f91c50d"): 2351, - plumbing.NewHash("dbd3641b371024f44d0e469a9c8f5457b0660de1"): 84115, - plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881"): 12, - plumbing.NewHash("eba74343e2f15d62adedfd8c883ee0262b5c8021"): 84708, - plumbing.NewHash("fb72698cab7617ac416264415f13224dfd7a165e"): 84671, + iter.Close() + assert.NoError(t, p.Close()) } -func (s *PackfileSuite) SetUpTest(c *C) { - s.f = fixtures.Basic().One() - - s.idx = idxfile.NewMemoryIndex() - c.Assert(idxfile.NewDecoder(s.f.Idx()).Decode(s.idx), IsNil) +func TestDecode(t *testing.T) { + t.Parallel() - s.p = packfile.NewPackfile(s.idx, fixtures.Filesystem, s.f.Packfile(), 0) -} - -func (s *PackfileSuite) TearDownTest(c *C) { - c.Assert(s.p.Close(), IsNil) -} + packfiles := fixtures.Basic().ByTag("packfile") + assert.Greater(t, len(packfiles), 0) -func (s *PackfileSuite) TestDecode(c *C) { - fixtures.Basic().ByTag("packfile").Test(c, func(f *fixtures.Fixture) { + for _, f := range packfiles { + f := f index := getIndexFromIdxFile(f.Idx()) - p := packfile.NewPackfile(index, fixtures.Filesystem, f.Packfile(), 0) - defer p.Close() + p := packfile.NewPackfile(f.Packfile(), + packfile.WithIdx(index), packfile.WithFs(fixtures.Filesystem), + ) for _, h := range expectedHashes { + h := h obj, err := p.Get(plumbing.NewHash(h)) - c.Assert(err, IsNil) - c.Assert(obj.Hash().String(), Equals, h) + assert.NoError(t, err) + assert.Equal(t, obj.Hash().String(), h) } - }) + + err := p.Close() + assert.NoError(t, err) + } } -func (s *PackfileSuite) TestDecodeByTypeRefDelta(c *C) { +func TestDecodeByTypeRefDelta(t *testing.T) { + t.Parallel() + f := fixtures.Basic().ByTag("ref-delta").One() index := getIndexFromIdxFile(f.Idx()) - packfile := packfile.NewPackfile(index, fixtures.Filesystem, f.Packfile(), 0) - defer packfile.Close() + packfile := packfile.NewPackfile(f.Packfile(), + packfile.WithIdx(index), packfile.WithFs(fixtures.Filesystem)) iter, err := packfile.GetByType(plumbing.CommitObject) - c.Assert(err, IsNil) + assert.NoError(t, err) var count int for { @@ -151,54 +141,143 @@ func (s *PackfileSuite) TestDecodeByTypeRefDelta(c *C) { } count++ - c.Assert(err, IsNil) - c.Assert(obj.Type(), Equals, plumbing.CommitObject) + assert.NoError(t, err) + assert.Equal(t, obj.Type(), plumbing.CommitObject) } - c.Assert(count > 0, Equals, true) + err = packfile.Close() + + assert.NoError(t, err) + assert.Greater(t, count, 0) } -func (s *PackfileSuite) TestDecodeByType(c *C) { - ts := []plumbing.ObjectType{ +func TestDecodeByType(t *testing.T) { + t.Parallel() + + types := []plumbing.ObjectType{ plumbing.CommitObject, plumbing.TagObject, plumbing.TreeObject, plumbing.BlobObject, } - fixtures.Basic().ByTag("packfile").Test(c, func(f *fixtures.Fixture) { - for _, t := range ts { + for _, f := range fixtures.Basic().ByTag("packfile") { + f := f + for _, typ := range types { + typ := typ index := getIndexFromIdxFile(f.Idx()) - packfile := packfile.NewPackfile(index, fixtures.Filesystem, f.Packfile(), 0) + packfile := packfile.NewPackfile(f.Packfile(), + packfile.WithIdx(index), packfile.WithFs(fixtures.Filesystem), + ) defer packfile.Close() - iter, err := packfile.GetByType(t) - c.Assert(err, IsNil) + iter, err := packfile.GetByType(typ) + assert.NoError(t, err) - c.Assert(iter.ForEach(func(obj plumbing.EncodedObject) error { - c.Assert(obj.Type(), Equals, t) + err = iter.ForEach(func(obj plumbing.EncodedObject) error { + assert.Equal(t, typ, obj.Type()) return nil - }), IsNil) + }) + assert.NoError(t, err) } - }) + } } -func (s *PackfileSuite) TestDecodeByTypeConstructor(c *C) { +func TestDecodeByTypeConstructor(t *testing.T) { + t.Parallel() + f := fixtures.Basic().ByTag("packfile").One() index := getIndexFromIdxFile(f.Idx()) - packfile := packfile.NewPackfile(index, fixtures.Filesystem, f.Packfile(), 0) + packfile := packfile.NewPackfile(f.Packfile(), + packfile.WithIdx(index), packfile.WithFs(fixtures.Filesystem), + ) defer packfile.Close() _, err := packfile.GetByType(plumbing.OFSDeltaObject) - c.Assert(err, Equals, plumbing.ErrInvalidType) + assert.ErrorIs(t, err, plumbing.ErrInvalidType) _, err = packfile.GetByType(plumbing.REFDeltaObject) - c.Assert(err, Equals, plumbing.ErrInvalidType) + assert.ErrorIs(t, err, plumbing.ErrInvalidType) _, err = packfile.GetByType(plumbing.InvalidObject) - c.Assert(err, Equals, plumbing.ErrInvalidType) + assert.ErrorIs(t, err, plumbing.ErrInvalidType) +} + +func getIndexFromIdxFile(r io.ReadCloser) idxfile.Index { + defer r.Close() + + idx := idxfile.NewMemoryIndex() + if err := idxfile.NewDecoder(r).Decode(idx); err != nil { + panic(err) + } + + return idx +} + +func TestSize(t *testing.T) { + t.Parallel() + + f := fixtures.Basic().ByTag("ref-delta").One() + + index := getIndexFromIdxFile(f.Idx()) + + packfile := packfile.NewPackfile(f.Packfile(), + packfile.WithIdx(index), + packfile.WithFs(fixtures.Filesystem), + ) + defer packfile.Close() + + // Get the size of binary.jpg, which is not delta-encoded. + offset, err := packfile.FindOffset(plumbing.NewHash("d5c0f4ab811897cadf03aec358ae60d21f91c50d")) + assert.NoError(t, err) + + size, err := packfile.GetSizeByOffset(offset) + assert.NoError(t, err) + assert.Equal(t, int64(76110), size) + + // Get the size of the root commit, which is delta-encoded. + offset, err = packfile.FindOffset(plumbing.NewHash(f.Head)) + assert.NoError(t, err) + size, err = packfile.GetSizeByOffset(offset) + assert.NoError(t, err) + assert.Equal(t, int64(245), size) +} + +func BenchmarkGetByOffset(b *testing.B) { + f := fixtures.Basic().One() + idx := idxfile.NewMemoryIndex() + + cache := cache.NewObjectLRUDefault() + err := idxfile.NewDecoder(f.Idx()).Decode(idx) + require.NoError(b, err) + + b.Run("with storage", + benchmarkGetByOffset(packfile.NewPackfile(f.Packfile(), + packfile.WithIdx(idx), packfile.WithFs(fixtures.Filesystem), + packfile.WithCache(cache), + ))) + b.Run("without storage", + benchmarkGetByOffset(packfile.NewPackfile(f.Packfile(), + packfile.WithCache(cache), packfile.WithIdx(idx), + ))) +} + +func benchmarkGetByOffset(p *packfile.Packfile) func(b *testing.B) { + return func(b *testing.B) { + for i := 0; i < b.N; i++ { + for h, o := range expectedEntries { + obj, err := p.GetByOffset(o) + if err != nil { + b.Fatal() + } + if h != obj.Hash() { + b.Fatal() + } + } + } + } } var expectedHashes = []string{ @@ -235,34 +314,36 @@ var expectedHashes = []string{ "7e59600739c96546163833214c36459e324bad0a", } -func getIndexFromIdxFile(r io.Reader) idxfile.Index { - idx := idxfile.NewMemoryIndex() - if err := idxfile.NewDecoder(r).Decode(idx); err != nil { - panic(err) - } - - return idx -} - -func (s *PackfileSuite) TestSize(c *C) { - f := fixtures.Basic().ByTag("ref-delta").One() - - index := getIndexFromIdxFile(f.Idx()) - - packfile := packfile.NewPackfile(index, fixtures.Filesystem, f.Packfile(), 0) - defer packfile.Close() - - // Get the size of binary.jpg, which is not delta-encoded. - offset, err := packfile.FindOffset(plumbing.NewHash("d5c0f4ab811897cadf03aec358ae60d21f91c50d")) - c.Assert(err, IsNil) - size, err := packfile.GetSizeByOffset(offset) - c.Assert(err, IsNil) - c.Assert(size, Equals, int64(76110)) - - // Get the size of the root commit, which is delta-encoded. - offset, err = packfile.FindOffset(plumbing.NewHash(f.Head)) - c.Assert(err, IsNil) - size, err = packfile.GetSizeByOffset(offset) - c.Assert(err, IsNil) - c.Assert(size, Equals, int64(245)) +var expectedEntries = map[plumbing.Hash]int64{ + plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea"): 615, + plumbing.NewHash("32858aad3c383ed1ff0a0f9bdf231d54a00c9e88"): 1524, + plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"): 1063, + plumbing.NewHash("49c6bb89b17060d7b4deacb7b338fcc6ea2352a9"): 78882, + plumbing.NewHash("4d081c50e250fa32ea8b1313cf8bb7c2ad7627fd"): 84688, + plumbing.NewHash("586af567d0bb5e771e49bdd9434f5e0fb76d25fa"): 84559, + plumbing.NewHash("5a877e6a906a2743ad6e45d99c1793642aaf8eda"): 84479, + plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"): 186, + plumbing.NewHash("7e59600739c96546163833214c36459e324bad0a"): 84653, + plumbing.NewHash("880cd14280f4b9b6ed3986d6671f907d7cc2a198"): 78050, + plumbing.NewHash("8dcef98b1d52143e1e2dbc458ffe38f925786bf2"): 84741, + plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"): 286, + plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492"): 80998, + plumbing.NewHash("9dea2395f5403188298c1dabe8bdafe562c491e3"): 84032, + plumbing.NewHash("a39771a7651f97faf5c72e08224d857fc35133db"): 84430, + plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69"): 838, + plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c"): 84375, + plumbing.NewHash("aa9b383c260e1d05fbbf6b30a02914555e20c725"): 84760, + plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"): 449, + plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"): 1392, + plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"): 1230, + plumbing.NewHash("c192bd6a24ea1ab01d78686e417c8bdc7c3d197f"): 1713, + plumbing.NewHash("c2d30fa8ef288618f65f6eed6e168e0d514886f4"): 84725, + plumbing.NewHash("c8f1d8c61f9da76f4cb49fd86322b6e685dba956"): 80725, + plumbing.NewHash("cf4aa3b38974fb7d81f367c0830f7d78d65ab86b"): 84608, + plumbing.NewHash("d3ff53e0564a9f87d8e84b6e28e5060e517008aa"): 1685, + plumbing.NewHash("d5c0f4ab811897cadf03aec358ae60d21f91c50d"): 2351, + plumbing.NewHash("dbd3641b371024f44d0e469a9c8f5457b0660de1"): 84115, + plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881"): 12, + plumbing.NewHash("eba74343e2f15d62adedfd8c883ee0262b5c8021"): 84708, + plumbing.NewHash("fb72698cab7617ac416264415f13224dfd7a165e"): 84671, } diff --git a/plumbing/format/packfile/parser.go b/plumbing/format/packfile/parser.go index 62f1d13cb..b75ef26ba 100644 --- a/plumbing/format/packfile/parser.go +++ b/plumbing/format/packfile/parser.go @@ -5,12 +5,11 @@ import ( "errors" "fmt" "io" + stdsync "sync" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/utils/ioutil" - "github.com/go-git/go-git/v5/utils/sync" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/utils/ioutil" ) var ( @@ -26,522 +25,257 @@ var ( ErrDeltaNotCached = errors.New("delta could not be found in cache") ) -// Observer interface is implemented by index encoders. -type Observer interface { - // OnHeader is called when a new packfile is opened. - OnHeader(count uint32) error - // OnInflatedObjectHeader is called for each object header read. - OnInflatedObjectHeader(t plumbing.ObjectType, objSize int64, pos int64) error - // OnInflatedObjectContent is called for each decoded object. - OnInflatedObjectContent(h plumbing.Hash, pos int64, crc uint32, content []byte) error - // OnFooter is called when decoding is done. - OnFooter(h plumbing.Hash) error -} - // Parser decodes a packfile and calls any observer associated to it. Is used // to generate indexes. type Parser struct { - storage storer.EncodedObjectStorer - scanner *Scanner - count uint32 - oi []*objectInfo - oiByHash map[plumbing.Hash]*objectInfo - oiByOffset map[int64]*objectInfo - checksum plumbing.Hash - - cache *cache.BufferLRU - // delta content by offset, only used if source is not seekable - deltas map[int64][]byte - - ob []Observer -} + storage storer.EncodedObjectStorer + cache *parserCache + + scanner *Scanner + observers []Observer + hasher plumbing.Hasher -// NewParser creates a new Parser. The Scanner source must be seekable. -// If it's not, NewParserWithStorage should be used instead. -func NewParser(scanner *Scanner, ob ...Observer) (*Parser, error) { - return NewParserWithStorage(scanner, nil, ob...) + checksum plumbing.Hash + m stdsync.Mutex } -// NewParserWithStorage creates a new Parser. The scanner source must either -// be seekable or a storage must be provided. -func NewParserWithStorage( - scanner *Scanner, - storage storer.EncodedObjectStorer, - ob ...Observer, -) (*Parser, error) { - if !scanner.IsSeekable && storage == nil { - return nil, ErrNotSeekableSource +// NewParser creates a new Parser. +// When a storage is set, the objects are written to storage as they +// are parsed. +func NewParser(data io.Reader, opts ...ParserOption) *Parser { + p := &Parser{ + hasher: plumbing.NewHasher(plumbing.AnyObject, 0), } - - var deltas map[int64][]byte - if !scanner.IsSeekable { - deltas = make(map[int64][]byte) + for _, opt := range opts { + opt(p) } - return &Parser{ - storage: storage, - scanner: scanner, - ob: ob, - count: 0, - cache: cache.NewBufferLRUDefault(), - deltas: deltas, - }, nil -} + p.scanner = NewScanner(data) -func (p *Parser) forEachObserver(f func(o Observer) error) error { - for _, o := range p.ob { - if err := f(o); err != nil { - return err - } + if p.storage != nil { + p.scanner.storage = p.storage } - return nil -} - -func (p *Parser) onHeader(count uint32) error { - return p.forEachObserver(func(o Observer) error { - return o.OnHeader(count) - }) -} - -func (p *Parser) onInflatedObjectHeader( - t plumbing.ObjectType, - objSize int64, - pos int64, -) error { - return p.forEachObserver(func(o Observer) error { - return o.OnInflatedObjectHeader(t, objSize, pos) - }) -} - -func (p *Parser) onInflatedObjectContent( - h plumbing.Hash, - pos int64, - crc uint32, - content []byte, -) error { - return p.forEachObserver(func(o Observer) error { - return o.OnInflatedObjectContent(h, pos, crc, content) - }) -} + p.cache = newParserCache() -func (p *Parser) onFooter(h plumbing.Hash) error { - return p.forEachObserver(func(o Observer) error { - return o.OnFooter(h) - }) + return p } -// Parse start decoding phase of the packfile. -func (p *Parser) Parse() (plumbing.Hash, error) { - if err := p.init(); err != nil { - return plumbing.ZeroHash, err - } - - if err := p.indexObjects(); err != nil { - return plumbing.ZeroHash, err - } +func (p *Parser) storeOrCache(oh *ObjectHeader) error { + // Only need to store deltas, as the scanner already stored non-delta + // objects. + if p.storage != nil && oh.diskType.IsDelta() { + w, err := p.storage.RawObjectWriter(oh.Type, oh.Size) + if err != nil { + return err + } - var err error - p.checksum, err = p.scanner.Checksum() - if err != nil && err != io.EOF { - return plumbing.ZeroHash, err - } + defer w.Close() - if err := p.resolveDeltas(); err != nil { - return plumbing.ZeroHash, err + _, err = io.Copy(w, bytes.NewReader(oh.content.Bytes())) + if err != nil { + return err + } } - if err := p.onFooter(p.checksum); err != nil { - return plumbing.ZeroHash, err + if p.cache != nil { + p.cache.Add(oh) } - return p.checksum, nil -} - -func (p *Parser) init() error { - _, c, err := p.scanner.Header() - if err != nil { + if err := p.onInflatedObjectHeader(oh.Type, oh.Size, oh.Offset); err != nil { return err } - if err := p.onHeader(c); err != nil { + if err := p.onInflatedObjectContent(oh.Hash, oh.Offset, oh.Crc32, nil); err != nil { return err } - p.count = c - p.oiByHash = make(map[plumbing.Hash]*objectInfo, p.count) - p.oiByOffset = make(map[int64]*objectInfo, p.count) - p.oi = make([]*objectInfo, p.count) - return nil } -type objectHeaderWriter func(typ plumbing.ObjectType, sz int64) error - -type lazyObjectWriter interface { - // LazyWriter enables an object to be lazily written. - // It returns: - // - w: a writer to receive the object's content. - // - lwh: a func to write the object header. - // - err: any error from the initial writer creation process. - // - // Note that if the object header is not written BEFORE the writer - // is used, this will result in an invalid object. - LazyWriter() (w io.WriteCloser, lwh objectHeaderWriter, err error) +func (p *Parser) resetCache(qty int) { + if p.cache != nil { + p.cache.Reset(qty) + } } -func (p *Parser) indexObjects() error { - buf := sync.GetBytesBuffer() - defer sync.PutBytesBuffer(buf) - - for i := uint32(0); i < p.count; i++ { - oh, err := p.scanner.NextObjectHeader() - if err != nil { - return err - } - - delta := false - var ota *objectInfo - switch t := oh.Type; t { - case plumbing.OFSDeltaObject: - delta = true - - parent, ok := p.oiByOffset[oh.OffsetReference] - if !ok { - return plumbing.ErrObjectNotFound - } - - ota = newDeltaObject(oh.Offset, oh.Length, t, parent) - parent.Children = append(parent.Children, ota) - case plumbing.REFDeltaObject: - delta = true - parent, ok := p.oiByHash[oh.Reference] - if !ok { - // can't find referenced object in this pack file - // this must be a "thin" pack. - parent = &objectInfo{ //Placeholder parent - SHA1: oh.Reference, - ExternalRef: true, // mark as an external reference that must be resolved - Type: plumbing.AnyObject, - DiskType: plumbing.AnyObject, - } - p.oiByHash[oh.Reference] = parent - } - ota = newDeltaObject(oh.Offset, oh.Length, t, parent) - parent.Children = append(parent.Children, ota) - - default: - ota = newBaseObject(oh.Offset, oh.Length, t) - } - - hasher := plumbing.NewHasher(oh.Type, oh.Length) - writers := []io.Writer{hasher} - var obj *plumbing.MemoryObject - - // Lazy writing is only available for non-delta objects. - if p.storage != nil && !delta { - // When a storage is set and supports lazy writing, - // use that instead of creating a memory object. - if low, ok := p.storage.(lazyObjectWriter); ok { - ow, lwh, err := low.LazyWriter() - if err != nil { - return err - } - - if err = lwh(oh.Type, oh.Length); err != nil { - return err +// Parse start decoding phase of the packfile. +func (p *Parser) Parse() (plumbing.Hash, error) { + p.m.Lock() + defer p.m.Unlock() + + var pendingDeltas []*ObjectHeader + var pendingDeltaREFs []*ObjectHeader + + for p.scanner.Scan() { + data := p.scanner.Data() + switch data.Section { + case HeaderSection: + header := data.Value().(Header) + + p.resetCache(int(header.ObjectsQty)) + p.onHeader(header.ObjectsQty) + + case ObjectSection: + oh := data.Value().(ObjectHeader) + if oh.Type.IsDelta() { + if oh.Type == plumbing.OFSDeltaObject { + pendingDeltas = append(pendingDeltas, &oh) + } else if oh.Type == plumbing.REFDeltaObject { + pendingDeltaREFs = append(pendingDeltaREFs, &oh) } - - defer ow.Close() - writers = append(writers, ow) + continue } else { - obj = new(plumbing.MemoryObject) - obj.SetSize(oh.Length) - obj.SetType(oh.Type) - - writers = append(writers, obj) - } - } - if delta && !p.scanner.IsSeekable { - buf.Reset() - buf.Grow(int(oh.Length)) - writers = append(writers, buf) - } - - mw := io.MultiWriter(writers...) - - _, crc, err := p.scanner.NextObject(mw) - if err != nil { - return err - } - - // Non delta objects needs to be added into the storage. This - // is only required when lazy writing is not supported. - if obj != nil { - if _, err := p.storage.SetEncodedObject(obj); err != nil { - return err - } - } - - ota.Crc32 = crc - ota.Length = oh.Length - - if !delta { - sha1 := hasher.Sum() - - // Move children of placeholder parent into actual parent, in case this - // was a non-external delta reference. - if placeholder, ok := p.oiByHash[sha1]; ok { - ota.Children = placeholder.Children - for _, c := range ota.Children { - c.Parent = ota - } + p.storeOrCache(&oh) } - ota.SHA1 = sha1 - p.oiByHash[ota.SHA1] = ota + case FooterSection: + p.checksum = data.Value().(plumbing.Hash) } - - if delta && !p.scanner.IsSeekable { - data := buf.Bytes() - p.deltas[oh.Offset] = make([]byte, len(data)) - copy(p.deltas[oh.Offset], data) - } - - p.oiByOffset[oh.Offset] = ota - p.oi[i] = ota } - return nil -} - -func (p *Parser) resolveDeltas() error { - buf := sync.GetBytesBuffer() - defer sync.PutBytesBuffer(buf) + if p.scanner.objects == 0 { + return plumbing.ZeroHash, ErrEmptyPackfile + } - for _, obj := range p.oi { - buf.Reset() - buf.Grow(int(obj.Length)) - err := p.get(obj, buf) + for _, oh := range pendingDeltaREFs { + err := p.processDelta(oh) if err != nil { - return err - } - - if err := p.onInflatedObjectHeader(obj.Type, obj.Length, obj.Offset); err != nil { - return err - } - - if err := p.onInflatedObjectContent(obj.SHA1, obj.Offset, obj.Crc32, nil); err != nil { - return err - } - - if !obj.IsDelta() && len(obj.Children) > 0 { - // Dealing with an io.ReaderAt object, means we can - // create it once and reuse across all children. - r := bytes.NewReader(buf.Bytes()) - for _, child := range obj.Children { - // Even though we are discarding the output, we still need to read it to - // so that the scanner can advance to the next object, and the SHA1 can be - // calculated. - if err := p.resolveObject(io.Discard, child, r); err != nil { - return err - } - p.resolveExternalRef(child) - } - - // Remove the delta from the cache. - if obj.DiskType.IsDelta() && !p.scanner.IsSeekable { - delete(p.deltas, obj.Offset) - } + return plumbing.ZeroHash, err } } - return nil -} - -func (p *Parser) resolveExternalRef(o *objectInfo) { - if ref, ok := p.oiByHash[o.SHA1]; ok && ref.ExternalRef { - p.oiByHash[o.SHA1] = o - o.Children = ref.Children - for _, c := range o.Children { - c.Parent = o + for _, oh := range pendingDeltas { + err := p.processDelta(oh) + if err != nil { + return plumbing.ZeroHash, err } } -} -func (p *Parser) get(o *objectInfo, buf *bytes.Buffer) (err error) { - if !o.ExternalRef { // skip cache check for placeholder parents - b, ok := p.cache.Get(o.Offset) - if ok { - _, err := buf.Write(b) - return err - } - } + return p.checksum, p.onFooter(p.checksum) +} - // If it's not on the cache and is not a delta we can try to find it in the - // storage, if there's one. External refs must enter here. - if p.storage != nil && !o.Type.IsDelta() { - var e plumbing.EncodedObject - e, err = p.storage.EncodedObject(plumbing.AnyObject, o.SHA1) - if err != nil { - return err +func (p *Parser) processDelta(oh *ObjectHeader) error { + switch oh.Type { + case plumbing.OFSDeltaObject: + pa, ok := p.cache.oiByOffset[oh.OffsetReference] + if !ok { + return plumbing.ErrObjectNotFound } - o.Type = e.Type() + oh.parent = pa - var r io.ReadCloser - r, err = e.Reader() - if err != nil { - return err + case plumbing.REFDeltaObject: + pa, ok := p.cache.oiByHash[oh.Reference] + if !ok { + // can't find referenced object in this pack file + // this must be a "thin" pack. + oh.parent = &ObjectHeader{ //Placeholder parent + Hash: oh.Reference, + externalRef: true, // mark as an external reference that must be resolved + Type: plumbing.AnyObject, + diskType: plumbing.AnyObject, + } + } else { + oh.parent = pa } + p.cache.oiByHash[oh.Reference] = oh.parent - defer ioutil.CheckClose(r, &err) - - _, err = buf.ReadFrom(io.LimitReader(r, e.Size())) - return err + default: + return fmt.Errorf("unsupported delta type: %v", oh.Type) } - if o.ExternalRef { - // we were not able to resolve a ref in a thin pack - return ErrReferenceDeltaNotFound + parentContents, err := p.parentReader(oh.parent) + if err != nil { + return err } - if o.DiskType.IsDelta() { - b := sync.GetBytesBuffer() - defer sync.PutBytesBuffer(b) - buf.Grow(int(o.Length)) - err := p.get(o.Parent, b) - if err != nil { - return err - } - - err = p.resolveObject(buf, o, bytes.NewReader(b.Bytes())) - if err != nil { - return err - } + var deltaData bytes.Buffer + if oh.content.Len() > 0 { + oh.content.WriteTo(&deltaData) } else { - err := p.readData(buf, o) + deltaData = *bytes.NewBuffer(make([]byte, 0, oh.Size)) + err = p.scanner.inflateContent(oh.ContentOffset, &deltaData) if err != nil { return err } } - // If the scanner is seekable, caching this data into - // memory by offset seems wasteful. - // There is a trade-off to be considered here in terms - // of execution time vs memory consumption. - // - // TODO: improve seekable execution time, so that we can - // skip this cache. - if len(o.Children) > 0 { - data := make([]byte, buf.Len()) - copy(data, buf.Bytes()) - p.cache.Put(o.Offset, data) + w, err := p.cacheWriter(oh) + if err != nil { + return err } - return nil -} -// resolveObject resolves an object from base, using information -// provided by o. -// -// This call has the side-effect of changing field values -// from the object info o: -// - Type: OFSDeltaObject may become the target type (e.g. Blob). -// - Size: The size may be update with the target size. -// - Hash: Zero hashes will be calculated as part of the object -// resolution. Hence why this process can't be avoided even when w -// is an io.Discard. -// -// base must be an io.ReaderAt, which is a requirement from -// patchDeltaStream. The main reason being that reversing an -// delta object may lead to going backs and forths within base, -// which is not supported by io.Reader. -func (p *Parser) resolveObject( - w io.Writer, - o *objectInfo, - base io.ReaderAt, -) error { - if !o.DiskType.IsDelta() { - return nil - } - buf := sync.GetBytesBuffer() - defer sync.PutBytesBuffer(buf) - err := p.readData(buf, o) + defer w.Close() + + err = applyPatchBaseHeader(oh, parentContents, &deltaData, w, nil) if err != nil { return err } - writers := []io.Writer{w} - var obj *plumbing.MemoryObject - var lwh objectHeaderWriter - - if p.storage != nil { - if low, ok := p.storage.(lazyObjectWriter); ok { - ow, wh, err := low.LazyWriter() - if err != nil { - return err - } - lwh = wh + return p.storeOrCache(oh) +} - defer ow.Close() - writers = append(writers, ow) - } else { - obj = new(plumbing.MemoryObject) - ow, err := obj.Writer() - if err != nil { - return err +func (p *Parser) parentReader(parent *ObjectHeader) (io.ReaderAt, error) { + // If parent is a Delta object, the inflated object must come + // from either cache or storage, else we would need to inflate + // it to then inflate the current object, which could go on + // indefinitely. + + if p.storage != nil && parent.Hash != plumbing.ZeroHash { + obj, err := p.storage.EncodedObject(parent.Type, parent.Hash) + if err == nil { + // Ensure that external references have the correct type and size. + parent.Type = obj.Type() + parent.Size = obj.Size() + r, err := obj.Reader() + if err == nil { + parentData := bytes.NewBuffer(make([]byte, 0, parent.Size)) + + _, err = io.Copy(parentData, r) + r.Close() + + if err == nil { + return bytes.NewReader(parentData.Bytes()), nil + } } - - writers = append(writers, ow) } } - mw := io.MultiWriter(writers...) - - err = applyPatchBase(o, base, buf, mw, lwh) - if err != nil { - return err + if p.cache != nil && parent.content.Len() > 0 { + return bytes.NewReader(parent.content.Bytes()), nil } - if obj != nil { - obj.SetType(o.Type) - obj.SetSize(o.Size()) // Size here is correct as it was populated by applyPatchBase. - if _, err := p.storage.SetEncodedObject(obj); err != nil { - return err - } + // If the parent is not an external ref and we don't have the + // content offset, we won't be able to inflate via seeking through + // the packfile. + if !parent.externalRef && parent.ContentOffset == 0 { + return nil, plumbing.ErrObjectNotFound } - return err -} -func (p *Parser) readData(w io.Writer, o *objectInfo) error { - if !p.scanner.IsSeekable && o.DiskType.IsDelta() { - data, ok := p.deltas[o.Offset] - if !ok { - return ErrDeltaNotCached - } - _, err := w.Write(data) - return err + // Not a seeker data source, so avoid seeking the content. + if p.scanner.seeker == nil { + return nil, plumbing.ErrObjectNotFound } - if _, err := p.scanner.SeekObjectHeader(o.Offset); err != nil { - return err + parentData := bytes.NewBuffer(make([]byte, 0, parent.Size)) + err := p.scanner.inflateContent(parent.ContentOffset, parentData) + if err != nil { + return nil, ErrReferenceDeltaNotFound } + return bytes.NewReader(parentData.Bytes()), nil +} - if _, _, err := p.scanner.NextObject(w); err != nil { - return err - } - return nil +func (p *Parser) cacheWriter(oh *ObjectHeader) (io.WriteCloser, error) { + return ioutil.NewWriteCloser(&oh.content, nil), nil } -// applyPatchBase applies the patch to target. -// -// Note that ota will be updated based on the description in resolveObject. -func applyPatchBase(ota *objectInfo, base io.ReaderAt, delta io.Reader, target io.Writer, wh objectHeaderWriter) error { +func applyPatchBaseHeader(ota *ObjectHeader, base io.ReaderAt, delta io.Reader, target io.Writer, wh objectHeaderWriter) error { if target == nil { return fmt.Errorf("cannot apply patch against nil target") } typ := ota.Type - if ota.SHA1 == plumbing.ZeroHash { - typ = ota.Parent.Type + if ota.Hash == plumbing.ZeroHash { + typ = ota.parent.Type } sz, h, err := patchDeltaWriter(target, base, delta, typ, wh) @@ -549,63 +283,53 @@ func applyPatchBase(ota *objectInfo, base io.ReaderAt, delta io.Reader, target i return err } - if ota.SHA1 == plumbing.ZeroHash { + if ota.Hash == plumbing.ZeroHash { ota.Type = typ - ota.Length = int64(sz) - ota.SHA1 = h + ota.Size = int64(sz) + ota.Hash = h } return nil } -func getSHA1(t plumbing.ObjectType, data []byte) (plumbing.Hash, error) { - hasher := plumbing.NewHasher(t, int64(len(data))) - if _, err := hasher.Write(data); err != nil { - return plumbing.ZeroHash, err +func (p *Parser) forEachObserver(f func(o Observer) error) error { + for _, o := range p.observers { + if err := f(o); err != nil { + return err + } } - - return hasher.Sum(), nil -} - -type objectInfo struct { - Offset int64 - Length int64 - Type plumbing.ObjectType - DiskType plumbing.ObjectType - ExternalRef bool // indicates this is an external reference in a thin pack file - - Crc32 uint32 - - Parent *objectInfo - Children []*objectInfo - SHA1 plumbing.Hash + return nil } -func newBaseObject(offset, length int64, t plumbing.ObjectType) *objectInfo { - return newDeltaObject(offset, length, t, nil) +func (p *Parser) onHeader(count uint32) error { + return p.forEachObserver(func(o Observer) error { + return o.OnHeader(count) + }) } -func newDeltaObject( - offset, length int64, +func (p *Parser) onInflatedObjectHeader( t plumbing.ObjectType, - parent *objectInfo, -) *objectInfo { - obj := &objectInfo{ - Offset: offset, - Length: length, - Type: t, - DiskType: t, - Crc32: 0, - Parent: parent, - } - - return obj + objSize int64, + pos int64, +) error { + return p.forEachObserver(func(o Observer) error { + return o.OnInflatedObjectHeader(t, objSize, pos) + }) } -func (o *objectInfo) IsDelta() bool { - return o.Type.IsDelta() +func (p *Parser) onInflatedObjectContent( + h plumbing.Hash, + pos int64, + crc uint32, + content []byte, +) error { + return p.forEachObserver(func(o Observer) error { + return o.OnInflatedObjectContent(h, pos, crc, content) + }) } -func (o *objectInfo) Size() int64 { - return o.Length +func (p *Parser) onFooter(h plumbing.Hash) error { + return p.forEachObserver(func(o Observer) error { + return o.OnFooter(h) + }) } diff --git a/plumbing/format/packfile/parser_cache.go b/plumbing/format/packfile/parser_cache.go new file mode 100644 index 000000000..ebd368ca4 --- /dev/null +++ b/plumbing/format/packfile/parser_cache.go @@ -0,0 +1,42 @@ +package packfile + +import ( + "slices" + + "github.com/jesseduffield/go-git/v5/plumbing" + "golang.org/x/exp/maps" +) + +func newParserCache() *parserCache { + c := &parserCache{} + return c +} + +// parserCache defines the cache used within the parser. +// This is not thread safe by itself, and relies on the parser to +// enforce thread-safety. +type parserCache struct { + oi []*ObjectHeader + oiByHash map[plumbing.Hash]*ObjectHeader + oiByOffset map[int64]*ObjectHeader +} + +func (c *parserCache) Add(oh *ObjectHeader) { + c.oiByHash[oh.Hash] = oh + c.oiByOffset[oh.Offset] = oh + c.oi = append(c.oi, oh) +} + +func (c *parserCache) Reset(n int) { + if c.oi == nil { + c.oi = make([]*ObjectHeader, 0, n) + c.oiByHash = make(map[plumbing.Hash]*ObjectHeader, n) + c.oiByOffset = make(map[int64]*ObjectHeader, n) + } else { + c.oi = c.oi[:0] + c.oi = slices.Grow(c.oi, n) + + maps.Clear(c.oiByHash) + maps.Clear(c.oiByOffset) + } +} diff --git a/plumbing/format/packfile/parser_options.go b/plumbing/format/packfile/parser_options.go new file mode 100644 index 000000000..0b05e02dc --- /dev/null +++ b/plumbing/format/packfile/parser_options.go @@ -0,0 +1,27 @@ +package packfile + +import ( + "github.com/jesseduffield/go-git/v5/plumbing/storer" +) + +type ParserOption func(*Parser) + +// WithStorage sets the storage to be used while parsing a pack file. +func WithStorage(storage storer.EncodedObjectStorer) ParserOption { + return func(p *Parser) { + p.storage = storage + } +} + +// WithScannerObservers sets the observers to be notified during the +// scanning or parsing of a pack file. The scanner is responsible for +// notifying observers around general pack file information, such as +// header and footer. The scanner also notifies object headers for +// non-delta objects. +// +// Delta objects are notified as part of the parser logic. +func WithScannerObservers(ob ...Observer) ParserOption { + return func(p *Parser) { + p.observers = ob + } +} diff --git a/plumbing/format/packfile/parser_test.go b/plumbing/format/packfile/parser_test.go index b8d080f68..3413c60cc 100644 --- a/plumbing/format/packfile/parser_test.go +++ b/plumbing/format/packfile/parser_test.go @@ -2,162 +2,205 @@ package packfile_test import ( "io" - "os" "testing" + billy "github.com/go-git/go-billy/v5" "github.com/go-git/go-billy/v5/osfs" - "github.com/go-git/go-billy/v5/util" - fixtures "github.com/go-git/go-git-fixtures/v4" - "github.com/go-git/go-git/v5" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/format/packfile" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage/filesystem" - . "gopkg.in/check.v1" + fixtures "github.com/go-git/go-git-fixtures/v5" + "github.com/jesseduffield/go-git/v5" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/format/packfile" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/assert" ) -type ParserSuite struct { - fixtures.Suite -} - -var _ = Suite(&ParserSuite{}) - -func (s *ParserSuite) TestParserHashes(c *C) { - f := fixtures.Basic().One() - scanner := packfile.NewScanner(f.Packfile()) - - obs := new(testObserver) - parser, err := packfile.NewParser(scanner, obs) - c.Assert(err, IsNil) - - ch, err := parser.Parse() - c.Assert(err, IsNil) - - checksum := "a3fed42da1e8189a077c0e6846c040dcf73fc9dd" - c.Assert(ch.String(), Equals, checksum) - - c.Assert(obs.checksum, Equals, checksum) - c.Assert(int(obs.count), Equals, int(31)) - - commit := plumbing.CommitObject - blob := plumbing.BlobObject - tree := plumbing.TreeObject - - objs := []observerObject{ - {"e8d3ffab552895c19b9fcf7aa264d277cde33881", commit, 254, 12, 0xaa07ba4b}, - {"6ecf0ef2c2dffb796033e5a02219af86ec6584e5", commit, 245, 186, 0xf706df58}, - {"918c48b83bd081e863dbe1b80f8998f058cd8294", commit, 242, 286, 0x12438846}, - {"af2d6a6954d532f8ffb47615169c8fdf9d383a1a", commit, 242, 449, 0x2905a38c}, - {"1669dce138d9b841a518c64b10914d88f5e488ea", commit, 333, 615, 0xd9429436}, - {"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69", commit, 332, 838, 0xbecfde4e}, - {"35e85108805c84807bc66a02d91535e1e24b38b9", commit, 244, 1063, 0x780e4b3e}, - {"b8e471f58bcbca63b07bda20e428190409c2db47", commit, 243, 1230, 0xdc18344f}, - {"b029517f6300c2da0f4b651b8642506cd6aaf45d", commit, 187, 1392, 0xcf4e4280}, - {"32858aad3c383ed1ff0a0f9bdf231d54a00c9e88", blob, 189, 1524, 0x1f08118a}, - {"d3ff53e0564a9f87d8e84b6e28e5060e517008aa", blob, 18, 1685, 0xafded7b8}, - {"c192bd6a24ea1ab01d78686e417c8bdc7c3d197f", blob, 1072, 1713, 0xcc1428ed}, - {"d5c0f4ab811897cadf03aec358ae60d21f91c50d", blob, 76110, 2351, 0x1631d22f}, - {"880cd14280f4b9b6ed3986d6671f907d7cc2a198", blob, 2780, 78050, 0xbfff5850}, - {"49c6bb89b17060d7b4deacb7b338fcc6ea2352a9", blob, 217848, 78882, 0xd108e1d8}, - {"c8f1d8c61f9da76f4cb49fd86322b6e685dba956", blob, 706, 80725, 0x8e97ba25}, - {"9a48f23120e880dfbe41f7c9b7b708e9ee62a492", blob, 11488, 80998, 0x7316ff70}, - {"9dea2395f5403188298c1dabe8bdafe562c491e3", blob, 78, 84032, 0xdb4fce56}, - {"dbd3641b371024f44d0e469a9c8f5457b0660de1", tree, 272, 84115, 0x901cce2c}, - {"a8d315b2b1c615d43042c3a62402b8a54288cf5c", tree, 271, 84375, 0xec4552b0}, - {"a39771a7651f97faf5c72e08224d857fc35133db", tree, 38, 84430, 0x847905bf}, - {"5a877e6a906a2743ad6e45d99c1793642aaf8eda", tree, 75, 84479, 0x3689459a}, - {"586af567d0bb5e771e49bdd9434f5e0fb76d25fa", tree, 38, 84559, 0xe67af94a}, - {"cf4aa3b38974fb7d81f367c0830f7d78d65ab86b", tree, 34, 84608, 0xc2314a2e}, - {"7e59600739c96546163833214c36459e324bad0a", blob, 9, 84653, 0xcd987848}, - {"fb72698cab7617ac416264415f13224dfd7a165e", tree, 238, 84671, 0x8a853a6d}, - {"4d081c50e250fa32ea8b1313cf8bb7c2ad7627fd", tree, 179, 84688, 0x70c6518}, - {"eba74343e2f15d62adedfd8c883ee0262b5c8021", tree, 148, 84708, 0x4f4108e2}, - {"c2d30fa8ef288618f65f6eed6e168e0d514886f4", tree, 110, 84725, 0xd6fe09e9}, - {"8dcef98b1d52143e1e2dbc458ffe38f925786bf2", tree, 111, 84741, 0xf07a2804}, - {"aa9b383c260e1d05fbbf6b30a02914555e20c725", tree, 73, 84760, 0x1d75d6be}, +func TestParserHashes(t *testing.T) { + tests := []struct { + name string + storage storer.Storer + }{ + { + name: "without storage", + }, + { + name: "with storage", + storage: filesystem.NewStorage(osfs.New(t.TempDir()), cache.NewObjectLRUDefault()), + }, } - c.Assert(obs.objects, DeepEquals, objs) -} + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + f := fixtures.Basic().One() + + obs := new(testObserver) + parser := packfile.NewParser(f.Packfile(), packfile.WithScannerObservers(obs), + packfile.WithStorage(tc.storage)) + + commit := plumbing.CommitObject + blob := plumbing.BlobObject + tree := plumbing.TreeObject + + objs := []observerObject{ + {hash: "e8d3ffab552895c19b9fcf7aa264d277cde33881", otype: commit, size: 254, offset: 12, crc: 0xaa07ba4b}, + {hash: "918c48b83bd081e863dbe1b80f8998f058cd8294", otype: commit, size: 242, offset: 286, crc: 0x12438846}, + {hash: "af2d6a6954d532f8ffb47615169c8fdf9d383a1a", otype: commit, size: 242, offset: 449, crc: 0x2905a38c}, + {hash: "1669dce138d9b841a518c64b10914d88f5e488ea", otype: commit, size: 333, offset: 615, crc: 0xd9429436}, + {hash: "a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69", otype: commit, size: 332, offset: 838, crc: 0xbecfde4e}, + {hash: "35e85108805c84807bc66a02d91535e1e24b38b9", otype: commit, size: 244, offset: 1063, crc: 0x780e4b3e}, + {hash: "b8e471f58bcbca63b07bda20e428190409c2db47", otype: commit, size: 243, offset: 1230, crc: 0xdc18344f}, + {hash: "b029517f6300c2da0f4b651b8642506cd6aaf45d", otype: commit, size: 187, offset: 1392, crc: 0xcf4e4280}, + {hash: "32858aad3c383ed1ff0a0f9bdf231d54a00c9e88", otype: blob, size: 189, offset: 1524, crc: 0x1f08118a}, + {hash: "d3ff53e0564a9f87d8e84b6e28e5060e517008aa", otype: blob, size: 18, offset: 1685, crc: 0xafded7b8}, + {hash: "c192bd6a24ea1ab01d78686e417c8bdc7c3d197f", otype: blob, size: 1072, offset: 1713, crc: 0xcc1428ed}, + {hash: "d5c0f4ab811897cadf03aec358ae60d21f91c50d", otype: blob, size: 76110, offset: 2351, crc: 0x1631d22f}, + {hash: "880cd14280f4b9b6ed3986d6671f907d7cc2a198", otype: blob, size: 2780, offset: 78050, crc: 0xbfff5850}, + {hash: "49c6bb89b17060d7b4deacb7b338fcc6ea2352a9", otype: blob, size: 217848, offset: 78882, crc: 0xd108e1d8}, + {hash: "c8f1d8c61f9da76f4cb49fd86322b6e685dba956", otype: blob, size: 706, offset: 80725, crc: 0x8e97ba25}, + {hash: "9a48f23120e880dfbe41f7c9b7b708e9ee62a492", otype: blob, size: 11488, offset: 80998, crc: 0x7316ff70}, + {hash: "9dea2395f5403188298c1dabe8bdafe562c491e3", otype: blob, size: 78, offset: 84032, crc: 0xdb4fce56}, + {hash: "dbd3641b371024f44d0e469a9c8f5457b0660de1", otype: tree, size: 272, offset: 84115, crc: 0x901cce2c}, + {hash: "a39771a7651f97faf5c72e08224d857fc35133db", otype: tree, size: 38, offset: 84430, crc: 0x847905bf}, + {hash: "5a877e6a906a2743ad6e45d99c1793642aaf8eda", otype: tree, size: 75, offset: 84479, crc: 0x3689459a}, + {hash: "586af567d0bb5e771e49bdd9434f5e0fb76d25fa", otype: tree, size: 38, offset: 84559, crc: 0xe67af94a}, + {hash: "cf4aa3b38974fb7d81f367c0830f7d78d65ab86b", otype: tree, size: 34, offset: 84608, crc: 0xc2314a2e}, + {hash: "7e59600739c96546163833214c36459e324bad0a", otype: blob, size: 9, offset: 84653, crc: 0xcd987848}, + {hash: "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", otype: commit, size: 245, offset: 186, crc: 0xf706df58}, + {hash: "a8d315b2b1c615d43042c3a62402b8a54288cf5c", otype: tree, size: 271, offset: 84375, crc: 0xec4552b0}, + {hash: "fb72698cab7617ac416264415f13224dfd7a165e", otype: tree, size: 238, offset: 84671, crc: 0x8a853a6d}, + {hash: "4d081c50e250fa32ea8b1313cf8bb7c2ad7627fd", otype: tree, size: 179, offset: 84688, crc: 0x70c6518}, + {hash: "eba74343e2f15d62adedfd8c883ee0262b5c8021", otype: tree, size: 148, offset: 84708, crc: 0x4f4108e2}, + {hash: "c2d30fa8ef288618f65f6eed6e168e0d514886f4", otype: tree, size: 110, offset: 84725, crc: 0xd6fe09e9}, + {hash: "8dcef98b1d52143e1e2dbc458ffe38f925786bf2", otype: tree, size: 111, offset: 84741, crc: 0xf07a2804}, + {hash: "aa9b383c260e1d05fbbf6b30a02914555e20c725", otype: tree, size: 73, offset: 84760, crc: 0x1d75d6be}, + } -func (s *ParserSuite) TestThinPack(c *C) { - fs := osfs.New(os.TempDir()) - path, err := util.TempDir(fs, "", "") - c.Assert(err, IsNil) + _, err := parser.Parse() + assert.NoError(t, err) + assert.Equal(t, "a3fed42da1e8189a077c0e6846c040dcf73fc9dd", obs.checksum) + assert.Equal(t, objs, obs.objects) + }) + } +} + +func TestThinPack(t *testing.T) { // Initialize an empty repository - r, err := git.PlainInit(path, true) - c.Assert(err, IsNil) + r, err := git.PlainInit(t.TempDir(), true) + assert.NoError(t, err) // Try to parse a thin pack without having the required objects in the repo to // see if the correct errors are returned thinpack := fixtures.ByTag("thinpack").One() - scanner := packfile.NewScanner(thinpack.Packfile()) - parser, err := packfile.NewParserWithStorage(scanner, r.Storer) // ParserWithStorage writes to the storer all parsed objects! - c.Assert(err, IsNil) + parser := packfile.NewParser(thinpack.Packfile(), packfile.WithStorage(r.Storer)) // ParserWithStorage writes to the storer all parsed objects! + assert.NoError(t, err) _, err = parser.Parse() - c.Assert(err, Equals, plumbing.ErrObjectNotFound) - - path, err = util.TempDir(fs, "", "") - c.Assert(err, IsNil) + assert.Equal(t, err, packfile.ErrReferenceDeltaNotFound) // start over with a clean repo - r, err = git.PlainInit(path, true) - c.Assert(err, IsNil) + r, err = git.PlainInit(t.TempDir(), true) + assert.NoError(t, err) // Now unpack a base packfile into our empty repo: f := fixtures.ByURL("https://github.com/spinnaker/spinnaker.git").One() w, err := r.Storer.(storer.PackfileWriter).PackfileWriter() - c.Assert(err, IsNil) + assert.NoError(t, err) _, err = io.Copy(w, f.Packfile()) - c.Assert(err, IsNil) - w.Close() + assert.NoError(t, err) + assert.NoError(t, w.Close()) // Check that the test object that will come with our thin pack is *not* in the repo _, err = r.Storer.EncodedObject(plumbing.CommitObject, plumbing.NewHash(thinpack.Head)) - c.Assert(err, Equals, plumbing.ErrObjectNotFound) + assert.ErrorIs(t, err, plumbing.ErrObjectNotFound) // Now unpack the thin pack: - scanner = packfile.NewScanner(thinpack.Packfile()) - parser, err = packfile.NewParserWithStorage(scanner, r.Storer) // ParserWithStorage writes to the storer all parsed objects! - c.Assert(err, IsNil) + parser = packfile.NewParser(thinpack.Packfile(), packfile.WithStorage(r.Storer)) // ParserWithStorage writes to the storer all parsed objects! h, err := parser.Parse() - c.Assert(err, IsNil) - c.Assert(h, Equals, plumbing.NewHash("1288734cbe0b95892e663221d94b95de1f5d7be8")) + assert.NoError(t, err) + assert.Equal(t, plumbing.NewHash("1288734cbe0b95892e663221d94b95de1f5d7be8"), h) // Check that our test object is now accessible _, err = r.Storer.EncodedObject(plumbing.CommitObject, plumbing.NewHash(thinpack.Head)) - c.Assert(err, IsNil) + assert.NoError(t, err) +} + +func TestResolveExternalRefsInThinPack(t *testing.T) { + extRefsThinPack := fixtures.ByTag("codecommit").One().Packfile() + parser := packfile.NewParser(extRefsThinPack) + + checksum, err := parser.Parse() + assert.NoError(t, err) + assert.NotEqual(t, plumbing.ZeroHash, checksum) } -func (s *ParserSuite) TestResolveExternalRefsInThinPack(c *C) { - extRefsThinPack := fixtures.ByTag("codecommit").One() +func TestResolveExternalRefs(t *testing.T) { + extRefsThinPack := fixtures.ByTag("delta-before-base").One().Packfile() + + parser := packfile.NewParser(extRefsThinPack) - scanner := packfile.NewScanner(extRefsThinPack.Packfile()) + checksum, err := parser.Parse() + assert.NoError(t, err) + assert.NotEqual(t, plumbing.ZeroHash, checksum) +} - obs := new(testObserver) - parser, err := packfile.NewParser(scanner, obs) - c.Assert(err, IsNil) +func TestMemoryResolveExternalRefs(t *testing.T) { + extRefsThinPack := fixtures.ByTag("delta-before-base").One().Packfile() - _, err = parser.Parse() - c.Assert(err, IsNil) + parser := packfile.NewParser(extRefsThinPack, packfile.WithStorage(memory.NewStorage())) + + checksum, err := parser.Parse() + assert.NoError(t, err) + assert.NotEqual(t, plumbing.ZeroHash, checksum) +} + +func BenchmarkParseBasic(b *testing.B) { + f := fixtures.Basic().One().Packfile() + scanner := packfile.NewScanner(f) + storage := filesystem.NewStorage(osfs.New(b.TempDir()), cache.NewObjectLRUDefault()) + + b.Run("with storage", func(b *testing.B) { + benchmarkParseBasic(b, f, scanner, packfile.WithStorage(storage)) + }) + b.Run("with memory storage", func(b *testing.B) { + benchmarkParseBasic(b, f, scanner, packfile.WithStorage(memory.NewStorage())) + }) + b.Run("without storage", func(b *testing.B) { + benchmarkParseBasic(b, f, scanner) + }) } -func (s *ParserSuite) TestResolveExternalRefs(c *C) { - extRefsThinPack := fixtures.ByTag("delta-before-base").One() +func benchmarkParseBasic(b *testing.B, + f billy.File, scanner *packfile.Scanner, + opts ...packfile.ParserOption) { + for i := 0; i < b.N; i++ { + f.Seek(0, io.SeekStart) + scanner.Reset() + parser := packfile.NewParser(scanner, opts...) - scanner := packfile.NewScanner(extRefsThinPack.Packfile()) + checksum, err := parser.Parse() + if err != nil { + b.Fatal(err) + } - obs := new(testObserver) - parser, err := packfile.NewParser(scanner, obs) - c.Assert(err, IsNil) + if checksum == plumbing.ZeroHash { + b.Fatal("failed to parse") + } + } +} - _, err = parser.Parse() - c.Assert(err, IsNil) +func BenchmarkParse(b *testing.B) { + for _, f := range fixtures.ByTag("packfile") { + scanner := packfile.NewScanner(f.Packfile()) + + b.Run(f.URL, func(b *testing.B) { + benchmarkParseBasic(b, f.Packfile(), scanner) + }) + } } type observerObject struct { @@ -226,66 +269,3 @@ func (t *testObserver) put(pos int64, o observerObject) { t.pos[pos] = len(t.objects) t.objects = append(t.objects, o) } - -func BenchmarkParse(b *testing.B) { - defer fixtures.Clean() - - for _, f := range fixtures.ByTag("packfile") { - b.Run(f.URL, func(b *testing.B) { - for i := 0; i < b.N; i++ { - parser, err := packfile.NewParser(packfile.NewScanner(f.Packfile())) - if err != nil { - b.Fatal(err) - } - - _, err = parser.Parse() - if err != nil { - b.Fatal(err) - } - } - }) - } -} - -func BenchmarkParseBasic(b *testing.B) { - defer fixtures.Clean() - - f := fixtures.Basic().One() - for i := 0; i < b.N; i++ { - parser, err := packfile.NewParser(packfile.NewScanner(f.Packfile())) - if err != nil { - b.Fatal(err) - } - - _, err = parser.Parse() - if err != nil { - b.Fatal(err) - } - } -} - -func BenchmarkParser(b *testing.B) { - f := fixtures.Basic().One() - defer fixtures.Clean() - - b.ResetTimer() - for n := 0; n < b.N; n++ { - b.StopTimer() - scanner := packfile.NewScanner(f.Packfile()) - fs := osfs.New(os.TempDir()) - storage := filesystem.NewStorage(fs, cache.NewObjectLRUDefault()) - - parser, err := packfile.NewParserWithStorage(scanner, storage) - if err != nil { - b.Error(err) - } - - b.StartTimer() - _, err = parser.Parse() - - b.StopTimer() - if err != nil { - b.Error(err) - } - } -} diff --git a/plumbing/format/packfile/parser_types.go b/plumbing/format/packfile/parser_types.go new file mode 100644 index 000000000..e34ccb409 --- /dev/null +++ b/plumbing/format/packfile/parser_types.go @@ -0,0 +1,19 @@ +package packfile + +import ( + "github.com/jesseduffield/go-git/v5/plumbing" +) + +// Observer interface is implemented by index encoders. +type Observer interface { + // OnHeader is called when a new packfile is opened. + OnHeader(count uint32) error + // OnInflatedObjectHeader is called for each object header read. + OnInflatedObjectHeader(t plumbing.ObjectType, objSize int64, pos int64) error + // OnInflatedObjectContent is called for each decoded object. + OnInflatedObjectContent(h plumbing.Hash, pos int64, crc uint32, content []byte) error + // OnFooter is called when decoding is done. + OnFooter(h plumbing.Hash) error +} + +type objectHeaderWriter func(typ plumbing.ObjectType, sz int64) error diff --git a/plumbing/format/packfile/patch_delta.go b/plumbing/format/packfile/patch_delta.go index 960769c7c..54d9b08b2 100644 --- a/plumbing/format/packfile/patch_delta.go +++ b/plumbing/format/packfile/patch_delta.go @@ -8,9 +8,9 @@ import ( "io" "math" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/utils/ioutil" - "github.com/go-git/go-git/v5/utils/sync" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/utils/sync" ) // See https://github.com/git/git/blob/49fa3dc76179e04b0833542fa52d0f287a4955ac/delta.h @@ -26,6 +26,13 @@ var ( const ( payload = 0x7f // 0111 1111 continuation = 0x80 // 1000 0000 + + // maxPatchPreemptionSize defines what is the max size of bytes to be + // premptively made available for a patch operation. + maxPatchPreemptionSize uint = 65536 + + // minDeltaSize defines the smallest size for a delta. + minDeltaSize = 4 ) type offset struct { @@ -86,9 +93,13 @@ func ApplyDelta(target, base plumbing.EncodedObject, delta []byte) (err error) { } // PatchDelta returns the result of applying the modification deltas in delta to src. -// An error will be returned if delta is corrupted (ErrDeltaLen) or an action command +// An error will be returned if delta is corrupted (ErrInvalidDelta) or an action command // is not copy from source or copy from delta (ErrDeltaCmd). func PatchDelta(src, delta []byte) ([]byte, error) { + if len(src) == 0 || len(delta) < minDeltaSize { + return nil, ErrInvalidDelta + } + b := &bytes.Buffer{} if err := patchDelta(b, src, delta); err != nil { return nil, err @@ -239,7 +250,9 @@ func patchDelta(dst *bytes.Buffer, src, delta []byte) error { remainingTargetSz := targetSz var cmd byte - dst.Grow(int(targetSz)) + + growSz := min(targetSz, maxPatchPreemptionSize) + dst.Grow(int(growSz)) for { if len(delta) == 0 { return ErrInvalidDelta @@ -403,6 +416,10 @@ func patchDeltaWriter(dst io.Writer, base io.ReaderAt, delta io.Reader, // This must be called twice on the delta data buffer, first to get the // expected source buffer size, and again to get the target buffer size. func decodeLEB128(input []byte) (uint, []byte) { + if len(input) == 0 { + return 0, input + } + var num, sz uint var b byte for { diff --git a/plumbing/format/packfile/patch_delta_test.go b/plumbing/format/packfile/patch_delta_test.go new file mode 100644 index 000000000..0a4d99f21 --- /dev/null +++ b/plumbing/format/packfile/patch_delta_test.go @@ -0,0 +1,72 @@ +package packfile + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestDecodeLEB128(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + input []byte + want uint + wantRest []byte + }{ + { + name: "single byte, small number", + input: []byte{0x01, 0xFF}, + want: 1, + wantRest: []byte{0xFF}, + }, + { + name: "single byte, max value without continuation", + input: []byte{0x7F, 0xFF}, + want: 127, + wantRest: []byte{0xFF}, + }, + { + name: "two bytes", + input: []byte{0x80, 0x01, 0xFF}, + want: 128, + wantRest: []byte{0xFF}, + }, + { + name: "two bytes, larger number", + input: []byte{0xFF, 0x01, 0xFF}, + want: 255, + wantRest: []byte{0xFF}, + }, + { + name: "three bytes", + input: []byte{0x80, 0x80, 0x01, 0xFF}, + want: 16384, + wantRest: []byte{0xFF}, + }, + { + name: "empty remaining bytes", + input: []byte{0x01}, + want: 1, + wantRest: []byte{}, + }, + { + name: "empty input", + input: []byte{}, + want: 0, + wantRest: []byte{}, + }, + } + + for _, tc := range tests { + tc := tc + t.Run(tc.name, func(t *testing.T) { + t.Parallel() + + gotNum, gotRest := decodeLEB128(tc.input) + assert.Equal(t, tc.want, gotNum, "decoded number mismatch") + assert.Equal(t, tc.wantRest, gotRest, "remaining bytes mismatch") + }) + } +} diff --git a/plumbing/format/packfile/scanner.go b/plumbing/format/packfile/scanner.go index 730343ee3..ad28f21c0 100644 --- a/plumbing/format/packfile/scanner.go +++ b/plumbing/format/packfile/scanner.go @@ -1,474 +1,499 @@ package packfile import ( - "bufio" "bytes" + "encoding/hex" "fmt" "hash" "hash/crc32" "io" + "sync" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/utils/binary" - "github.com/go-git/go-git/v5/utils/ioutil" - "github.com/go-git/go-git/v5/utils/sync" + "github.com/jesseduffield/go-git/v5/plumbing" + gogithash "github.com/jesseduffield/go-git/v5/plumbing/hash" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/utils/binary" + gogitsync "github.com/jesseduffield/go-git/v5/utils/sync" ) var ( - // ErrEmptyPackfile is returned by ReadHeader when no data is found in the packfile + // ErrEmptyPackfile is returned by ReadHeader when no data is found in the packfile. ErrEmptyPackfile = NewError("empty packfile") // ErrBadSignature is returned by ReadHeader when the signature in the packfile is incorrect. ErrBadSignature = NewError("malformed pack file signature") + // ErrMalformedPackfile is returned when the packfile format is incorrect. + ErrMalformedPackfile = NewError("malformed pack file") // ErrUnsupportedVersion is returned by ReadHeader when the packfile version is // different than VersionSupported. ErrUnsupportedVersion = NewError("unsupported packfile version") - // ErrSeekNotSupported returned if seek is not support + // ErrSeekNotSupported returned if seek is not support. ErrSeekNotSupported = NewError("not seek support") ) -// ObjectHeader contains the information related to the object, this information -// is collected from the previous bytes to the content of the object. -type ObjectHeader struct { - Type plumbing.ObjectType - Offset int64 - Length int64 - Reference plumbing.Hash - OffsetReference int64 -} - +// Scanner provides sequential access to the data stored in a Git packfile. +// +// A Git packfile is a compressed binary format that stores multiple Git objects, +// such as commits, trees, delta objects and blobs. These packfiles are used to +// reduce the size of data when transferring or storing Git repositories. +// +// A Git packfile is structured as follows: +// +// +----------------------------------------------------+ +// | PACK File Header | +// +----------------------------------------------------+ +// | "PACK" | Version Number | Number of Objects | +// | (4 bytes) | (4 bytes) | (4 bytes) | +// +----------------------------------------------------+ +// | Object Entry #1 | +// +----------------------------------------------------+ +// | Object Header | Compressed Object Data / Delta | +// | (type + size) | (var-length, zlib compressed) | +// +----------------------------------------------------+ +// | ... | +// +----------------------------------------------------+ +// | PACK File Footer | +// +----------------------------------------------------+ +// | SHA-1 Checksum (20 bytes) | +// +----------------------------------------------------+ +// +// For upstream docs, refer to https://git-scm.com/docs/gitformat-pack. type Scanner struct { - r *scannerReader + // version holds the packfile version. + version Version + // objects holds the quantiy of objects within the packfile. + objects uint32 + // objIndex is the current index when going through the packfile objects. + objIndex int + // hasher is used to hash non-delta objects. + hasher plumbing.Hasher + // hasher256 is optional and used to hash the non-delta objects using SHA256. + hasher256 *plumbing.Hasher256 + // crc is used to generate the CRC-32 checksum of each object's content. crc hash.Hash32 + // packhash hashes the pack contents so that at the end it is able to + // validate the packfile's footer checksum against the calculated hash. + packhash gogithash.Hash - // pendingObject is used to detect if an object has been read, or still - // is waiting to be read - pendingObject *ObjectHeader - version, objects uint32 + // next holds what state function should be executed on the next + // call to Scan(). + nextFn stateFn + // packData holds the data for the last successful call to Scan(). + packData PackData + // err holds the first error that occurred. + err error - // lsSeekable says if this scanner can do Seek or not, to have a Scanner - // seekable a r implementing io.Seeker is required - IsSeekable bool -} + m sync.Mutex -// NewScanner returns a new Scanner based on a reader, if the given reader -// implements io.ReadSeeker the Scanner will be also Seekable -func NewScanner(r io.Reader) *Scanner { - _, ok := r.(io.ReadSeeker) + // storage is optional, and when set is used to store full objects found. + // Note that delta objects are not stored. + storage storer.EncodedObjectStorer - crc := crc32.NewIEEE() - return &Scanner{ - r: newScannerReader(r, crc), - crc: crc, - IsSeekable: ok, - } + *scannerReader + zr gogitsync.ZLibReader + buf bytes.Buffer } -func (s *Scanner) Reset(r io.Reader) { - _, ok := r.(io.ReadSeeker) - - s.r.Reset(r) - s.crc.Reset() - s.IsSeekable = ok - s.pendingObject = nil - s.version = 0 - s.objects = 0 -} +// NewScanner creates a new instance of Scanner. +func NewScanner(rs io.Reader, opts ...ScannerOption) *Scanner { + dict := make([]byte, 16*1024) + crc := crc32.NewIEEE() + packhash := gogithash.New(gogithash.CryptoType) -// Header reads the whole packfile header (signature, version and object count). -// It returns the version and the object count and performs checks on the -// validity of the signature and the version fields. -func (s *Scanner) Header() (version, objects uint32, err error) { - if s.version != 0 { - return s.version, s.objects, nil + r := &Scanner{ + scannerReader: newScannerReader(rs, io.MultiWriter(crc, packhash)), + zr: gogitsync.NewZlibReader(&dict), + objIndex: -1, + hasher: plumbing.NewHasher(plumbing.AnyObject, 0), + crc: crc, + packhash: packhash, + nextFn: packHeaderSignature, } - sig, err := s.readSignature() - if err != nil { - if err == io.EOF { - err = ErrEmptyPackfile - } - - return + for _, opt := range opts { + opt(r) } - if !s.isValidSignature(sig) { - err = ErrBadSignature - return - } + return r +} - version, err = s.readVersion() - s.version = version - if err != nil { - return - } +// Scan scans a Packfile sequently. Each call will navigate from a section +// to the next, until the entire file is read. +// +// The section data can be accessed via calls to Data(). Example: +// +// for scanner.Scan() { +// v := scanner.Data().Value() +// +// switch scanner.Data().Section { +// case HeaderSection: +// header := v.(Header) +// fmt.Println("[Header] Objects Qty:", header.ObjectsQty) +// case ObjectSection: +// oh := v.(ObjectHeader) +// fmt.Println("[Object] Object Type:", oh.Type) +// case FooterSection: +// checksum := v.(plumbing.Hash) +// fmt.Println("[Footer] Checksum:", checksum) +// } +// } +func (r *Scanner) Scan() bool { + r.m.Lock() + defer r.m.Unlock() - if !s.isSupportedVersion(version) { - err = ErrUnsupportedVersion.AddDetails("%d", version) - return + if r.err != nil || r.nextFn == nil { + return false } - objects, err = s.readCount() - s.objects = objects - return -} - -// readSignature reads a returns the signature field in the packfile. -func (s *Scanner) readSignature() ([]byte, error) { - var sig = make([]byte, 4) - if _, err := io.ReadFull(s.r, sig); err != nil { - return []byte{}, err + if err := scan(r); err != nil { + r.err = err + return false } - return sig, nil + return true } -// isValidSignature returns if sig is a valid packfile signature. -func (s *Scanner) isValidSignature(sig []byte) bool { - return bytes.Equal(sig, signature) -} +// Reset resets the current scanner, enabling it to be used to scan the +// same Packfile again. +func (r *Scanner) Reset() { + r.scannerReader.Flush() + r.scannerReader.Seek(0, io.SeekStart) + r.packhash.Reset() -// readVersion reads and returns the version field of a packfile. -func (s *Scanner) readVersion() (uint32, error) { - return binary.ReadUint32(s.r) + r.objIndex = -1 + r.version = 0 + r.objects = 0 + r.packData = PackData{} + r.err = nil + r.nextFn = packHeaderSignature } -// isSupportedVersion returns whether version v is supported by the parser. -// The current supported version is VersionSupported, defined above. -func (s *Scanner) isSupportedVersion(v uint32) bool { - return v == VersionSupported +// Data returns the pack data based on the last call to Scan(). +func (r *Scanner) Data() PackData { + return r.packData } -// readCount reads and returns the count of objects field of a packfile. -func (s *Scanner) readCount() (uint32, error) { - return binary.ReadUint32(s.r) +// Data returns the first error that occurred on the last call to Scan(). +// Once an error occurs, calls to Scan() becomes a no-op. +func (r *Scanner) Error() error { + return r.err } -// SeekObjectHeader seeks to specified offset and returns the ObjectHeader -// for the next object in the reader -func (s *Scanner) SeekObjectHeader(offset int64) (*ObjectHeader, error) { - // if seeking we assume that you are not interested in the header - if s.version == 0 { - s.version = VersionSupported - } +func (r *Scanner) SeekFromStart(offset int64) error { + r.Reset() - if _, err := s.r.Seek(offset, io.SeekStart); err != nil { - return nil, err + if !r.Scan() { + return fmt.Errorf("failed to reset and read header") } - h, err := s.nextObjectHeader() - if err != nil { - return nil, err - } - - h.Offset = offset - return h, nil + _, err := r.scannerReader.Seek(offset, io.SeekStart) + return err } -// NextObjectHeader returns the ObjectHeader for the next object in the reader -func (s *Scanner) NextObjectHeader() (*ObjectHeader, error) { - if err := s.doPending(); err != nil { - return nil, err +func (s *Scanner) WriteObject(oh *ObjectHeader, writer io.Writer) error { + if oh.content.Len() > 0 { + _, err := io.Copy(writer, bytes.NewReader(oh.content.Bytes())) + return err } - offset, err := s.r.Seek(0, io.SeekCurrent) - if err != nil { - return nil, err + // If the oh is not an external ref and we don't have the + // content offset, we won't be able to inflate via seeking through + // the packfile. + if oh.externalRef && oh.ContentOffset == 0 { + return plumbing.ErrObjectNotFound } - h, err := s.nextObjectHeader() + // Not a seeker data source. + if s.seeker == nil { + return plumbing.ErrObjectNotFound + } + + err := s.inflateContent(oh.ContentOffset, writer) if err != nil { - return nil, err + return ErrReferenceDeltaNotFound } - h.Offset = offset - return h, nil + return nil } -// nextObjectHeader returns the ObjectHeader for the next object in the reader -// without the Offset field -func (s *Scanner) nextObjectHeader() (*ObjectHeader, error) { - s.r.Flush() - s.crc.Reset() - - h := &ObjectHeader{} - s.pendingObject = h - - var err error - h.Offset, err = s.r.Seek(0, io.SeekCurrent) +func (s *Scanner) inflateContent(contentOffset int64, writer io.Writer) error { + _, err := s.scannerReader.Seek(contentOffset, io.SeekStart) if err != nil { - return nil, err + return err } - h.Type, h.Length, err = s.readObjectTypeAndLength() + err = s.zr.Reset(s.scannerReader) if err != nil { - return nil, err + return fmt.Errorf("zlib reset error: %s", err) } - switch h.Type { - case plumbing.OFSDeltaObject: - no, err := binary.ReadVariableWidthInt(s.r) - if err != nil { - return nil, err - } - - h.OffsetReference = h.Offset - no - case plumbing.REFDeltaObject: - var err error - h.Reference, err = binary.ReadHash(s.r) - if err != nil { - return nil, err - } + _, err = io.Copy(writer, s.zr.Reader) + if err != nil { + return err } - return h, nil + return nil } -func (s *Scanner) doPending() error { - if s.version == 0 { - var err error - s.version, s.objects, err = s.Header() +// scan goes through the next stateFn. +// +// State functions are chained by returning a non-nil value for stateFn. +// In such cases, the returned stateFn will be called immediately after +// the current func. +func scan(r *Scanner) error { + var err error + for state := r.nextFn; state != nil; { + state, err = state(r) if err != nil { return err } } - - return s.discardObjectIfNeeded() + return nil } -func (s *Scanner) discardObjectIfNeeded() error { - if s.pendingObject == nil { - return nil - } +// stateFn defines each individual state within the state machine that +// represents a packfile. +type stateFn func(*Scanner) (stateFn, error) - h := s.pendingObject - n, _, err := s.NextObject(io.Discard) +// packHeaderSignature validates the packfile's header signature and +// returns [ErrBadSignature] if the value provided is invalid. +// +// This is always the first state of a packfile and starts the chain +// that handles the entire packfile header. +func packHeaderSignature(r *Scanner) (stateFn, error) { + start := make([]byte, 4) + _, err := r.Read(start) if err != nil { - return err + return nil, fmt.Errorf("%w: %w", ErrBadSignature, err) } - if n != h.Length { - return fmt.Errorf( - "error discarding object, discarded %d, expected %d", - n, h.Length, - ) + if bytes.Equal(start, signature) { + return packVersion, nil } - return nil + return nil, ErrBadSignature } -// ReadObjectTypeAndLength reads and returns the object type and the -// length field from an object entry in a packfile. -func (s *Scanner) readObjectTypeAndLength() (plumbing.ObjectType, int64, error) { - t, c, err := s.readType() +// packVersion parses the packfile version. It returns [ErrMalformedPackfile] +// when the version cannot be parsed. If a valid version is parsed, but it is +// not currently supported, it returns [ErrUnsupportedVersion] instead. +func packVersion(r *Scanner) (stateFn, error) { + version, err := binary.ReadUint32(r.scannerReader) if err != nil { - return t, 0, err + return nil, fmt.Errorf("%w: cannot read version", ErrMalformedPackfile) } - l, err := s.readLength(c) - - return t, l, err -} - -func (s *Scanner) readType() (plumbing.ObjectType, byte, error) { - var c byte - var err error - if c, err = s.r.ReadByte(); err != nil { - return plumbing.ObjectType(0), 0, err + v := Version(version) + if !v.Supported() { + return nil, ErrUnsupportedVersion } - typ := parseType(c) - - return typ, c, nil -} - -func parseType(b byte) plumbing.ObjectType { - return plumbing.ObjectType((b & maskType) >> firstLengthBits) + r.version = v + return packObjectsQty, nil } -// the length is codified in the last 4 bits of the first byte and in -// the last 7 bits of subsequent bytes. Last byte has a 0 MSB. -func (s *Scanner) readLength(first byte) (int64, error) { - length := int64(first & maskFirstLength) - - c := first - shift := firstLengthBits - var err error - for c&maskContinue > 0 { - if c, err = s.r.ReadByte(); err != nil { - return 0, err - } - - length += int64(c&maskLength) << shift - shift += lengthBits +// packObjectsQty parses the quantity of objects that the packfile contains. +// If the value cannot be parsed, [ErrMalformedPackfile] is returned. +// +// This state ends the packfile header chain. +func packObjectsQty(r *Scanner) (stateFn, error) { + qty, err := binary.ReadUint32(r.scannerReader) + if err != nil { + return nil, fmt.Errorf("%w: cannot read number of objects", ErrMalformedPackfile) + } + if qty == 0 { + return packFooter, nil } - return length, nil -} - -// NextObject writes the content of the next object into the reader, returns -// the number of bytes written, the CRC32 of the content and an error, if any -func (s *Scanner) NextObject(w io.Writer) (written int64, crc32 uint32, err error) { - s.pendingObject = nil - written, err = s.copyObject(w) - - s.r.Flush() - crc32 = s.crc.Sum32() - s.crc.Reset() + r.objects = qty + r.packData = PackData{ + Section: HeaderSection, + header: Header{Version: r.version, ObjectsQty: r.objects}, + } + r.nextFn = objectEntry - return + return nil, nil } -// ReadObject returns a reader for the object content and an error -func (s *Scanner) ReadObject() (io.ReadCloser, error) { - s.pendingObject = nil - zr, err := sync.GetZlibReader(s.r) - - if err != nil { - return nil, fmt.Errorf("zlib reset error: %s", err) +// objectEntry handles the object entries within a packfile. This is generally +// split between object headers and their contents. +// +// The object header contains the object type and size. If the type cannot be parsed, +// [ErrMalformedPackfile] is returned. +// +// When SHA256 is enabled, the scanner will also calculate the SHA256 for each object. +func objectEntry(r *Scanner) (stateFn, error) { + if r.objIndex+1 >= int(r.objects) { + return packFooter, nil } + r.objIndex++ - return ioutil.NewReadCloserWithCloser(zr.Reader, func() error { - sync.PutZlibReader(zr) - return nil - }), nil -} + offset := r.scannerReader.offset -// ReadRegularObject reads and write a non-deltified object -// from it zlib stream in an object entry in the packfile. -func (s *Scanner) copyObject(w io.Writer) (n int64, err error) { - zr, err := sync.GetZlibReader(s.r) - defer sync.PutZlibReader(zr) + r.scannerReader.Flush() + r.crc.Reset() + b := []byte{0} + _, err := r.Read(b) if err != nil { - return 0, fmt.Errorf("zlib reset error: %s", err) + return nil, err } - defer ioutil.CheckClose(zr.Reader, &err) - buf := sync.GetByteSlice() - n, err = io.CopyBuffer(w, zr.Reader, *buf) - sync.PutByteSlice(buf) - return -} - -// SeekFromStart sets a new offset from start, returns the old position before -// the change. -func (s *Scanner) SeekFromStart(offset int64) (previous int64, err error) { - // if seeking we assume that you are not interested in the header - if s.version == 0 { - s.version = VersionSupported + typ := parseType(b[0]) + if !typ.Valid() { + return nil, fmt.Errorf("%w: invalid object type: %v", ErrMalformedPackfile, b[0]) } - previous, err = s.r.Seek(0, io.SeekCurrent) + size, err := readVariableLengthSize(b[0], r) if err != nil { - return -1, err + return nil, err } - _, err = s.r.Seek(offset, io.SeekStart) - return previous, err -} + oh := ObjectHeader{ + Offset: offset, + Type: typ, + diskType: typ, + Size: int64(size), + } + + switch oh.Type { + case plumbing.OFSDeltaObject, plumbing.REFDeltaObject: + // For delta objects, we need to skip the base reference + if oh.Type == plumbing.OFSDeltaObject { + no, err := binary.ReadVariableWidthInt(r.scannerReader) + if err != nil { + return nil, err + } + oh.OffsetReference = oh.Offset - no + } else { + ref, err := binary.ReadHash(r.scannerReader) + if err != nil { + return nil, err + } + oh.Reference = ref + } + } -// Checksum returns the checksum of the packfile -func (s *Scanner) Checksum() (plumbing.Hash, error) { - err := s.discardObjectIfNeeded() + oh.ContentOffset = r.scannerReader.offset + err = r.zr.Reset(r.scannerReader) if err != nil { - return plumbing.ZeroHash, err + return nil, fmt.Errorf("zlib reset error: %s", err) } - return binary.ReadHash(s.r) -} + if !oh.Type.IsDelta() { + r.hasher.Reset(oh.Type, oh.Size) -// Close reads the reader until io.EOF -func (s *Scanner) Close() error { - buf := sync.GetByteSlice() - _, err := io.CopyBuffer(io.Discard, s.r, *buf) - sync.PutByteSlice(buf) + var mw io.Writer = r.hasher + if r.storage != nil { + w, err := r.storage.RawObjectWriter(oh.Type, oh.Size) + if err != nil { + return nil, err + } - return err -} + defer w.Close() + mw = io.MultiWriter(r.hasher, w) + } -// Flush is a no-op (deprecated) -func (s *Scanner) Flush() error { - return nil -} + if r.hasher256 != nil { + r.hasher256.Reset(oh.Type, oh.Size) + mw = io.MultiWriter(mw, r.hasher256) + } -// scannerReader has the following characteristics: -// - Provides an io.SeekReader impl for bufio.Reader, when the underlying -// reader supports it. -// - Keeps track of the current read position, for when the underlying reader -// isn't an io.SeekReader, but we still want to know the current offset. -// - Writes to the hash writer what it reads, with the aid of a smaller buffer. -// The buffer helps avoid a performance penalty for performing small writes -// to the crc32 hash writer. -type scannerReader struct { - reader io.Reader - crc io.Writer - rbuf *bufio.Reader - wbuf *bufio.Writer - offset int64 -} + // For non delta objects, simply calculate the hash of each object. + _, err = io.CopyBuffer(mw, r.zr.Reader, r.buf.Bytes()) + if err != nil { + return nil, err + } -func newScannerReader(r io.Reader, h io.Writer) *scannerReader { - sr := &scannerReader{ - rbuf: bufio.NewReader(nil), - wbuf: bufio.NewWriterSize(nil, 64), - crc: h, + oh.Hash = r.hasher.Sum() + if r.hasher256 != nil { + h := r.hasher256.Sum() + oh.Hash256 = &h + } + } else { + // If data source is not io.Seeker, keep the content + // in the cache, so that it can be accessed by the Parser. + if r.scannerReader.seeker == nil { + _, err = oh.content.ReadFrom(r.zr.Reader) + if err != nil { + return nil, err + } + } else { + // We don't know the compressed length, so we can't seek to + // the next object, we must discard the data instead. + _, err = io.Copy(io.Discard, r.zr.Reader) + if err != nil { + return nil, err + } + } } - sr.Reset(r) + r.scannerReader.Flush() + oh.Crc32 = r.crc.Sum32() - return sr -} + r.packData.Section = ObjectSection + r.packData.objectHeader = oh -func (r *scannerReader) Reset(reader io.Reader) { - r.reader = reader - r.rbuf.Reset(r.reader) - r.wbuf.Reset(r.crc) - - r.offset = 0 - if seeker, ok := r.reader.(io.ReadSeeker); ok { - r.offset, _ = seeker.Seek(0, io.SeekCurrent) - } + return nil, nil } -func (r *scannerReader) Read(p []byte) (n int, err error) { - n, err = r.rbuf.Read(p) +// packFooter parses the packfile checksum. +// If the checksum cannot be parsed, or it does not match the checksum +// calculated during the scanning process, an [ErrMalformedPackfile] is +// returned. +func packFooter(r *Scanner) (stateFn, error) { + r.scannerReader.Flush() + actual := r.packhash.Sum(nil) - r.offset += int64(n) - if _, err := r.wbuf.Write(p[:n]); err != nil { - return n, err + checksum, err := binary.ReadHash(r.scannerReader) + if err != nil { + return nil, fmt.Errorf("cannot read PACK checksum: %w", ErrMalformedPackfile) } - return -} -func (r *scannerReader) ReadByte() (b byte, err error) { - b, err = r.rbuf.ReadByte() - if err == nil { - r.offset++ - return b, r.wbuf.WriteByte(b) + if !bytes.Equal(actual, checksum[:]) { + return nil, fmt.Errorf("checksum mismatch expected %q but found %q: %w", + hex.EncodeToString(actual), checksum, ErrMalformedPackfile) } - return -} -func (r *scannerReader) Flush() error { - return r.wbuf.Flush() + r.packData.Section = FooterSection + r.packData.checksum = checksum + r.nextFn = nil + + return nil, nil } -// Seek seeks to a location. If the underlying reader is not an io.ReadSeeker, -// then only whence=io.SeekCurrent is supported, any other operation fails. -func (r *scannerReader) Seek(offset int64, whence int) (int64, error) { - var err error +func readVariableLengthSize(first byte, reader io.ByteReader) (uint64, error) { + // Extract the first part of the size (last 3 bits of the first byte). + size := uint64(first & 0x0F) - if seeker, ok := r.reader.(io.ReadSeeker); !ok { - if whence != io.SeekCurrent || offset != 0 { - return -1, ErrSeekNotSupported - } - } else { - if whence == io.SeekCurrent && offset == 0 { - return r.offset, nil - } + // | 001xxxx | xxxxxxxx | xxxxxxxx | ... + // + // ^^^ ^^^^^^^^ ^^^^^^^^ + // Type Size Part 1 Size Part 2 + // + // Check if more bytes are needed to fully determine the size. + if first&maskContinue != 0 { + shift := uint(4) - r.offset, err = seeker.Seek(offset, whence) - r.rbuf.Reset(r.reader) + for { + b, err := reader.ReadByte() + if err != nil { + return 0, err + } + + // Add the next 7 bits to the size. + size |= uint64(b&0x7F) << shift + + // Check if the continuation bit is set. + if b&maskContinue == 0 { + break + } + + // Prepare for the next byte. + shift += 7 + } } + return size, nil +} - return r.offset, err +func parseType(b byte) plumbing.ObjectType { + return plumbing.ObjectType((b & maskType) >> firstLengthBits) } diff --git a/plumbing/format/packfile/scanner_options.go b/plumbing/format/packfile/scanner_options.go new file mode 100644 index 000000000..e6fcbea2d --- /dev/null +++ b/plumbing/format/packfile/scanner_options.go @@ -0,0 +1,13 @@ +package packfile + +import "github.com/jesseduffield/go-git/v5/plumbing" + +type ScannerOption func(*Scanner) + +// WithSHA256 enables the SHA256 hashing while scanning a pack file. +func WithSHA256() ScannerOption { + return func(s *Scanner) { + h := plumbing.NewHasher256(plumbing.AnyObject, 0) + s.hasher256 = &h + } +} diff --git a/plumbing/format/packfile/scanner_reader.go b/plumbing/format/packfile/scanner_reader.go new file mode 100644 index 000000000..2e78f91f1 --- /dev/null +++ b/plumbing/format/packfile/scanner_reader.go @@ -0,0 +1,99 @@ +package packfile + +import ( + "bufio" + "io" +) + +// scannerReader has the following characteristics: +// - Provides an io.SeekReader impl for bufio.Reader, when the underlying +// reader supports it. +// - Keeps track of the current read position, for when the underlying reader +// isn't an io.SeekReader, but we still want to know the current offset. +// - Writes to the hash writer what it reads, with the aid of a smaller buffer. +// The buffer helps avoid a performance penalty for performing small writes +// to the crc32 hash writer. +// +// Note that this is passed on to zlib, and it mmust support io.BytesReader, else +// it won't be able to just read the content of the current object, but rather it +// will read the entire packfile. +// +// scannerReader is not thread-safe. +type scannerReader struct { + reader io.Reader + crc io.Writer + rbuf *bufio.Reader + wbuf *bufio.Writer + offset int64 + seeker io.Seeker +} + +func newScannerReader(r io.Reader, h io.Writer) *scannerReader { + sr := &scannerReader{ + rbuf: bufio.NewReader(nil), + wbuf: bufio.NewWriterSize(nil, 64), + crc: h, + } + sr.Reset(r) + + return sr +} + +func (r *scannerReader) Reset(reader io.Reader) { + r.reader = reader + r.rbuf.Reset(r.reader) + r.wbuf.Reset(r.crc) + + r.offset = 0 + + seeker, ok := r.reader.(io.ReadSeeker) + r.seeker = seeker + + if ok { + r.offset, _ = seeker.Seek(0, io.SeekCurrent) + } +} + +func (r *scannerReader) Read(p []byte) (n int, err error) { + n, err = r.rbuf.Read(p) + + r.offset += int64(n) + if _, err := r.wbuf.Write(p[:n]); err != nil { + return n, err + } + return +} + +func (r *scannerReader) ReadByte() (b byte, err error) { + b, err = r.rbuf.ReadByte() + if err == nil { + r.offset++ + return b, r.wbuf.WriteByte(b) + } + return +} + +func (r *scannerReader) Flush() error { + return r.wbuf.Flush() +} + +// Seek seeks to a location. If the underlying reader is not an io.ReadSeeker, +// then only whence=io.SeekCurrent is supported, any other operation fails. +func (r *scannerReader) Seek(offset int64, whence int) (int64, error) { + var err error + + if r.seeker == nil { + if whence != io.SeekCurrent || offset != 0 { + return -1, ErrSeekNotSupported + } + } + + if whence == io.SeekCurrent && offset == 0 { + return r.offset, nil + } + + r.offset, err = r.seeker.Seek(offset, whence) + r.rbuf.Reset(r.reader) + + return r.offset, err +} diff --git a/plumbing/format/packfile/scanner_test.go b/plumbing/format/packfile/scanner_test.go index 9dcc3594d..9ca0e5227 100644 --- a/plumbing/format/packfile/scanner_test.go +++ b/plumbing/format/packfile/scanner_test.go @@ -2,222 +2,402 @@ package packfile import ( "bytes" + "encoding/binary" "io" - - fixtures "github.com/go-git/go-git-fixtures/v4" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/hash" - - . "gopkg.in/check.v1" + "reflect" + "runtime" + "testing" + + "github.com/go-git/go-billy/v5" + fixtures "github.com/go-git/go-git-fixtures/v5" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/stretchr/testify/assert" ) -type ScannerSuite struct { - fixtures.Suite -} - -var _ = Suite(&ScannerSuite{}) - -func (s *ScannerSuite) TestHeader(c *C) { - r := fixtures.Basic().One().Packfile() - p := NewScanner(r) - - version, objects, err := p.Header() - c.Assert(err, IsNil) - c.Assert(version, Equals, VersionSupported) - c.Assert(objects, Equals, uint32(31)) -} - -func (s *ScannerSuite) TestNextObjectHeaderWithoutHeader(c *C) { - r := fixtures.Basic().One().Packfile() - p := NewScanner(r) - - h, err := p.NextObjectHeader() - c.Assert(err, IsNil) - c.Assert(h, DeepEquals, &expectedHeadersOFS[0]) - - version, objects, err := p.Header() - c.Assert(err, IsNil) - c.Assert(version, Equals, VersionSupported) - c.Assert(objects, Equals, uint32(31)) -} - -func (s *ScannerSuite) TestNextObjectHeaderREFDelta(c *C) { - s.testNextObjectHeader(c, "ref-delta", expectedHeadersREF, expectedCRCREF) -} - -func (s *ScannerSuite) TestNextObjectHeaderOFSDelta(c *C) { - s.testNextObjectHeader(c, "ofs-delta", expectedHeadersOFS, expectedCRCOFS) -} - -func (s *ScannerSuite) testNextObjectHeader(c *C, tag string, - expected []ObjectHeader, expectedCRC []uint32) { - - r := fixtures.Basic().ByTag(tag).One().Packfile() - p := NewScanner(r) - - _, objects, err := p.Header() - c.Assert(err, IsNil) - - for i := 0; i < int(objects); i++ { - h, err := p.NextObjectHeader() - c.Assert(err, IsNil) - c.Assert(*h, DeepEquals, expected[i]) - - buf := bytes.NewBuffer(nil) - n, crcFromScanner, err := p.NextObject(buf) - c.Assert(err, IsNil) - c.Assert(n, Equals, h.Length) - c.Assert(crcFromScanner, Equals, expectedCRC[i]) +func TestScan(t *testing.T) { + tests := []struct { + name string + packfile billy.File + sha256 bool + want []ObjectHeader + wantCrc []uint32 + wantChecksum string + }{ + { + name: "ofs", + packfile: fixtures.Basic().One().Packfile(), + want: expectedHeadersOFS256, + wantCrc: expectedCRCOFS, + wantChecksum: "a3fed42da1e8189a077c0e6846c040dcf73fc9dd", + }, + { + name: "ofs sha256", + packfile: fixtures.Basic().One().Packfile(), + sha256: true, + want: expectedHeadersOFS256, + wantCrc: expectedCRCOFS, + wantChecksum: "a3fed42da1e8189a077c0e6846c040dcf73fc9dd", + }, + { + name: "refs", + packfile: fixtures.Basic().ByTag("ref-delta").One().Packfile(), + want: expectedHeadersREF, + wantCrc: expectedCRCREF, + wantChecksum: "c544593473465e6315ad4182d04d366c4592b829", + }, } - n, err := p.Checksum() - c.Assert(err, IsNil) - c.Assert(n, HasLen, hash.Size) -} - -func (s *ScannerSuite) TestNextObjectHeaderWithOutReadObject(c *C) { - f := fixtures.Basic().ByTag("ref-delta").One() - r := f.Packfile() - p := NewScanner(r) - - _, objects, err := p.Header() - c.Assert(err, IsNil) - - for i := 0; i < int(objects); i++ { - h, _ := p.NextObjectHeader() - c.Assert(err, IsNil) - c.Assert(*h, DeepEquals, expectedHeadersREF[i]) + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + var opts []ScannerOption + + if tc.sha256 { + opts = append(opts, WithSHA256()) + } + + s := NewScanner(tc.packfile, opts...) + i := 0 + + for s.Scan() { + data := s.Data() + v := data.Value() + + switch data.Section { + case HeaderSection: + gotHeader := v.(Header) + assert.Equal(t, 0, i, "wrong index") + assert.Equal(t, Version(2), gotHeader.Version) + assert.Equal(t, uint32(len(tc.want)), gotHeader.ObjectsQty) + case ObjectSection: + index := i - 1 + + oh := v.(ObjectHeader) + oo := tc.want[index] + assert.Equal(t, oo.Type, oh.Type, "type mismatch index: %d", index) + assert.Equal(t, oo.Offset, oh.Offset, "offset mismatch index: %d", index) + assert.Equal(t, oo.Size, oh.Size, "size mismatch index: %d", index) + assert.Equal(t, oo.Reference, oh.Reference, "reference mismatch index: %d", index) + assert.Equal(t, oo.OffsetReference, oh.OffsetReference, "offset reference mismatch index: %d", index) + assert.Equal(t, oo.Hash.String(), oh.Hash.String(), "hash mismatch index: %d", index) + if tc.sha256 && !oo.Type.IsDelta() { + assert.Equal(t, oo.Hash256.String(), oh.Hash256.String(), "hash mismatch index: %d", index) + } + assert.Equal(t, tc.wantCrc[index], oh.Crc32, "crc mismatch index: %d", index) + case FooterSection: + checksum := v.(plumbing.Hash) + assert.Equal(t, tc.wantChecksum, checksum.String()) + } + i++ + } + + err := s.Error() + assert.NoError(t, err) + + // wanted objects + header + footer + assert.Equal(t, len(tc.want)+2, i) + }) } - - err = p.discardObjectIfNeeded() - c.Assert(err, IsNil) - - n, err := p.Checksum() - c.Assert(err, IsNil) - c.Assert(n.String(), Equals, f.PackfileHash) } -func (s *ScannerSuite) TestNextObjectHeaderWithOutReadObjectNonSeekable(c *C) { - f := fixtures.Basic().ByTag("ref-delta").One() - r := io.MultiReader(f.Packfile()) - p := NewScanner(r) +func BenchmarkScannerBasic(b *testing.B) { + f := fixtures.Basic().One().Packfile() + scanner := NewScanner(f) + for i := 0; i < b.N; i++ { + scanner.Reset() - _, objects, err := p.Header() - c.Assert(err, IsNil) + for scanner.Scan() { + } - for i := 0; i < int(objects); i++ { - h, _ := p.NextObjectHeader() - c.Assert(err, IsNil) - c.Assert(*h, DeepEquals, expectedHeadersREF[i]) + err := scanner.Error() + if err != nil { + b.Fatal(err) + } } - - err = p.discardObjectIfNeeded() - c.Assert(err, IsNil) - - n, err := p.Checksum() - c.Assert(err, IsNil) - c.Assert(n.String(), Equals, f.PackfileHash) } -func (s *ScannerSuite) TestSeekObjectHeader(c *C) { - r := fixtures.Basic().One().Packfile() - p := NewScanner(r) +func TestPackHeaderSignature(t *testing.T) { + tests := []struct { + name string + scanner *Scanner + nextState stateFn + wantErr error + }{ + { + name: "valid signature", + scanner: &Scanner{ + scannerReader: newScannerReader(bytes.NewReader([]byte("PACK")), nil), + }, + nextState: packVersion, + }, + { + name: "invalid signature", + scanner: &Scanner{ + scannerReader: newScannerReader(bytes.NewReader([]byte("FOOBAR")), nil), + }, + wantErr: ErrBadSignature, + }, + { + name: "invalid signature - too small", + scanner: &Scanner{ + scannerReader: newScannerReader(bytes.NewReader([]byte("FOO")), nil), + }, + wantErr: ErrBadSignature, + }, + { + name: "empty packfile: io.EOF", + scanner: &Scanner{ + scannerReader: newScannerReader(bytes.NewReader(nil), nil), + }, + wantErr: io.EOF, + }, + { + name: "empty packfile: ErrBadSignature", + scanner: &Scanner{ + scannerReader: newScannerReader(bytes.NewReader(nil), nil), + }, + wantErr: ErrBadSignature, + }, + } - h, err := p.SeekObjectHeader(expectedHeadersOFS[4].Offset) - c.Assert(err, IsNil) - c.Assert(h, DeepEquals, &expectedHeadersOFS[4]) + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + next, err := packHeaderSignature(tc.scanner) + + if tc.wantErr == nil { + assert.Equal(t, + runtime.FuncForPC(reflect.ValueOf(tc.nextState).Pointer()).Name(), + runtime.FuncForPC(reflect.ValueOf(next).Pointer()).Name()) + + assert.NoError(t, err) + } else { + assert.Nil(t, next) + assert.ErrorIs(t, err, tc.wantErr) + } + }) + } } -func (s *ScannerSuite) TestSeekObjectHeaderNonSeekable(c *C) { - r := io.MultiReader(fixtures.Basic().One().Packfile()) - p := NewScanner(r) +func TestPackVersion(t *testing.T) { + tests := []struct { + name string + scanner *Scanner + version Version + nextState stateFn + wantErr error + }{ + { + name: "Version 2", + version: Version(2), + scanner: &Scanner{ + scannerReader: func() *scannerReader { + buf := bytes.NewBuffer(make([]byte, 0, 4)) + binary.Write(buf, binary.BigEndian, uint32(2)) + return newScannerReader(buf, nil) + }(), + }, + nextState: packObjectsQty, + }, + { + name: "Version -1", + scanner: &Scanner{ + scannerReader: func() *scannerReader { + buf := bytes.NewBuffer(make([]byte, 0, 4)) + binary.Write(buf, binary.BigEndian, -1) + return newScannerReader(buf, nil) + }(), + }, + wantErr: ErrMalformedPackfile, + }, + { + name: "Unsupported version", + scanner: &Scanner{ + scannerReader: func() *scannerReader { + buf := bytes.NewBuffer(make([]byte, 0, 4)) + binary.Write(buf, binary.BigEndian, uint32(3)) + return newScannerReader(buf, nil) + }(), + }, + wantErr: ErrUnsupportedVersion, + }, + { + name: "empty packfile: ErrMalformedPackfile", + scanner: &Scanner{ + scannerReader: newScannerReader(bytes.NewReader(nil), nil), + }, + wantErr: ErrMalformedPackfile, + }, + } - _, err := p.SeekObjectHeader(expectedHeadersOFS[4].Offset) - c.Assert(err, Equals, ErrSeekNotSupported) + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + next, err := packVersion(tc.scanner) + + if tc.wantErr == nil { + assert.Equal(t, + runtime.FuncForPC(reflect.ValueOf(tc.nextState).Pointer()).Name(), + runtime.FuncForPC(reflect.ValueOf(next).Pointer()).Name()) + + assert.Equal(t, tc.version, tc.scanner.version) + assert.NoError(t, err) + } else { + assert.Nil(t, next) + assert.ErrorIs(t, err, tc.wantErr) + } + }) + } } -func (s *ScannerSuite) TestReaderReset(c *C) { - r := fixtures.Basic().One().Packfile() - p := NewScanner(r) - - version, objects, err := p.Header() - c.Assert(err, IsNil) - c.Assert(version, Equals, VersionSupported) - c.Assert(objects, Equals, uint32(31)) - - h, err := p.SeekObjectHeader(expectedHeadersOFS[0].Offset) - c.Assert(err, IsNil) - c.Assert(h, DeepEquals, &expectedHeadersOFS[0]) - - p.Reset(r) - c.Assert(p.pendingObject, IsNil) - c.Assert(p.version, Equals, uint32(0)) - c.Assert(p.objects, Equals, uint32(0)) - c.Assert(p.r.reader, Equals, r) - c.Assert(p.r.offset > expectedHeadersOFS[0].Offset, Equals, true) +func TestPackObjectQty(t *testing.T) { + tests := []struct { + name string + scanner *Scanner + objects uint32 + nextState stateFn + wantErr error + }{ + { + name: "Zero", + scanner: &Scanner{ + scannerReader: func() *scannerReader { + buf := bytes.NewBuffer(make([]byte, 0, 4)) + binary.Write(buf, binary.BigEndian, uint32(0)) + return newScannerReader(buf, nil) + }(), + }, + nextState: packFooter, // if there are no objects, skip to footer. + }, + { + name: "Valid number", + scanner: &Scanner{ + scannerReader: func() *scannerReader { + buf := bytes.NewBuffer(make([]byte, 0, 4)) + binary.Write(buf, binary.BigEndian, uint32(7)) + return newScannerReader(buf, nil) + }(), + }, + objects: 7, + nextState: nil, + }, + { + name: "less than 2 bytes on source", + scanner: &Scanner{ + scannerReader: func() *scannerReader { + buf := bytes.NewBuffer(make([]byte, 0, 2)) + return newScannerReader(buf, nil) + }(), + }, + wantErr: ErrMalformedPackfile, + }, + { + name: "empty packfile: ErrMalformedPackfile", + scanner: &Scanner{ + scannerReader: newScannerReader(bytes.NewReader(nil), nil), + }, + wantErr: ErrMalformedPackfile, + }, + } - p.Reset(bytes.NewReader(nil)) - c.Assert(p.r.offset, Equals, int64(0)) + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + next, err := packObjectsQty(tc.scanner) + + if tc.wantErr == nil { + assert.Equal(t, + runtime.FuncForPC(reflect.ValueOf(tc.nextState).Pointer()).Name(), + runtime.FuncForPC(reflect.ValueOf(next).Pointer()).Name()) + + assert.Equal(t, tc.objects, tc.scanner.objects) + assert.NoError(t, err) + } else { + assert.Nil(t, next) + assert.ErrorIs(t, err, tc.wantErr) + } + }) + } } -func (s *ScannerSuite) TestReaderResetSeeks(c *C) { - r := fixtures.Basic().One().Packfile() - - // seekable - p := NewScanner(r) - c.Assert(p.IsSeekable, Equals, true) - h, err := p.SeekObjectHeader(expectedHeadersOFS[0].Offset) - c.Assert(err, IsNil) - c.Assert(h, DeepEquals, &expectedHeadersOFS[0]) - - // reset with seekable - p.Reset(r) - c.Assert(p.IsSeekable, Equals, true) - h, err = p.SeekObjectHeader(expectedHeadersOFS[1].Offset) - c.Assert(err, IsNil) - c.Assert(h, DeepEquals, &expectedHeadersOFS[1]) - - // reset with non-seekable - f := fixtures.Basic().ByTag("ref-delta").One() - p.Reset(io.MultiReader(f.Packfile())) - c.Assert(p.IsSeekable, Equals, false) - - _, err = p.SeekObjectHeader(expectedHeadersOFS[4].Offset) - c.Assert(err, Equals, ErrSeekNotSupported) +func ptr[T any](value T) *T { + return &value } -var expectedHeadersOFS = []ObjectHeader{ - {Type: plumbing.CommitObject, Offset: 12, Length: 254}, - {Type: plumbing.OFSDeltaObject, Offset: 186, Length: 93, OffsetReference: 12}, - {Type: plumbing.CommitObject, Offset: 286, Length: 242}, - {Type: plumbing.CommitObject, Offset: 449, Length: 242}, - {Type: plumbing.CommitObject, Offset: 615, Length: 333}, - {Type: plumbing.CommitObject, Offset: 838, Length: 332}, - {Type: plumbing.CommitObject, Offset: 1063, Length: 244}, - {Type: plumbing.CommitObject, Offset: 1230, Length: 243}, - {Type: plumbing.CommitObject, Offset: 1392, Length: 187}, - {Type: plumbing.BlobObject, Offset: 1524, Length: 189}, - {Type: plumbing.BlobObject, Offset: 1685, Length: 18}, - {Type: plumbing.BlobObject, Offset: 1713, Length: 1072}, - {Type: plumbing.BlobObject, Offset: 2351, Length: 76110}, - {Type: plumbing.BlobObject, Offset: 78050, Length: 2780}, - {Type: plumbing.BlobObject, Offset: 78882, Length: 217848}, - {Type: plumbing.BlobObject, Offset: 80725, Length: 706}, - {Type: plumbing.BlobObject, Offset: 80998, Length: 11488}, - {Type: plumbing.BlobObject, Offset: 84032, Length: 78}, - {Type: plumbing.TreeObject, Offset: 84115, Length: 272}, - {Type: plumbing.OFSDeltaObject, Offset: 84375, Length: 43, OffsetReference: 84115}, - {Type: plumbing.TreeObject, Offset: 84430, Length: 38}, - {Type: plumbing.TreeObject, Offset: 84479, Length: 75}, - {Type: plumbing.TreeObject, Offset: 84559, Length: 38}, - {Type: plumbing.TreeObject, Offset: 84608, Length: 34}, - {Type: plumbing.BlobObject, Offset: 84653, Length: 9}, - {Type: plumbing.OFSDeltaObject, Offset: 84671, Length: 6, OffsetReference: 84375}, - {Type: plumbing.OFSDeltaObject, Offset: 84688, Length: 9, OffsetReference: 84375}, - {Type: plumbing.OFSDeltaObject, Offset: 84708, Length: 6, OffsetReference: 84375}, - {Type: plumbing.OFSDeltaObject, Offset: 84725, Length: 5, OffsetReference: 84115}, - {Type: plumbing.OFSDeltaObject, Offset: 84741, Length: 8, OffsetReference: 84375}, - {Type: plumbing.OFSDeltaObject, Offset: 84760, Length: 4, OffsetReference: 84741}, +var expectedHeadersOFS256 = []ObjectHeader{ + {Type: plumbing.CommitObject, Offset: 12, Size: 254, + Hash: plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881"), + Hash256: ptr(plumbing.NewHash256("751ee7d8e2736460ea9b6f1b88aeb050dad7d7641b0313d27f0bb9bedd1b3726"))}, + {Type: plumbing.OFSDeltaObject, Offset: 186, Size: 93, OffsetReference: 12}, + {Type: plumbing.CommitObject, Offset: 286, Size: 242, + Hash: plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"), + Hash256: ptr(plumbing.NewHash256("a279e860c7074462629fefb6a96e77eecb240eba291791c163581f6afeaa7f12"))}, + {Type: plumbing.CommitObject, Offset: 449, Size: 242, + Hash: plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"), + Hash256: ptr(plumbing.NewHash256("aa68eba21ad1796f88c16e470e0374bf6ed1376495ab3a367cd85698c3df766f"))}, + {Type: plumbing.CommitObject, Offset: 615, Size: 333, + Hash: plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea"), + Hash256: ptr(plumbing.NewHash256("4d00acb62a3ecb5f3f6871aa29c8ea670fc3d27042842277280c6b3e48a206f1"))}, + {Type: plumbing.CommitObject, Offset: 838, Size: 332, + Hash: plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69"), + Hash256: ptr(plumbing.NewHash256("627852504dc677ba7ac2ec7717d69b42f787c8d79bac9fe1370b8775d2312e94"))}, + {Type: plumbing.CommitObject, Offset: 1063, Size: 244, + Hash: plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"), + Hash256: ptr(plumbing.NewHash256("00f0a27f127cffbb2a1089b772edd3ba7c82a6b69d666048b75d4bdcee24515d"))}, + {Type: plumbing.CommitObject, Offset: 1230, Size: 243, + Hash: plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"), + Hash256: ptr(plumbing.NewHash256("ef5441299e83e8707722706fefd89e77290a2a6e84be5202b980128eaa6decc2"))}, + {Type: plumbing.CommitObject, Offset: 1392, Size: 187, + Hash: plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"), + Hash256: ptr(plumbing.NewHash256("809c0681b603794597ef162c71184b38dda79364a423c6c61d2e514a1d46efff"))}, + {Type: plumbing.BlobObject, Offset: 1524, Size: 189, + Hash: plumbing.NewHash("32858aad3c383ed1ff0a0f9bdf231d54a00c9e88"), + Hash256: ptr(plumbing.NewHash256("40b7c05726c9da78c3d5a705c2a48a120261b36f521302ce06bad41916d000f7"))}, + {Type: plumbing.BlobObject, Offset: 1685, Size: 18, + Hash: plumbing.NewHash("d3ff53e0564a9f87d8e84b6e28e5060e517008aa"), + Hash256: ptr(plumbing.NewHash256("e6ee53c7eb0e33417ee04110b84b304ff2da5c1b856f320b61ad9f2ef56c6e4e"))}, + {Type: plumbing.BlobObject, Offset: 1713, Size: 1072, + Hash: plumbing.NewHash("c192bd6a24ea1ab01d78686e417c8bdc7c3d197f"), + Hash256: ptr(plumbing.NewHash256("789c9f4220d167b66020b46bacddcad0ab5bb12f0f469576aa60bb59d98293dc"))}, + {Type: plumbing.BlobObject, Offset: 2351, Size: 76110, + Hash: plumbing.NewHash("d5c0f4ab811897cadf03aec358ae60d21f91c50d"), + Hash256: ptr(plumbing.NewHash256("665e33431d9b88280d7c1837680fdb66664c4cb4b394c9057cdbd07f3b4acff8"))}, + {Type: plumbing.BlobObject, Offset: 78050, Size: 2780, + Hash: plumbing.NewHash("880cd14280f4b9b6ed3986d6671f907d7cc2a198"), + Hash256: ptr(plumbing.NewHash256("33a5013ed4af64b6e54076c986a4733c2c11ce8ab27ede79f21366e8722ac5ed"))}, + {Type: plumbing.BlobObject, Offset: 78882, Size: 217848, + Hash: plumbing.NewHash("49c6bb89b17060d7b4deacb7b338fcc6ea2352a9"), + Hash256: ptr(plumbing.NewHash256("4c61794e77ff8c7ab7f07404cdb1bc0e989b27530e37a6be6d2ef73639aaff6d"))}, + {Type: plumbing.BlobObject, Offset: 80725, Size: 706, + Hash: plumbing.NewHash("c8f1d8c61f9da76f4cb49fd86322b6e685dba956"), + Hash256: ptr(plumbing.NewHash256("2a246d3eaea67b7c4ac36d96d1dc9dad2a4dc24486c4d67eb7cb73963f522481"))}, + {Type: plumbing.BlobObject, Offset: 80998, Size: 11488, + Hash: plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492"), + Hash256: ptr(plumbing.NewHash256("73660d98a4c6c8951f86bb8c4744a0b4837a6dd5f796c314064c1615781c400c"))}, + {Type: plumbing.BlobObject, Offset: 84032, Size: 78, + Hash: plumbing.NewHash("9dea2395f5403188298c1dabe8bdafe562c491e3"), + Hash256: ptr(plumbing.NewHash256("2a7543a59f760f7ca41784bc898057799ae960323733cab1175c21960a750f72"))}, + {Type: plumbing.TreeObject, Offset: 84115, Size: 272, + Hash: plumbing.NewHash("dbd3641b371024f44d0e469a9c8f5457b0660de1"), + Hash256: ptr(plumbing.NewHash256("773b6c73238a74067c97f193c06c1bf38a982e39ded04fdf9c833ebc34cedd3d"))}, + {Type: plumbing.OFSDeltaObject, Offset: 84375, Size: 43, OffsetReference: 84115}, + {Type: plumbing.TreeObject, Offset: 84430, Size: 38, + Hash: plumbing.NewHash("a39771a7651f97faf5c72e08224d857fc35133db"), + Hash256: ptr(plumbing.NewHash256("166e4d7c5b5771422259dda0819ea54e06a6e4f07cf927d9fc95f5c370fff28a"))}, + {Type: plumbing.TreeObject, Offset: 84479, Size: 75, + Hash: plumbing.NewHash("5a877e6a906a2743ad6e45d99c1793642aaf8eda"), + Hash256: ptr(plumbing.NewHash256("393e771684c98451b904457acffac4ca5bd5a736a1b9127cedf7b8fa1b6a9901"))}, + {Type: plumbing.TreeObject, Offset: 84559, Size: 38, + Hash: plumbing.NewHash("586af567d0bb5e771e49bdd9434f5e0fb76d25fa"), + Hash256: ptr(plumbing.NewHash256("3db5b7f8353ebe6e4d4bff0bd2953952e08d73e72040abe4a46d08e7c3593dcc"))}, + {Type: plumbing.TreeObject, Offset: 84608, Size: 34, + Hash: plumbing.NewHash("cf4aa3b38974fb7d81f367c0830f7d78d65ab86b"), + Hash256: ptr(plumbing.NewHash256("e39c8c3d47aa310861634c6cf44e54e847c02f99c34c8cb25246e16f40502a7e"))}, + {Type: plumbing.BlobObject, Offset: 84653, Size: 9, + Hash: plumbing.NewHash("7e59600739c96546163833214c36459e324bad0a"), + Hash256: ptr(plumbing.NewHash256("1f307724f91af43be1570b77aeef69c5010e8136e50bef83c28de2918a08f494"))}, + {Type: plumbing.OFSDeltaObject, Offset: 84671, Size: 6, OffsetReference: 84375}, + {Type: plumbing.OFSDeltaObject, Offset: 84688, Size: 9, OffsetReference: 84375}, + {Type: plumbing.OFSDeltaObject, Offset: 84708, Size: 6, OffsetReference: 84375}, + {Type: plumbing.OFSDeltaObject, Offset: 84725, Size: 5, OffsetReference: 84115}, + {Type: plumbing.OFSDeltaObject, Offset: 84741, Size: 8, OffsetReference: 84375}, + {Type: plumbing.OFSDeltaObject, Offset: 84760, Size: 4, OffsetReference: 84741}, } var expectedCRCOFS = []uint32{ @@ -255,43 +435,43 @@ var expectedCRCOFS = []uint32{ } var expectedHeadersREF = []ObjectHeader{ - {Type: plumbing.CommitObject, Offset: 12, Length: 254}, - {Type: plumbing.REFDeltaObject, Offset: 186, Length: 93, + {Type: plumbing.CommitObject, Offset: 12, Size: 254, Hash: plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881")}, + {Type: plumbing.REFDeltaObject, Offset: 186, Size: 93, Reference: plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881")}, - {Type: plumbing.CommitObject, Offset: 304, Length: 242}, - {Type: plumbing.CommitObject, Offset: 467, Length: 242}, - {Type: plumbing.CommitObject, Offset: 633, Length: 333}, - {Type: plumbing.CommitObject, Offset: 856, Length: 332}, - {Type: plumbing.CommitObject, Offset: 1081, Length: 243}, - {Type: plumbing.CommitObject, Offset: 1243, Length: 244}, - {Type: plumbing.CommitObject, Offset: 1410, Length: 187}, - {Type: plumbing.BlobObject, Offset: 1542, Length: 189}, - {Type: plumbing.BlobObject, Offset: 1703, Length: 18}, - {Type: plumbing.BlobObject, Offset: 1731, Length: 1072}, - {Type: plumbing.BlobObject, Offset: 2369, Length: 76110}, - {Type: plumbing.TreeObject, Offset: 78068, Length: 38}, - {Type: plumbing.BlobObject, Offset: 78117, Length: 2780}, - {Type: plumbing.TreeObject, Offset: 79049, Length: 75}, - {Type: plumbing.BlobObject, Offset: 79129, Length: 217848}, - {Type: plumbing.BlobObject, Offset: 80972, Length: 706}, - {Type: plumbing.TreeObject, Offset: 81265, Length: 38}, - {Type: plumbing.BlobObject, Offset: 81314, Length: 11488}, - {Type: plumbing.TreeObject, Offset: 84752, Length: 34}, - {Type: plumbing.BlobObject, Offset: 84797, Length: 78}, - {Type: plumbing.TreeObject, Offset: 84880, Length: 271}, - {Type: plumbing.REFDeltaObject, Offset: 85141, Length: 6, + {Type: plumbing.CommitObject, Offset: 304, Size: 242, Hash: plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294")}, + {Type: plumbing.CommitObject, Offset: 467, Size: 242, Hash: plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a")}, + {Type: plumbing.CommitObject, Offset: 633, Size: 333, Hash: plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea")}, + {Type: plumbing.CommitObject, Offset: 856, Size: 332, Hash: plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69")}, + {Type: plumbing.CommitObject, Offset: 1081, Size: 243, Hash: plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47")}, + {Type: plumbing.CommitObject, Offset: 1243, Size: 244, Hash: plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9")}, + {Type: plumbing.CommitObject, Offset: 1410, Size: 187, Hash: plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d")}, + {Type: plumbing.BlobObject, Offset: 1542, Size: 189, Hash: plumbing.NewHash("32858aad3c383ed1ff0a0f9bdf231d54a00c9e88")}, + {Type: plumbing.BlobObject, Offset: 1703, Size: 18, Hash: plumbing.NewHash("d3ff53e0564a9f87d8e84b6e28e5060e517008aa")}, + {Type: plumbing.BlobObject, Offset: 1731, Size: 1072, Hash: plumbing.NewHash("c192bd6a24ea1ab01d78686e417c8bdc7c3d197f")}, + {Type: plumbing.BlobObject, Offset: 2369, Size: 76110, Hash: plumbing.NewHash("d5c0f4ab811897cadf03aec358ae60d21f91c50d")}, + {Type: plumbing.TreeObject, Offset: 78068, Size: 38, Hash: plumbing.NewHash("a39771a7651f97faf5c72e08224d857fc35133db")}, + {Type: plumbing.BlobObject, Offset: 78117, Size: 2780, Hash: plumbing.NewHash("880cd14280f4b9b6ed3986d6671f907d7cc2a198")}, + {Type: plumbing.TreeObject, Offset: 79049, Size: 75, Hash: plumbing.NewHash("5a877e6a906a2743ad6e45d99c1793642aaf8eda")}, + {Type: plumbing.BlobObject, Offset: 79129, Size: 217848, Hash: plumbing.NewHash("49c6bb89b17060d7b4deacb7b338fcc6ea2352a9")}, + {Type: plumbing.BlobObject, Offset: 80972, Size: 706, Hash: plumbing.NewHash("c8f1d8c61f9da76f4cb49fd86322b6e685dba956")}, + {Type: plumbing.TreeObject, Offset: 81265, Size: 38, Hash: plumbing.NewHash("586af567d0bb5e771e49bdd9434f5e0fb76d25fa")}, + {Type: plumbing.BlobObject, Offset: 81314, Size: 11488, Hash: plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492")}, + {Type: plumbing.TreeObject, Offset: 84752, Size: 34, Hash: plumbing.NewHash("cf4aa3b38974fb7d81f367c0830f7d78d65ab86b")}, + {Type: plumbing.BlobObject, Offset: 84797, Size: 78, Hash: plumbing.NewHash("9dea2395f5403188298c1dabe8bdafe562c491e3")}, + {Type: plumbing.TreeObject, Offset: 84880, Size: 271, Hash: plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")}, + {Type: plumbing.REFDeltaObject, Offset: 85141, Size: 6, Reference: plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")}, - {Type: plumbing.REFDeltaObject, Offset: 85176, Length: 37, + {Type: plumbing.REFDeltaObject, Offset: 85176, Size: 37, Reference: plumbing.NewHash("fb72698cab7617ac416264415f13224dfd7a165e")}, - {Type: plumbing.BlobObject, Offset: 85244, Length: 9}, - {Type: plumbing.REFDeltaObject, Offset: 85262, Length: 9, + {Type: plumbing.BlobObject, Offset: 85244, Size: 9, Hash: plumbing.NewHash("7e59600739c96546163833214c36459e324bad0a")}, + {Type: plumbing.REFDeltaObject, Offset: 85262, Size: 9, Reference: plumbing.NewHash("fb72698cab7617ac416264415f13224dfd7a165e")}, - {Type: plumbing.REFDeltaObject, Offset: 85300, Length: 6, + {Type: plumbing.REFDeltaObject, Offset: 85300, Size: 6, Reference: plumbing.NewHash("fb72698cab7617ac416264415f13224dfd7a165e")}, - {Type: plumbing.TreeObject, Offset: 85335, Length: 110}, - {Type: plumbing.REFDeltaObject, Offset: 85448, Length: 8, + {Type: plumbing.TreeObject, Offset: 85335, Size: 110, Hash: plumbing.NewHash("c2d30fa8ef288618f65f6eed6e168e0d514886f4")}, + {Type: plumbing.REFDeltaObject, Offset: 85448, Size: 8, Reference: plumbing.NewHash("eba74343e2f15d62adedfd8c883ee0262b5c8021")}, - {Type: plumbing.TreeObject, Offset: 85485, Length: 73}, + {Type: plumbing.TreeObject, Offset: 85485, Size: 73, Hash: plumbing.NewHash("aa9b383c260e1d05fbbf6b30a02914555e20c725")}, } var expectedCRCREF = []uint32{ diff --git a/plumbing/format/packfile/types.go b/plumbing/format/packfile/types.go new file mode 100644 index 000000000..c9286a2b8 --- /dev/null +++ b/plumbing/format/packfile/types.go @@ -0,0 +1,74 @@ +package packfile + +import ( + "bytes" + + "github.com/jesseduffield/go-git/v5/plumbing" +) + +type Version uint32 + +const ( + V2 Version = 2 +) + +func (v Version) Supported() bool { + switch v { + case V2: + return true + default: + return false + } +} + +// ObjectHeader contains the information related to the object, this information +// is collected from the previous bytes to the content of the object. +type ObjectHeader struct { + Type plumbing.ObjectType + Offset int64 + ContentOffset int64 + Size int64 + Reference plumbing.Hash + OffsetReference int64 + Crc32 uint32 + Hash plumbing.Hash + Hash256 *plumbing.Hash256 + + content bytes.Buffer + parent *ObjectHeader + diskType plumbing.ObjectType + externalRef bool +} + +type SectionType int + +const ( + HeaderSection SectionType = iota + ObjectSection + FooterSection +) + +type Header struct { + Version Version + ObjectsQty uint32 +} + +type PackData struct { + Section SectionType + header Header + objectHeader ObjectHeader + checksum plumbing.Hash +} + +func (p PackData) Value() interface{} { + switch p.Section { + case HeaderSection: + return p.header + case ObjectSection: + return p.objectHeader + case FooterSection: + return p.checksum + default: + return nil + } +} diff --git a/plumbing/format/pktline/common.go b/plumbing/format/pktline/common.go new file mode 100644 index 000000000..ed6b465b0 --- /dev/null +++ b/plumbing/format/pktline/common.go @@ -0,0 +1,56 @@ +package pktline + +import "errors" + +const ( + // Err is returned when the pktline has encountered an error. + Err = iota - 1 + + // Flush is the numeric value of a flush packet. It is returned when the + // pktline is a flush packet. + Flush + + // Delim is the numeric value of a delim packet. It is returned when the + // pktline is a delim packet. + Delim + + // ResponseEnd is the numeric value of a response-end packet. It is + // returned when the pktline is a response-end packet. + ResponseEnd +) + +const ( + // MaxPayloadSize is the maximum payload size of a pkt-line in bytes. + // See https://git-scm.com/docs/protocol-common#_pkt_line_format + MaxPayloadSize = MaxSize - LenSize + + // MaxSize is the maximum packet size of a pkt-line in bytes. + // See https://git-scm.com/docs/protocol-common#_pkt_line_format + MaxSize = 65520 + + // LenSize is the size of the packet length in bytes. + LenSize = 4 +) + +var ( + // ErrPayloadTooLong is returned by the Encode methods when any of the + // provided payloads is bigger than MaxPayloadSize. + ErrPayloadTooLong = errors.New("payload is too long") + + // ErrInvalidPktLen is returned by Err() when an invalid pkt-len is found. + ErrInvalidPktLen = errors.New("invalid pkt-len found") +) + +var ( + // flushPkt are the contents of a flush-pkt pkt-line. + flushPkt = []byte{'0', '0', '0', '0'} + + // delimPkt are the contents of a delim-pkt pkt-line. + delimPkt = []byte{'0', '0', '0', '1'} + + // responseEndPkt are the contents of a response-end-pkt pkt-line. + responseEndPkt = []byte{'0', '0', '0', '2'} + + // emptyPkt is an empty string pkt-line payload. + emptyPkt = []byte{'0', '0', '0', '4'} +) diff --git a/plumbing/format/pktline/encoder.go b/plumbing/format/pktline/encoder.go deleted file mode 100644 index b6144faf5..000000000 --- a/plumbing/format/pktline/encoder.go +++ /dev/null @@ -1,126 +0,0 @@ -// Package pktline implements reading payloads form pkt-lines and encoding -// pkt-lines from payloads. -package pktline - -import ( - "bytes" - "errors" - "fmt" - "io" - - "github.com/go-git/go-git/v5/utils/trace" -) - -// An Encoder writes pkt-lines to an output stream. -type Encoder struct { - w io.Writer -} - -const ( - // MaxPayloadSize is the maximum payload size of a pkt-line in bytes. - MaxPayloadSize = 65516 - - // For compatibility with canonical Git implementation, accept longer pkt-lines - OversizePayloadMax = 65520 -) - -var ( - // FlushPkt are the contents of a flush-pkt pkt-line. - FlushPkt = []byte{'0', '0', '0', '0'} - // Flush is the payload to use with the Encode method to encode a flush-pkt. - Flush = []byte{} - // FlushString is the payload to use with the EncodeString method to encode a flush-pkt. - FlushString = "" - // ErrPayloadTooLong is returned by the Encode methods when any of the - // provided payloads is bigger than MaxPayloadSize. - ErrPayloadTooLong = errors.New("payload is too long") -) - -// NewEncoder returns a new encoder that writes to w. -func NewEncoder(w io.Writer) *Encoder { - return &Encoder{ - w: w, - } -} - -// Flush encodes a flush-pkt to the output stream. -func (e *Encoder) Flush() error { - defer trace.Packet.Print("packet: > 0000") - _, err := e.w.Write(FlushPkt) - return err -} - -// Encode encodes a pkt-line with the payload specified and write it to -// the output stream. If several payloads are specified, each of them -// will get streamed in their own pkt-lines. -func (e *Encoder) Encode(payloads ...[]byte) error { - for _, p := range payloads { - if err := e.encodeLine(p); err != nil { - return err - } - } - - return nil -} - -func (e *Encoder) encodeLine(p []byte) error { - if len(p) > MaxPayloadSize { - return ErrPayloadTooLong - } - - if bytes.Equal(p, Flush) { - return e.Flush() - } - - n := len(p) + 4 - defer trace.Packet.Printf("packet: > %04x %s", n, p) - if _, err := e.w.Write(asciiHex16(n)); err != nil { - return err - } - _, err := e.w.Write(p) - return err -} - -// Returns the hexadecimal ascii representation of the 16 less -// significant bits of n. The length of the returned slice will always -// be 4. Example: if n is 1234 (0x4d2), the return value will be -// []byte{'0', '4', 'd', '2'}. -func asciiHex16(n int) []byte { - var ret [4]byte - ret[0] = byteToASCIIHex(byte(n & 0xf000 >> 12)) - ret[1] = byteToASCIIHex(byte(n & 0x0f00 >> 8)) - ret[2] = byteToASCIIHex(byte(n & 0x00f0 >> 4)) - ret[3] = byteToASCIIHex(byte(n & 0x000f)) - - return ret[:] -} - -// turns a byte into its hexadecimal ascii representation. Example: -// from 11 (0xb) to 'b'. -func byteToASCIIHex(n byte) byte { - if n < 10 { - return '0' + n - } - - return 'a' - 10 + n -} - -// EncodeString works similarly as Encode but payloads are specified as strings. -func (e *Encoder) EncodeString(payloads ...string) error { - for _, p := range payloads { - if err := e.Encode([]byte(p)); err != nil { - return err - } - } - - return nil -} - -// Encodef encodes a single pkt-line with the payload formatted as -// the format specifier. The rest of the arguments will be used in -// the format string. -func (e *Encoder) Encodef(format string, a ...interface{}) error { - return e.EncodeString( - fmt.Sprintf(format, a...), - ) -} diff --git a/plumbing/format/pktline/error.go b/plumbing/format/pktline/error.go index 2c0e5a72a..852b47d05 100644 --- a/plumbing/format/pktline/error.go +++ b/plumbing/format/pktline/error.go @@ -1,10 +1,8 @@ package pktline import ( - "bytes" "errors" "io" - "strings" ) var ( @@ -12,9 +10,16 @@ var ( // error line. ErrInvalidErrorLine = errors.New("expected an error-line") + // ErrNilWriter is returned when a nil writer is passed to WritePacket. + ErrNilWriter = errors.New("nil writer") + errPrefix = []byte("ERR ") ) +const ( + errPrefixSize = LenSize +) + // ErrorLine is a packet line that contains an error message. // Once this packet is sent by client or server, the data transfer process is // terminated. @@ -30,22 +35,17 @@ func (e *ErrorLine) Error() string { // Encode encodes the ErrorLine into a packet line. func (e *ErrorLine) Encode(w io.Writer) error { - p := NewEncoder(w) - return p.Encodef("%s%s\n", string(errPrefix), e.Text) + _, err := Writef(w, "%s%s\n", errPrefix, e.Text) + return err } // Decode decodes a packet line into an ErrorLine. func (e *ErrorLine) Decode(r io.Reader) error { - s := NewScanner(r) - if !s.Scan() { - return s.Err() - } - - line := s.Bytes() - if !bytes.HasPrefix(line, errPrefix) { + _, _, err := ReadLine(r) + var el *ErrorLine + if !errors.As(err, &el) { return ErrInvalidErrorLine } - - e.Text = strings.TrimSpace(string(line[4:])) + e.Text = el.Text return nil } diff --git a/plumbing/format/pktline/error_test.go b/plumbing/format/pktline/error_test.go index 3cffd20d1..fff17932b 100644 --- a/plumbing/format/pktline/error_test.go +++ b/plumbing/format/pktline/error_test.go @@ -1,6 +1,7 @@ package pktline import ( + "bufio" "bytes" "errors" "io" @@ -33,7 +34,7 @@ func TestDecodeEmptyErrorLine(t *testing.T) { var buf bytes.Buffer e := &ErrorLine{} err := e.Decode(&buf) - if err != nil { + if !errors.Is(err, ErrInvalidErrorLine) { t.Fatal(err) } if e.Text != "" { @@ -44,10 +45,10 @@ func TestDecodeEmptyErrorLine(t *testing.T) { func TestDecodeErrorLine(t *testing.T) { var buf bytes.Buffer buf.WriteString("000eERR foobar") - var e *ErrorLine + var e ErrorLine err := e.Decode(&buf) - if !errors.As(err, &e) { - t.Fatalf("expected error line, got: %T: %v", err, err) + if err != nil { + t.Fatal(err) } if e.Text != "foobar" { t.Fatalf("unexpected error line: %q", e.Text) @@ -57,12 +58,22 @@ func TestDecodeErrorLine(t *testing.T) { func TestDecodeErrorLineLn(t *testing.T) { var buf bytes.Buffer buf.WriteString("000fERR foobar\n") - var e *ErrorLine + var e ErrorLine err := e.Decode(&buf) - if !errors.As(err, &e) { - t.Fatalf("expected error line, got: %T: %v", err, err) + if err != nil { + t.Fatal(err) } if e.Text != "foobar" { t.Fatalf("unexpected error line: %q", e.Text) } } + +func TestPeekErrorLine(t *testing.T) { + var buf bytes.Buffer + buf.WriteString("000fERR foobar\n") + var e *ErrorLine + _, _, err := PeekLine(bufio.NewReader(&buf)) + if !errors.As(err, &e) { + t.Fatalf("expected error line, got: %T: %v", err, err) + } +} diff --git a/plumbing/format/pktline/length.go b/plumbing/format/pktline/length.go new file mode 100644 index 000000000..e8e774024 --- /dev/null +++ b/plumbing/format/pktline/length.go @@ -0,0 +1,87 @@ +package pktline + +// ParseLength parses a four digit hexadecimal number from the given byte slice +// into its integer representation. If the byte slice contains non-hexadecimal, +// it will return an error. +func ParseLength(b []byte) (int, error) { + if b == nil { + return Err, ErrInvalidPktLen + } + + n, err := hexDecode(b) + if err != nil { + return Err, err + } + + if n == 3 { + return Err, ErrInvalidPktLen + } + + // Limit the maximum size of a pkt-line to 65520 bytes. + // Fixes: b4177b89c08b (plumbing: format: pktline, Accept oversized pkt-lines up to 65524 bytes) + // See https://github.com/git/git/commit/7841c4801ce51f1f62d376d164372e8677c6bc94 + if n > MaxSize { + return Err, ErrInvalidPktLen + } + + return n, nil +} + +// Turns the hexadecimal representation of a number in a byte slice into +// a number. This function substitute strconv.ParseUint(string(buf), 16, +// 16) and/or hex.Decode, to avoid generating new strings, thus helping the +// GC. +func hexDecode(buf []byte) (int, error) { + if len(buf) < 4 { + return 0, ErrInvalidPktLen + } + + var ret int + for i := 0; i < LenSize; i++ { + n, err := asciiHexToByte(buf[i]) + if err != nil { + return 0, ErrInvalidPktLen + } + ret = 16*ret + int(n) + } + return ret, nil +} + +// turns the hexadecimal ascii representation of a byte into its +// numerical value. Example: from 'b' to 11 (0xb). +func asciiHexToByte(b byte) (byte, error) { + switch { + case b >= '0' && b <= '9': + return b - '0', nil + case b >= 'a' && b <= 'f': + return b - 'a' + 10, nil + case b >= 'A' && b <= 'F': + return b - 'A' + 10, nil + default: + return 0, ErrInvalidPktLen + } +} + +// Returns the hexadecimal ascii representation of the 16 less +// significant bits of n. The length of the returned slice will always +// be 4. Example: if n is 1234 (0x4d2), the return value will be +// []byte{'0', '4', 'd', '2'}. +func asciiHex16(n int) []byte { + var ret [4]byte + ret[0] = byteToASCIIHex(byte(n & 0xf000 >> 12)) + ret[1] = byteToASCIIHex(byte(n & 0x0f00 >> 8)) + ret[2] = byteToASCIIHex(byte(n & 0x00f0 >> 4)) + ret[3] = byteToASCIIHex(byte(n & 0x000f)) + + return ret[:] +} + +// turns a byte into its hexadecimal ascii representation. Example: +// from 11 (0xb) to 'b'. +func byteToASCIIHex(n byte) byte { + if n < 10 { + return '0' + n + } + + return 'a' - 10 + n +} diff --git a/plumbing/format/pktline/pktline.go b/plumbing/format/pktline/pktline.go new file mode 100644 index 000000000..889822c08 --- /dev/null +++ b/plumbing/format/pktline/pktline.go @@ -0,0 +1,233 @@ +package pktline + +import ( + "bytes" + "fmt" + "io" + + "github.com/jesseduffield/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/utils/trace" +) + +// Write writes a pktline packet. +func Write(w io.Writer, p []byte) (n int, err error) { + if w == nil { + return 0, ErrNilWriter + } + + defer func() { + if err == nil { + maskPackDataTrace(true, n, p) + } + }() + + if len(p) == 0 { + return w.Write(emptyPkt) + } + + if len(p) > MaxPayloadSize { + return 0, ErrPayloadTooLong + } + + pktlen := len(p) + LenSize + n, err = w.Write(asciiHex16(pktlen)) + if err != nil { + return + } + + n2, err := w.Write(p) + n += n2 + return +} + +// Writef writes a pktline packet from a format string. +func Writef(w io.Writer, format string, a ...interface{}) (n int, err error) { + if len(a) == 0 { + return Write(w, []byte(format)) + } + return Write(w, []byte(fmt.Sprintf(format, a...))) +} + +// Writeln writes a pktline packet from a string and appends a newline. +func Writeln(w io.Writer, s string) (n int, err error) { + return Write(w, []byte(s+"\n")) +} + +// WriteString writes a pktline packet from a string. +func WriteString(w io.Writer, s string) (n int, err error) { + return Write(w, []byte(s)) +} + +// WriteError writes an error packet. +func WriteError(w io.Writer, e error) (n int, err error) { + return Writef(w, "%s%s\n", errPrefix, e.Error()) +} + +// WriteFlush writes a flush packet. +// This always writes 4 bytes. +func WriteFlush(w io.Writer) (err error) { + defer func() { + if err == nil { + trace.Packet.Printf("packet: > 0000") + } + }() + + _, err = w.Write(flushPkt) + return err +} + +// WriteDelim writes a delimiter packet. +// This always writes 4 bytes. +func WriteDelim(w io.Writer) (err error) { + defer func() { + if err == nil { + trace.Packet.Printf("packet: > 0001") + } + }() + + _, err = w.Write(delimPkt) + return err +} + +// WriteResponseEnd writes a response-end packet. +// This always writes 4 bytes. +func WriteResponseEnd(w io.Writer) (err error) { + defer func() { + if err == nil { + trace.Packet.Printf("packet: > 0002") + } + }() + + _, err = w.Write(responseEndPkt) + return err +} + +// Read reads a pktline packet payload into p and returns the packet full +// length. +// +// If p is less than 4 bytes, Read returns ErrInvalidPktLen. If p cannot hold +// the entire packet, Read returns io.ErrUnexpectedEOF. +// The error can be of type *ErrorLine if the packet is an error packet. +// +// Use packet length to determine the type of packet i.e. 0 is a flush packet, +// 1 is a delim packet, 2 is a response-end packet, and a length greater or +// equal to 4 is a data packet. +func Read(r io.Reader, p []byte) (l int, err error) { + _, err = io.ReadFull(r, p[:LenSize]) + if err != nil { + if err == io.ErrUnexpectedEOF { + return Err, ErrInvalidPktLen + } + return Err, err + } + + length, err := ParseLength(p) + if err != nil { + return Err, err + } + + switch length { + case Flush, Delim, ResponseEnd: + trace.Packet.Printf("packet: < %04x", length) + return length, nil + case LenSize: // empty line + trace.Packet.Printf("packet: < %04x", length) + return length, nil + } + + _, err = io.ReadFull(r, p[LenSize:length]) + if err != nil { + return Err, err + } + + if bytes.HasPrefix(p[LenSize:], errPrefix) { + err = &ErrorLine{ + Text: string(bytes.TrimSpace(p[LenSize+errPrefixSize : length])), + } + } + + maskPackDataTrace(false, length, p[LenSize:length]) + + return length, err +} + +// ReadLine reads a packet line into a temporary shared buffer and +// returns the packet length and payload. +// Subsequent calls to ReadLine may overwrite the buffer. +// +// Use packet length to determine the type of packet i.e. 0 is a flush packet, +// 1 is a delim packet, 2 is a response-end packet, and a length greater or +// equal to 4 is a data packet. +// +// The error can be of type *ErrorLine if the packet is an error packet. +func ReadLine(r io.Reader) (l int, p []byte, err error) { + buf := GetBuffer() + defer PutBuffer(buf) + + l, err = Read(r, (*buf)[:]) + if l < LenSize { + return l, nil, err + } + + return l, (*buf)[LenSize:l], err +} + +// PeekLine reads a packet line without consuming it. +// +// Use packet length to determine the type of packet i.e. 0 is a flush packet, +// 1 is a delim packet, 2 is a response-end packet, and a length greater or +// equal to 4 is a data packet. +// +// The error can be of type *ErrorLine if the packet is an error packet. +func PeekLine(r ioutil.ReadPeeker) (l int, p []byte, err error) { + n, err := r.Peek(LenSize) + if err != nil { + return Err, nil, err + } + + length, err := ParseLength(n) + if err != nil { + return Err, nil, err + } + + switch length { + case Flush, Delim, ResponseEnd: + trace.Packet.Printf("packet: < %04x", length) + return length, nil, nil + case LenSize: // empty line + trace.Packet.Printf("packet: < %04x", length) + return length, []byte{}, nil + } + + data, err := r.Peek(length) + if err != nil { + return Err, nil, err + } + + buf := data[LenSize:length] + if bytes.HasPrefix(buf, errPrefix) { + err = &ErrorLine{ + Text: string(bytes.TrimSpace(buf[errPrefixSize:])), + } + } + + maskPackDataTrace(false, length, buf) + + return length, buf, err +} + +func maskPackDataTrace(out bool, l int, data []byte) { + if !trace.Packet.Enabled() { + return + } + + output := []byte("[ PACKDATA ]") + if l < 400 && len(data) > 0 && data[0] != 1 { // [sideband.PackData] + output = data + } + arrow := '<' + if out { + arrow = '>' + } + trace.Packet.Printf("packet: %c %04x %q", arrow, l, output) +} diff --git a/plumbing/format/pktline/pktline_bench_test.go b/plumbing/format/pktline/pktline_bench_test.go new file mode 100644 index 000000000..98115a423 --- /dev/null +++ b/plumbing/format/pktline/pktline_bench_test.go @@ -0,0 +1,214 @@ +package pktline_test + +import ( + "bytes" + "io" + "strings" + "testing" + + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" +) + +func BenchmarkScanner(b *testing.B) { + sections, err := sectionsExample(2, 4) + if err != nil { + b.Fatal(err) + } + + var maxp bytes.Buffer + if _, err := pktline.WriteString(&maxp, strings.Repeat("a", pktline.MaxPayloadSize)); err != nil { + b.Fatal(err) + } + + cases := []struct { + name string + input string + }{ + { + name: "empty", + input: "", + }, + { + name: "one message", + input: "000ahello\n", + }, + { + name: "two messages", + input: "000ahello\n000bworld!\n", + }, + { + name: "sections", + input: sections.String(), + }, + { + name: "max packet size", + input: maxp.String(), + }, + } + for _, tc := range cases { + r := strings.NewReader("") + s := pktline.NewScanner(r) + b.Run(tc.name, func(b *testing.B) { + for i := 0; i < b.N; i++ { + r.Reset(tc.input) + for s.Scan() { + if err := s.Err(); err != nil && err != io.EOF { + b.Error(err) + } + } + } + }) + } +} + +func BenchmarkReadPacket(b *testing.B) { + sections, err := sectionsExample(2, 4) + if err != nil { + b.Fatal(err) + } + + var maxp bytes.Buffer + if _, err := pktline.WriteString(&maxp, strings.Repeat("a", pktline.MaxPayloadSize)); err != nil { + b.Fatal(err) + } + + cases := []struct { + name string + input string + }{ + { + name: "empty", + input: "", + }, + { + name: "one message", + input: "000ahello\n", + }, + { + name: "two messages", + input: "000ahello\n000bworld!\n", + }, + { + name: "sections", + input: sections.String(), + }, + { + name: "max packet size", + input: maxp.String(), + }, + } + for _, tc := range cases { + r := strings.NewReader("") + b.Run(tc.name, func(b *testing.B) { + buf := pktline.GetBuffer() + for i := 0; i < b.N; i++ { + r.Reset(tc.input) + for { + _, err := pktline.Read(r, (*buf)[:]) + if err == io.EOF { + break + } + if err != nil { + b.Error(err) + } + } + } + pktline.PutBuffer(buf) + }) + } +} + +func BenchmarkReadPacketLine(b *testing.B) { + sections, err := sectionsExample(2, 4) + if err != nil { + b.Fatal(err) + } + + var maxp bytes.Buffer + if _, err := pktline.WriteString(&maxp, strings.Repeat("a", pktline.MaxPayloadSize)); err != nil { + b.Fatal(err) + } + + cases := []struct { + name string + input string + }{ + { + name: "empty", + input: "", + }, + { + name: "one message", + input: "000ahello\n", + }, + { + name: "two messages", + input: "000ahello\n000bworld!\n", + }, + { + name: "sections", + input: sections.String(), + }, + { + name: "max packet size", + input: maxp.String(), + }, + } + for _, tc := range cases { + r := strings.NewReader("") + b.Run(tc.name, func(b *testing.B) { + for i := 0; i < b.N; i++ { + r.Reset(tc.input) + for { + _, _, err := pktline.ReadLine(r) + if err == io.EOF { + break + } + if err != nil { + break + } + } + } + }) + } +} + +func BenchmarkWritePacket(b *testing.B) { + sections, err := sectionsExample(2, 4) + if err != nil { + b.Fatal(err) + } + + cases := []struct { + name string + input []byte + }{ + { + name: "empty", + input: []byte(""), + }, + { + name: "one message", + input: []byte("hello\n"), + }, + { + name: "two messages", + input: []byte("hello\nworld!\n"), + }, + { + name: "sections", + input: sections.Bytes(), + }, + } + for _, tc := range cases { + b.Run(tc.name, func(b *testing.B) { + var buf bytes.Buffer + for i := 0; i < b.N; i++ { + _, err := pktline.Write(&buf, tc.input) + if err != nil { + b.Fatal(err) + } + } + }) + } +} diff --git a/plumbing/format/pktline/pktline_read_test.go b/plumbing/format/pktline/pktline_read_test.go new file mode 100644 index 000000000..633730965 --- /dev/null +++ b/plumbing/format/pktline/pktline_read_test.go @@ -0,0 +1,365 @@ +package pktline_test + +import ( + "bufio" + "bytes" + "errors" + "fmt" + "io" + "strings" + "testing" + + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" + "github.com/stretchr/testify/suite" +) + +type SuiteReader struct { + suite.Suite +} + +func TestSuiteReader(t *testing.T) { + suite.Run(t, new(SuiteReader)) +} + +func (s *SuiteReader) TestInvalid() { + for i, test := range [...]string{ + "0003", + "fff5", "ffff", + "gorka", + "0", "003", + " 5a", "5 a", "5 \n", + "-001", "-000", + } { + r := strings.NewReader(test) + _, _, err := pktline.ReadLine(r) + s.ErrorContains(err, pktline.ErrInvalidPktLen.Error(), + fmt.Sprintf("i = %d, data = %q", i, test)) + } +} + +func (s *SuiteReader) TestDecodeOversizePktLines() { + for _, test := range [...]string{ + "fff1" + strings.Repeat("a", 0xfff1), + "fff2" + strings.Repeat("a", 0xfff2), + "fff3" + strings.Repeat("a", 0xfff3), + "fff4" + strings.Repeat("a", 0xfff4), + } { + r := strings.NewReader(test) + _, _, err := pktline.ReadLine(r) + s.NotNil(err) + } +} + +func (s *SuiteReader) TestEmptyReader() { + r := strings.NewReader("") + l, p, err := pktline.ReadLine(r) + s.Equal(-1, l) + s.Nil(p) + s.ErrorContains(err, io.EOF.Error()) +} + +func (s *SuiteReader) TestFlush() { + var buf bytes.Buffer + err := pktline.WriteFlush(&buf) + s.NoError(err) + + l, p, err := pktline.ReadLine(&buf) + s.Equal(pktline.Flush, l) + s.Nil(p) + s.NoError(err) + s.Len(p, 0) +} + +func (s *SuiteReader) TestPktLineTooShort() { + r := strings.NewReader("010cfoobar") + _, _, err := pktline.ReadLine(r) + s.ErrorContains(err, "unexpected EOF") +} + +func (s *SuiteReader) TestScanAndPayload() { + for i, test := range [...]string{ + "a", + "a\n", + strings.Repeat("a", 100), + strings.Repeat("a", 100) + "\n", + strings.Repeat("\x00", 100), + strings.Repeat("\x00", 100) + "\n", + strings.Repeat("a", pktline.MaxPayloadSize), + strings.Repeat("a", pktline.MaxPayloadSize-1) + "\n", + } { + var buf bytes.Buffer + _, err := pktline.Writef(&buf, "%s", test) + s.NoError(err, + fmt.Sprintf("input len=%x, contents=%.10q\n", len(test), test)) + + _, p, err := pktline.ReadLine(&buf) + s.NoError(err) + s.NotNil(p, + fmt.Sprintf("i = %d, payload = %q, test = %.20q...", i, p, test)) + + s.Equal([]byte(test), p, + fmt.Sprintf("in = %.20q out = %.20q", test, string(p))) + } +} + +func (s *SuiteReader) TestSkip() { + for _, test := range [...]struct { + input []string + n int + expected []byte + }{ + { + input: []string{ + "first", + "second", + "third", + }, + n: 1, + expected: []byte("second"), + }, + { + input: []string{ + "first", + "second", + "third", + }, + n: 2, + expected: []byte("third"), + }, + } { + var buf bytes.Buffer + for _, in := range test.input { + _, err := pktline.Writef(&buf, "%s", in) + s.NoError(err) + } + + for i := 0; i < test.n; i++ { + _, p, err := pktline.ReadLine(&buf) + s.NotNil(p, + fmt.Sprintf("scan error = %s", err)) + } + _, p, err := pktline.ReadLine(&buf) + s.NotNil(p, + fmt.Sprintf("scan error = %s", err)) + + s.Equal(test.expected, p, + fmt.Sprintf("\nin = %.20q\nout = %.20q\nexp = %.20q", + test.input, p, test.expected)) + } +} + +func (s *SuiteReader) TestEOF() { + var buf bytes.Buffer + _, err := pktline.Writef(&buf, "first") + s.NoError(err) + _, err = pktline.Writef(&buf, "second") + s.NoError(err) + + for { + _, _, err = pktline.ReadLine(&buf) + if err == io.EOF { + break + } + } + s.ErrorContains(err, "EOF") +} + +type mockSuiteReader struct{} + +func (r *mockSuiteReader) Read([]byte) (int, error) { return 0, errors.New("foo") } + +func (s *SuiteReader) TestInternalReadError() { + r := &mockSuiteReader{} + _, p, err := pktline.ReadLine(r) + s.Nil(p) + s.ErrorContains(err, "foo") +} + +// A section are several non flush-pkt lines followed by a flush-pkt, which +// how the git protocol sends long messages. +func (s *SuiteReader) TestReadSomeSections() { + nSections := 2 + nLines := 4 + data, err := sectionsExample(nSections, nLines) + s.NoError(err) + + sectionCounter := 0 + lineCounter := 0 + var ( + p []byte + e error + ) + for { + _, p, e = pktline.ReadLine(data) + if e == io.EOF { + break + } + if len(p) == 0 { + sectionCounter++ + } + lineCounter++ + } + s.ErrorContains(e, "EOF") + s.Equal(nSections, sectionCounter) + s.Equal((1+nLines)*nSections, lineCounter) +} + +func (s *SuiteReader) TestPeekReadPacket() { + var buf bytes.Buffer + _, err := pktline.Writef(&buf, "first") + s.NoError(err) + _, err = pktline.Writef(&buf, "second") + s.NoError(err) + + sc := bufio.NewReader(&buf) + p, err := sc.Peek(4) + s.NoError(err) + s.Equal([]byte("0009"), p) + + l, p, err := pktline.ReadLine(sc) + s.NoError(err) + s.Equal(9, l) + s.Equal([]byte("first"), p) + + p, err = sc.Peek(4) + s.NoError(err) + s.Equal([]byte("000a"), p) +} + +func (s *SuiteReader) TestPeekMultiple() { + var buf bytes.Buffer + _, err := pktline.WriteString(&buf, "a") + s.NoError(err) + + sc := bufio.NewReader(&buf) + b, err := sc.Peek(4) + s.Equal([]byte("0005"), b) + s.NoError(err) + + b, err = sc.Peek(5) + s.Equal([]byte("0005a"), b) + s.NoError(err) +} + +func (s *SuiteReader) TestInvalidPeek() { + var buf bytes.Buffer + _, err := pktline.WriteString(&buf, "a") + s.NoError(err) + s.NoError(err) + + sc := bufio.NewReader(&buf) + _, err = sc.Peek(-1) + s.ErrorContains(err, bufio.ErrNegativeCount.Error()) +} + +func (s *SuiteReader) TestPeekPacket() { + var buf bytes.Buffer + _, err := pktline.Writef(&buf, "first") + s.NoError(err) + _, err = pktline.Writef(&buf, "second") + s.NoError(err) + sc := bufio.NewReader(&buf) + l, p, err := pktline.PeekLine(sc) + s.NoError(err) + s.Equal(9, l) + s.Equal([]byte("first"), p) + l, p, err = pktline.PeekLine(sc) + s.NoError(err) + s.Equal(9, l) + s.Equal([]byte("first"), p) +} + +func (s *SuiteReader) TestPeekPacketReadPacket() { + var buf bytes.Buffer + _, err := pktline.WriteString(&buf, "a") + s.NoError(err) + + sc := bufio.NewReader(&buf) + l, p, err := pktline.PeekLine(sc) + s.NoError(err) + s.Equal(5, l) + s.Equal([]byte("a"), p) + + l, p, err = pktline.ReadLine(sc) + s.NoError(err) + s.Equal(5, l) + s.Equal([]byte("a"), p) + + l, p, err = pktline.PeekLine(sc) + s.ErrorContains(err, io.EOF.Error()) + s.Equal(-1, l) + s.Nil(p) +} + +func (s *SuiteReader) TestPeekRead() { + hash := "6ecf0ef2c2dffb796033e5a02219af86ec6584e5" + + var buf bytes.Buffer + _, err := pktline.Writef(&buf, "%s", hash) + s.NoError(err) + + sc := bufio.NewReader(&buf) + b, err := sc.Peek(7) + s.NoError(err) + s.Equal([]byte("002c6ec"), b) + + full, err := io.ReadAll(sc) + s.NoError(err) + s.Equal("002c"+hash, string(full)) +} + +func (s *SuiteReader) TestPeekReadPart() { + hash := "6ecf0ef2c2dffb796033e5a02219af86ec6584e5" + + var buf bytes.Buffer + _, err := pktline.Writef(&buf, "%s", hash) + s.NoError(err) + + sc := bufio.NewReader(&buf) + b, err := sc.Peek(7) + s.NoError(err) + s.Equal([]byte("002c6ec"), b) + + var part [8]byte + n, err := sc.Read(part[:]) + s.NoError(err) + s.Equal(8, n) + s.Equal([]byte("002c6ecf"), part[:]) +} + +func (s *SuiteReader) TestReadPacketError() { + var buf bytes.Buffer + _, err := pktline.WriteError(&buf, io.EOF) + s.NoError(err) + + l, p, err := pktline.ReadLine(&buf) + s.NotNil(err) + s.Equal(12, l) + s.Equal("ERR EOF\n", string(p)) +} + +// returns nSection sections, each of them with nLines pkt-lines (not +// counting the flush-pkt: +// +// 0009 0.0\n +// 0009 0.1\n +// ... +// 0000 +// and so on +func sectionsExample(nSections, nLines int) (*bytes.Buffer, error) { + var buf bytes.Buffer + for section := 0; section < nSections; section++ { + for line := 0; line < nLines; line++ { + line := fmt.Sprintf(" %d.%d\n", section, line) + _, err := pktline.WriteString(&buf, line) + if err != nil { + return nil, err + } + } + if err := pktline.WriteFlush(&buf); err != nil { + return nil, err + } + } + + return &buf, nil +} diff --git a/plumbing/format/pktline/encoder_test.go b/plumbing/format/pktline/pktline_write_test.go similarity index 63% rename from plumbing/format/pktline/encoder_test.go rename to plumbing/format/pktline/pktline_write_test.go index a6addd658..e38db1527 100644 --- a/plumbing/format/pktline/encoder_test.go +++ b/plumbing/format/pktline/pktline_write_test.go @@ -2,32 +2,32 @@ package pktline_test import ( "bytes" + "fmt" "strings" "testing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } - -type SuiteEncoder struct{} +type SuiteWriter struct { + suite.Suite +} -var _ = Suite(&SuiteEncoder{}) +func TestSuiteWriter(t *testing.T) { + suite.Run(t, new(SuiteWriter)) +} -func (s *SuiteEncoder) TestFlush(c *C) { +func (s *SuiteWriter) TestFlush() { var buf bytes.Buffer - e := pktline.NewEncoder(&buf) - - err := e.Flush() - c.Assert(err, IsNil) + err := pktline.WriteFlush(&buf) + s.NoError(err) obtained := buf.Bytes() - c.Assert(obtained, DeepEquals, pktline.FlushPkt) + s.Equal([]byte("0000"), obtained) } -func (s *SuiteEncoder) TestEncode(c *C) { +func (s *SuiteWriter) TestEncode() { for i, test := range [...]struct { input [][]byte expected []byte @@ -40,7 +40,7 @@ func (s *SuiteEncoder) TestEncode(c *C) { }, { input: [][]byte{ []byte("hello\n"), - pktline.Flush, + {}, }, expected: []byte("000ahello\n0000"), }, { @@ -53,10 +53,10 @@ func (s *SuiteEncoder) TestEncode(c *C) { }, { input: [][]byte{ []byte("hello\n"), - pktline.Flush, + {}, []byte("world!\n"), []byte("foo"), - pktline.Flush, + {}, }, expected: []byte("000ahello\n0000000bworld!\n0007foo0000"), }, { @@ -75,19 +75,25 @@ func (s *SuiteEncoder) TestEncode(c *C) { "fff0" + strings.Repeat("b", pktline.MaxPayloadSize)), }, } { - comment := Commentf("input %d = %v\n", i, test.input) + comment := fmt.Sprintf("input %d = %s\n", i, test.input) var buf bytes.Buffer - e := pktline.NewEncoder(&buf) - err := e.Encode(test.input...) - c.Assert(err, IsNil, comment) - - c.Assert(buf.Bytes(), DeepEquals, test.expected, comment) + for _, p := range test.input { + var err error + if len(p) == 0 { + err = pktline.WriteFlush(&buf) + } else { + _, err = pktline.Write(&buf, p) + } + s.NoError(err, comment) + } + + s.Equal(string(test.expected), buf.String(), comment) } } -func (s *SuiteEncoder) TestEncodeErrPayloadTooLong(c *C) { +func (s *SuiteWriter) TestEncodeErrPayloadTooLong() { for i, input := range [...][][]byte{ { []byte(strings.Repeat("a", pktline.MaxPayloadSize+1)), @@ -102,17 +108,15 @@ func (s *SuiteEncoder) TestEncodeErrPayloadTooLong(c *C) { []byte("foo"), }, } { - comment := Commentf("input %d = %v\n", i, input) + comment := fmt.Sprintf("input %d = %v\n", i, input) var buf bytes.Buffer - e := pktline.NewEncoder(&buf) - - err := e.Encode(input...) - c.Assert(err, Equals, pktline.ErrPayloadTooLong, comment) + _, err := pktline.Write(&buf, bytes.Join(input, nil)) + s.Equal(pktline.ErrPayloadTooLong, err, comment) } } -func (s *SuiteEncoder) TestEncodeStrings(c *C) { +func (s *SuiteWriter) TestWritePacketStrings() { for i, test := range [...]struct { input []string expected []byte @@ -125,7 +129,7 @@ func (s *SuiteEncoder) TestEncodeStrings(c *C) { }, { input: []string{ "hello\n", - pktline.FlushString, + "", }, expected: []byte("000ahello\n0000"), }, { @@ -138,10 +142,10 @@ func (s *SuiteEncoder) TestEncodeStrings(c *C) { }, { input: []string{ "hello\n", - pktline.FlushString, + "", "world!\n", "foo", - pktline.FlushString, + "", }, expected: []byte("000ahello\n0000000bworld!\n0007foo0000"), }, { @@ -160,18 +164,23 @@ func (s *SuiteEncoder) TestEncodeStrings(c *C) { "fff0" + strings.Repeat("b", pktline.MaxPayloadSize)), }, } { - comment := Commentf("input %d = %v\n", i, test.input) + comment := fmt.Sprintf("input %d = %v\n", i, test.input) var buf bytes.Buffer - e := pktline.NewEncoder(&buf) - - err := e.EncodeString(test.input...) - c.Assert(err, IsNil, comment) - c.Assert(buf.Bytes(), DeepEquals, test.expected, comment) + for _, p := range test.input { + var err error + if p == "" { + err = pktline.WriteFlush(&buf) + } else { + _, err = pktline.WriteString(&buf, p) + } + s.NoError(err, comment) + } + s.Equal(string(test.expected), buf.String(), comment) } } -func (s *SuiteEncoder) TestEncodeStringErrPayloadTooLong(c *C) { +func (s *SuiteWriter) TestWritePacketStringErrPayloadTooLong() { for i, input := range [...][]string{ { strings.Repeat("a", pktline.MaxPayloadSize+1), @@ -186,27 +195,23 @@ func (s *SuiteEncoder) TestEncodeStringErrPayloadTooLong(c *C) { "foo", }, } { - comment := Commentf("input %d = %v\n", i, input) + comment := fmt.Sprintf("input %d = %v\n", i, input) var buf bytes.Buffer - e := pktline.NewEncoder(&buf) - - err := e.EncodeString(input...) - c.Assert(err, Equals, pktline.ErrPayloadTooLong, comment) + _, err := pktline.WriteString(&buf, strings.Join(input, "")) + s.Equal(pktline.ErrPayloadTooLong, err, comment) } } -func (s *SuiteEncoder) TestEncodef(c *C) { +func (s *SuiteWriter) TestFormatString() { format := " %s %d\n" str := "foo" d := 42 var buf bytes.Buffer - e := pktline.NewEncoder(&buf) - - err := e.Encodef(format, str, d) - c.Assert(err, IsNil) + _, err := pktline.Writef(&buf, format, str, d) + s.NoError(err) expected := []byte("000c foo 42\n") - c.Assert(buf.Bytes(), DeepEquals, expected) + s.Equal(expected, buf.Bytes()) } diff --git a/plumbing/format/pktline/scanner.go b/plumbing/format/pktline/scanner.go index fbb137de0..ad6b2a5d6 100644 --- a/plumbing/format/pktline/scanner.go +++ b/plumbing/format/pktline/scanner.go @@ -1,21 +1,10 @@ package pktline import ( - "bytes" "errors" "io" - "strings" - - "github.com/go-git/go-git/v5/utils/trace" -) - -const ( - lenSize = 4 ) -// ErrInvalidPktLen is returned by Err() when an invalid pkt-len is found. -var ErrInvalidPktLen = errors.New("invalid pkt-len found") - // Scanner provides a convenient interface for reading the payloads of a // series of pkt-lines. It takes an io.Reader providing the source, // which then can be tokenized through repeated calls to the Scan @@ -27,10 +16,10 @@ var ErrInvalidPktLen = errors.New("invalid pkt-len found") // // Scanning stops at EOF or the first I/O error. type Scanner struct { - r io.Reader // The reader provided by the client - err error // Sticky error - payload []byte // Last pkt-payload - len [lenSize]byte // Last pkt-len + r io.Reader // The reader provided by the client + err error // Sticky error + buf [MaxSize]byte // Buffer used to read the pktlines + n int // Number of bytes read in the last read } // NewScanner returns a new Scanner to read from r. @@ -51,96 +40,36 @@ func (s *Scanner) Err() error { // will return any error that occurred during scanning, except that if // it was io.EOF, Err will return nil. func (s *Scanner) Scan() bool { - var l int - l, s.err = s.readPayloadLen() - if s.err == io.EOF { - s.err = nil - return false - } - if s.err != nil { - return false - } - - if cap(s.payload) < l { - s.payload = make([]byte, 0, l) - } - - if _, s.err = io.ReadFull(s.r, s.payload[:l]); s.err != nil { + if s.r == nil { return false } - s.payload = s.payload[:l] - trace.Packet.Printf("packet: < %04x %s", l, s.payload) - - if bytes.HasPrefix(s.payload, errPrefix) { - s.err = &ErrorLine{ - Text: strings.TrimSpace(string(s.payload[4:])), - } + s.n, s.err = Read(s.r, s.buf[:]) + if errors.Is(s.err, io.EOF) { + s.err = nil return false } - - return true + return s.err == nil } -// Bytes returns the most recent payload generated by a call to Scan. +// Bytes returns the most recent packet generated by a call to Scan. // The underlying array may point to data that will be overwritten by a // subsequent call to Scan. It does no allocation. +// This returns nil if the last scan was a special packet such as a [Flush], +// [Delim], or [ResponseEnd]. func (s *Scanner) Bytes() []byte { - return s.payload -} - -// Method readPayloadLen returns the payload length by reading the -// pkt-len and subtracting the pkt-len size. -func (s *Scanner) readPayloadLen() (int, error) { - if _, err := io.ReadFull(s.r, s.len[:]); err != nil { - if err == io.ErrUnexpectedEOF { - return 0, ErrInvalidPktLen - } - - return 0, err - } - - n, err := hexDecode(s.len) - if err != nil { - return 0, err - } - - switch { - case n == 0: - return 0, nil - case n <= lenSize: - return 0, ErrInvalidPktLen - case n > OversizePayloadMax+lenSize: - return 0, ErrInvalidPktLen - default: - return n - lenSize, nil + if s.n >= LenSize { + return s.buf[LenSize:s.n] } + return nil } -// Turns the hexadecimal representation of a number in a byte slice into -// a number. This function substitute strconv.ParseUint(string(buf), 16, -// 16) and/or hex.Decode, to avoid generating new strings, thus helping the -// GC. -func hexDecode(buf [lenSize]byte) (int, error) { - var ret int - for i := 0; i < lenSize; i++ { - n, err := asciiHexToByte(buf[i]) - if err != nil { - return 0, ErrInvalidPktLen - } - ret = 16*ret + int(n) - } - return ret, nil +// Text returns the most recent packet generated by a call to Scan. +func (s *Scanner) Text() string { + return string(s.Bytes()) } -// turns the hexadecimal ascii representation of a byte into its -// numerical value. Example: from 'b' to 11 (0xb). -func asciiHexToByte(b byte) (byte, error) { - switch { - case b >= '0' && b <= '9': - return b - '0', nil - case b >= 'a' && b <= 'f': - return b - 'a' + 10, nil - default: - return 0, ErrInvalidPktLen - } +// Len returns the length of the most recent packet generated by a call to +// Scan. +func (s *Scanner) Len() int { + return s.n } diff --git a/plumbing/format/pktline/scanner_test.go b/plumbing/format/pktline/scanner_test.go index 60b622407..ae0a3c89e 100644 --- a/plumbing/format/pktline/scanner_test.go +++ b/plumbing/format/pktline/scanner_test.go @@ -4,21 +4,24 @@ import ( "bytes" "errors" "fmt" - "io" "strings" + "testing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" + "github.com/stretchr/testify/suite" ) -type SuiteScanner struct{} +type SuiteScanner struct { + suite.Suite +} -var _ = Suite(&SuiteScanner{}) +func TestSuiteScanner(t *testing.T) { + suite.Run(t, new(SuiteScanner)) +} -func (s *SuiteScanner) TestInvalid(c *C) { +func (s *SuiteScanner) TestInvalid() { for _, test := range [...]string{ - "0001", "0002", "0003", "0004", + "0003", "0001asdfsadf", "0004foo", "fff5", "ffff", "gorka", @@ -28,13 +31,14 @@ func (s *SuiteScanner) TestInvalid(c *C) { } { r := strings.NewReader(test) sc := pktline.NewScanner(r) - _ = sc.Scan() - c.Assert(sc.Err(), ErrorMatches, pktline.ErrInvalidPktLen.Error(), - Commentf("data = %q", test)) + for sc.Scan() { + } + s.ErrorContains(sc.Err(), pktline.ErrInvalidPktLen.Error(), + fmt.Sprintf("data = %q", test)) } } -func (s *SuiteScanner) TestDecodeOversizePktLines(c *C) { +func (s *SuiteScanner) TestDecodeOversizePktLines() { for _, test := range [...]string{ "fff1" + strings.Repeat("a", 0xfff1), "fff2" + strings.Repeat("a", 0xfff2), @@ -44,41 +48,58 @@ func (s *SuiteScanner) TestDecodeOversizePktLines(c *C) { r := strings.NewReader(test) sc := pktline.NewScanner(r) _ = sc.Scan() - c.Assert(sc.Err(), IsNil) + s.ErrorIs(sc.Err(), pktline.ErrInvalidPktLen) + } +} + +func (s *SuiteScanner) TestValidPktSizes() { + for _, test := range [...]string{ + "01fe" + strings.Repeat("a", 0x01fe-4), + "01FE" + strings.Repeat("a", 0x01fe-4), + "00b5" + strings.Repeat("a", 0x00b5-4), + "00B5" + strings.Repeat("a", 0x00b5-4), + } { + r := strings.NewReader(test) + sc := pktline.NewScanner(r) + hasPayload := sc.Scan() + obtained := fmt.Sprintf("%04x%s", sc.Len(), sc.Bytes()) + + s.True(hasPayload) + s.NoError(sc.Err()) + s.Equal(strings.ToLower(test), obtained) } } -func (s *SuiteScanner) TestEmptyReader(c *C) { +func (s *SuiteScanner) TestEmptyReader() { r := strings.NewReader("") sc := pktline.NewScanner(r) hasPayload := sc.Scan() - c.Assert(hasPayload, Equals, false) - c.Assert(sc.Err(), Equals, nil) + s.False(hasPayload) + s.NoError(sc.Err()) } -func (s *SuiteScanner) TestFlush(c *C) { +func (s *SuiteScanner) TestFlush() { var buf bytes.Buffer - e := pktline.NewEncoder(&buf) - err := e.Flush() - c.Assert(err, IsNil) + err := pktline.WriteFlush(&buf) + s.NoError(err) sc := pktline.NewScanner(&buf) - c.Assert(sc.Scan(), Equals, true) + s.True(sc.Scan()) payload := sc.Bytes() - c.Assert(len(payload), Equals, 0) + s.Len(payload, 0) } -func (s *SuiteScanner) TestPktLineTooShort(c *C) { +func (s *SuiteScanner) TestPktLineTooShort() { r := strings.NewReader("010cfoobar") sc := pktline.NewScanner(r) - c.Assert(sc.Scan(), Equals, false) - c.Assert(sc.Err(), ErrorMatches, "unexpected EOF") + s.False(sc.Scan()) + s.ErrorContains(sc.Err(), "unexpected EOF") } -func (s *SuiteScanner) TestScanAndPayload(c *C) { +func (s *SuiteScanner) TestScanAndPayload() { for _, test := range [...]string{ "a", "a\n", @@ -90,32 +111,32 @@ func (s *SuiteScanner) TestScanAndPayload(c *C) { strings.Repeat("a", pktline.MaxPayloadSize-1) + "\n", } { var buf bytes.Buffer - e := pktline.NewEncoder(&buf) - err := e.EncodeString(test) - c.Assert(err, IsNil, - Commentf("input len=%x, contents=%.10q\n", len(test), test)) + _, err := pktline.Writef(&buf, "%s", test) + s.NoError(err, + fmt.Sprintf("input len=%x, contents=%.10q\n", len(test), test)) sc := pktline.NewScanner(&buf) - c.Assert(sc.Scan(), Equals, true, - Commentf("test = %.20q...", test)) + s.True(sc.Scan(), + fmt.Sprintf("test = %.20q...", test)) obtained := sc.Bytes() - c.Assert(obtained, DeepEquals, []byte(test), - Commentf("in = %.20q out = %.20q", test, string(obtained))) + s.Equal([]byte(test), obtained, + fmt.Sprintf("in = %.20q out = %.20q", test, string(obtained))) } } -func (s *SuiteScanner) TestSkip(c *C) { +func (s *SuiteScanner) TestSkip() { for _, test := range [...]struct { input []string - n int expected []byte + n int }{ { input: []string{ "first", "second", - "third"}, + "third", + }, n: 1, expected: []byte("second"), }, @@ -123,97 +144,74 @@ func (s *SuiteScanner) TestSkip(c *C) { input: []string{ "first", "second", - "third"}, + "third", + }, n: 2, expected: []byte("third"), }, } { var buf bytes.Buffer - e := pktline.NewEncoder(&buf) - err := e.EncodeString(test.input...) - c.Assert(err, IsNil) + for _, in := range test.input { + _, err := pktline.Writef(&buf, "%s", in) + s.NoError(err) + } sc := pktline.NewScanner(&buf) for i := 0; i < test.n; i++ { - c.Assert(sc.Scan(), Equals, true, - Commentf("scan error = %s", sc.Err())) + s.True(sc.Scan(), + fmt.Sprintf("scan error = %s", sc.Err())) } - c.Assert(sc.Scan(), Equals, true, - Commentf("scan error = %s", sc.Err())) + s.True(sc.Scan(), + fmt.Sprintf("scan error = %s", sc.Err())) obtained := sc.Bytes() - c.Assert(obtained, DeepEquals, test.expected, - Commentf("\nin = %.20q\nout = %.20q\nexp = %.20q", + s.Equal(test.expected, obtained, + fmt.Sprintf("\nin = %.20q\nout = %.20q\nexp = %.20q", test.input, obtained, test.expected)) } } -func (s *SuiteScanner) TestEOF(c *C) { +func (s *SuiteScanner) TestEOF() { var buf bytes.Buffer - e := pktline.NewEncoder(&buf) - err := e.EncodeString("first", "second") - c.Assert(err, IsNil) + for _, in := range []string{"first", "second"} { + _, err := pktline.Writef(&buf, "%s", in) + s.NoError(err) + } sc := pktline.NewScanner(&buf) for sc.Scan() { } - c.Assert(sc.Err(), IsNil) + s.NoError(sc.Err()) } type mockReader struct{} func (r *mockReader) Read([]byte) (int, error) { return 0, errors.New("foo") } -func (s *SuiteScanner) TestInternalReadError(c *C) { +func (s *SuiteScanner) TestInternalReadError() { sc := pktline.NewScanner(&mockReader{}) - c.Assert(sc.Scan(), Equals, false) - c.Assert(sc.Err(), ErrorMatches, "foo") + s.False(sc.Scan()) + s.ErrorContains(sc.Err(), "foo") } // A section are several non flush-pkt lines followed by a flush-pkt, which // how the git protocol sends long messages. -func (s *SuiteScanner) TestReadSomeSections(c *C) { +func (s *SuiteScanner) TestReadSomeSections() { nSections := 2 nLines := 4 - data := sectionsExample(c, nSections, nLines) + data, err := sectionsExample(nSections, nLines) + s.NoError(err) sc := pktline.NewScanner(data) sectionCounter := 0 lineCounter := 0 for sc.Scan() { - if len(sc.Bytes()) == 0 { + if sc.Len() == pktline.Flush { sectionCounter++ } lineCounter++ } - c.Assert(sc.Err(), IsNil) - c.Assert(sectionCounter, Equals, nSections) - c.Assert(lineCounter, Equals, (1+nLines)*nSections) -} - -// returns nSection sections, each of them with nLines pkt-lines (not -// counting the flush-pkt: -// -// 0009 0.0\n -// 0009 0.1\n -// ... -// 0000 -// and so on -func sectionsExample(c *C, nSections, nLines int) io.Reader { - var buf bytes.Buffer - e := pktline.NewEncoder(&buf) - - for section := 0; section < nSections; section++ { - ss := []string{} - for line := 0; line < nLines; line++ { - line := fmt.Sprintf(" %d.%d\n", section, line) - ss = append(ss, line) - } - err := e.EncodeString(ss...) - c.Assert(err, IsNil) - err = e.Flush() - c.Assert(err, IsNil) - } - - return &buf + s.NoError(sc.Err()) + s.Equal(nSections, sectionCounter) + s.Equal((1+nLines)*nSections, lineCounter) } diff --git a/plumbing/format/pktline/sync.go b/plumbing/format/pktline/sync.go new file mode 100644 index 000000000..55fe7db3e --- /dev/null +++ b/plumbing/format/pktline/sync.go @@ -0,0 +1,25 @@ +package pktline + +import "sync" + +var pktBuffer = sync.Pool{ + New: func() interface{} { + var b [MaxSize]byte + return &b + }, +} + +// GetBuffer returns a *[MaxSize]byte that is managed by a sync.Pool. The +// initial slice length will be 65520 (65kb). +// +// After use, the *[MaxSize]byte should be put back into the sync.Pool by +// calling PutBuffer. +func GetBuffer() *[MaxSize]byte { + buf := pktBuffer.Get().(*[MaxSize]byte) + return buf +} + +// PutBuffer puts buf back into its sync.Pool. +func PutBuffer(buf *[MaxSize]byte) { + pktBuffer.Put(buf) +} diff --git a/plumbing/hash.go b/plumbing/hash.go index 39bb73fbb..1af39d4ae 100644 --- a/plumbing/hash.go +++ b/plumbing/hash.go @@ -6,7 +6,7 @@ import ( "sort" "strconv" - "github.com/go-git/go-git/v5/plumbing/hash" + "github.com/jesseduffield/go-git/v5/plumbing/hash" ) // Hash SHA1 hashed content @@ -47,11 +47,16 @@ type Hasher struct { func NewHasher(t ObjectType, size int64) Hasher { h := Hasher{hash.New(hash.CryptoType)} + h.Reset(t, size) + return h +} + +func (h Hasher) Reset(t ObjectType, size int64) { + h.Hash.Reset() h.Write(t.Bytes()) h.Write([]byte(" ")) h.Write([]byte(strconv.FormatInt(size, 10))) h.Write([]byte{0}) - return h } func (h Hasher) Sum() (hash Hash) { diff --git a/plumbing/hash256.go b/plumbing/hash256.go new file mode 100644 index 000000000..108c8a985 --- /dev/null +++ b/plumbing/hash256.go @@ -0,0 +1,64 @@ +package plumbing + +import ( + "crypto" + "encoding/hex" + "strconv" + + "github.com/jesseduffield/go-git/v5/plumbing/hash" +) + +// NewHash return a new Hash256 from a hexadecimal hash representation. +func NewHash256(s string) Hash256 { + b, _ := hex.DecodeString(s) + + var h Hash256 + copy(h[:], b) + + return h +} + +// Hash256 represents SHA256 hashed content. +type Hash256 [32]byte + +// ZeroHash is Hash256 with value zero. +var ZeroHash256 Hash256 + +func (h Hash256) IsZero() bool { + var empty Hash256 + return h == empty +} + +func (h Hash256) String() string { + return hex.EncodeToString(h[:]) +} + +// ComputeHash compute the hash for a given ObjectType and content. +func ComputeHash256(t ObjectType, content []byte) Hash256 { + h := NewHasher256(t, int64(len(content))) + h.Write(content) + return h.Sum() +} + +type Hasher256 struct { + hash.Hash +} + +func NewHasher256(t ObjectType, size int64) Hasher256 { + h := Hasher256{hash.New(crypto.SHA256)} + h.Reset(t, size) + return h +} + +func (h Hasher256) Reset(t ObjectType, size int64) { + h.Hash.Reset() + h.Write(t.Bytes()) + h.Write([]byte(" ")) + h.Write([]byte(strconv.FormatInt(size, 10))) + h.Write([]byte{0}) +} + +func (h Hasher256) Sum() (hash Hash256) { + copy(hash[:], h.Hash.Sum(nil)) + return +} diff --git a/plumbing/hash_test.go b/plumbing/hash_test.go index 0f836b0b6..243c50ca5 100644 --- a/plumbing/hash_test.go +++ b/plumbing/hash_test.go @@ -3,45 +3,47 @@ package plumbing import ( "testing" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } - -type HashSuite struct{} +type HashSuite struct { + suite.Suite +} -var _ = Suite(&HashSuite{}) +func TestHashSuite(t *testing.T) { + suite.Run(t, new(HashSuite)) +} -func (s *HashSuite) TestComputeHash(c *C) { +func (s *HashSuite) TestComputeHash() { hash := ComputeHash(BlobObject, []byte("")) - c.Assert(hash.String(), Equals, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391") + s.Equal("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", hash.String()) hash = ComputeHash(BlobObject, []byte("Hello, World!\n")) - c.Assert(hash.String(), Equals, "8ab686eafeb1f44702738c8b0f24f2567c36da6d") + s.Equal("8ab686eafeb1f44702738c8b0f24f2567c36da6d", hash.String()) } -func (s *HashSuite) TestNewHash(c *C) { +func (s *HashSuite) TestNewHash() { hash := ComputeHash(BlobObject, []byte("Hello, World!\n")) - c.Assert(hash, Equals, NewHash(hash.String())) + s.Equal(NewHash(hash.String()), hash) } -func (s *HashSuite) TestIsZero(c *C) { +func (s *HashSuite) TestIsZero() { hash := NewHash("foo") - c.Assert(hash.IsZero(), Equals, true) + s.True(hash.IsZero()) hash = NewHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d") - c.Assert(hash.IsZero(), Equals, false) + s.False(hash.IsZero()) } -func (s *HashSuite) TestNewHasher(c *C) { +func (s *HashSuite) TestNewHasher() { content := "hasher test sample" hasher := NewHasher(BlobObject, int64(len(content))) hasher.Write([]byte(content)) - c.Assert(hasher.Sum().String(), Equals, "dc42c3cc80028d0ec61f0a6b24cadd1c195c4dfc") + s.Equal("dc42c3cc80028d0ec61f0a6b24cadd1c195c4dfc", hasher.Sum().String()) } -func (s *HashSuite) TestHashesSort(c *C) { +func (s *HashSuite) TestHashesSort() { i := []Hash{ NewHash("2222222222222222222222222222222222222222"), NewHash("1111111111111111111111111111111111111111"), @@ -49,12 +51,12 @@ func (s *HashSuite) TestHashesSort(c *C) { HashesSort(i) - c.Assert(i[0], Equals, NewHash("1111111111111111111111111111111111111111")) - c.Assert(i[1], Equals, NewHash("2222222222222222222222222222222222222222")) + s.Equal(NewHash("1111111111111111111111111111111111111111"), i[0]) + s.Equal(NewHash("2222222222222222222222222222222222222222"), i[1]) } -func (s *HashSuite) TestIsHash(c *C) { - c.Assert(IsHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d"), Equals, true) - c.Assert(IsHash("foo"), Equals, false) - c.Assert(IsHash("zab686eafeb1f44702738c8b0f24f2567c36da6d"), Equals, false) +func (s *HashSuite) TestIsHash() { + s.True(IsHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d")) + s.False(IsHash("foo")) + s.False(IsHash("zab686eafeb1f44702738c8b0f24f2567c36da6d")) } diff --git a/plumbing/memory.go b/plumbing/memory.go index 6d11271dd..a94cc34c6 100644 --- a/plumbing/memory.go +++ b/plumbing/memory.go @@ -36,7 +36,9 @@ func (o *MemoryObject) Size() int64 { return o.sz } // SetSize set the object size, a content of the given size should be written // afterwards -func (o *MemoryObject) SetSize(s int64) { o.sz = s } +func (o *MemoryObject) SetSize(s int64) { + o.sz = s +} // Reader returns an io.ReadCloser used to read the object's content. // diff --git a/plumbing/memory_test.go b/plumbing/memory_test.go index f76b4f40f..4f0c3f23e 100644 --- a/plumbing/memory_test.go +++ b/plumbing/memory_test.go @@ -2,61 +2,66 @@ package plumbing import ( "io" + "testing" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) -type MemoryObjectSuite struct{} +type MemoryObjectSuite struct { + suite.Suite +} -var _ = Suite(&MemoryObjectSuite{}) +func TestMemoryObjectSuite(t *testing.T) { + suite.Run(t, new(MemoryObjectSuite)) +} -func (s *MemoryObjectSuite) TestHash(c *C) { +func (s *MemoryObjectSuite) TestHash() { o := &MemoryObject{} o.SetType(BlobObject) o.SetSize(14) _, err := o.Write([]byte("Hello, World!\n")) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(o.Hash().String(), Equals, "8ab686eafeb1f44702738c8b0f24f2567c36da6d") + s.Equal("8ab686eafeb1f44702738c8b0f24f2567c36da6d", o.Hash().String()) o.SetType(CommitObject) - c.Assert(o.Hash().String(), Equals, "8ab686eafeb1f44702738c8b0f24f2567c36da6d") + s.Equal("8ab686eafeb1f44702738c8b0f24f2567c36da6d", o.Hash().String()) } -func (s *MemoryObjectSuite) TestHashNotFilled(c *C) { +func (s *MemoryObjectSuite) TestHashNotFilled() { o := &MemoryObject{} o.SetType(BlobObject) o.SetSize(14) - c.Assert(o.Hash(), Equals, ZeroHash) + s.Equal(ZeroHash, o.Hash()) } -func (s *MemoryObjectSuite) TestType(c *C) { +func (s *MemoryObjectSuite) TestType() { o := &MemoryObject{} o.SetType(BlobObject) - c.Assert(o.Type(), Equals, BlobObject) + s.Equal(BlobObject, o.Type()) } -func (s *MemoryObjectSuite) TestSize(c *C) { +func (s *MemoryObjectSuite) TestSize() { o := &MemoryObject{} o.SetSize(42) - c.Assert(o.Size(), Equals, int64(42)) + s.Equal(int64(42), o.Size()) } -func (s *MemoryObjectSuite) TestReader(c *C) { +func (s *MemoryObjectSuite) TestReader() { o := &MemoryObject{cont: []byte("foo")} reader, err := o.Reader() - c.Assert(err, IsNil) - defer func() { c.Assert(reader.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(reader.Close()) }() b, err := io.ReadAll(reader) - c.Assert(err, IsNil) - c.Assert(b, DeepEquals, []byte("foo")) + s.NoError(err) + s.Equal([]byte("foo"), b) } -func (s *MemoryObjectSuite) TestSeekableReader(c *C) { +func (s *MemoryObjectSuite) TestSeekableReader() { const pageSize = 4096 const payload = "foo" content := make([]byte, pageSize+len(payload)) @@ -65,34 +70,34 @@ func (s *MemoryObjectSuite) TestSeekableReader(c *C) { o := &MemoryObject{cont: content} reader, err := o.Reader() - c.Assert(err, IsNil) - defer func() { c.Assert(reader.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(reader.Close()) }() rs, ok := reader.(io.ReadSeeker) - c.Assert(ok, Equals, true) + s.True(ok) _, err = rs.Seek(pageSize, io.SeekStart) - c.Assert(err, IsNil) + s.NoError(err) b, err := io.ReadAll(rs) - c.Assert(err, IsNil) - c.Assert(b, DeepEquals, []byte(payload)) + s.NoError(err) + s.Equal([]byte(payload), b) // Check that our Reader isn't also accidentally writable _, ok = reader.(io.WriteSeeker) - c.Assert(ok, Equals, false) + s.False(ok) } -func (s *MemoryObjectSuite) TestWriter(c *C) { +func (s *MemoryObjectSuite) TestWriter() { o := &MemoryObject{} writer, err := o.Writer() - c.Assert(err, IsNil) - defer func() { c.Assert(writer.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(writer.Close()) }() n, err := writer.Write([]byte("foo")) - c.Assert(err, IsNil) - c.Assert(n, Equals, 3) + s.NoError(err) + s.Equal(3, n) - c.Assert(o.cont, DeepEquals, []byte("foo")) + s.Equal([]byte("foo"), o.cont) } diff --git a/plumbing/object/blob.go b/plumbing/object/blob.go index 8fb7576fa..7bce28e80 100644 --- a/plumbing/object/blob.go +++ b/plumbing/object/blob.go @@ -3,9 +3,9 @@ package object import ( "io" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/utils/ioutil" ) // Blob is used to store arbitrary data - it is generally a file. diff --git a/plumbing/object/blob_test.go b/plumbing/object/blob_test.go index 9481dbe44..b40eac5f0 100644 --- a/plumbing/object/blob_test.go +++ b/plumbing/object/blob_test.go @@ -3,45 +3,52 @@ package object import ( "bytes" "io" + "testing" - "github.com/go-git/go-git/v5/plumbing" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/stretchr/testify/suite" ) type BlobsSuite struct { + suite.Suite BaseObjectsSuite } -var _ = Suite(&BlobsSuite{}) +func TestBlobsSuite(t *testing.T) { + suite.Run(t, new(BlobsSuite)) +} + +func (s *BlobsSuite) SetupSuite() { + s.BaseObjectsSuite.SetupSuite(s.T()) +} -func (s *BlobsSuite) TestBlobHash(c *C) { +func (s *BlobsSuite) TestBlobHash() { o := &plumbing.MemoryObject{} o.SetType(plumbing.BlobObject) o.SetSize(3) writer, err := o.Writer() - c.Assert(err, IsNil) - defer func() { c.Assert(writer.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(writer.Close()) }() writer.Write([]byte{'F', 'O', 'O'}) blob := &Blob{} - c.Assert(blob.Decode(o), IsNil) + s.Nil(blob.Decode(o)) - c.Assert(blob.Size, Equals, int64(3)) - c.Assert(blob.Hash.String(), Equals, "d96c7efbfec2814ae0301ad054dc8d9fc416c9b5") + s.Equal(int64(3), blob.Size) + s.Equal("d96c7efbfec2814ae0301ad054dc8d9fc416c9b5", blob.Hash.String()) reader, err := blob.Reader() - c.Assert(err, IsNil) - defer func() { c.Assert(reader.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(reader.Close()) }() data, err := io.ReadAll(reader) - c.Assert(err, IsNil) - c.Assert(string(data), Equals, "FOO") + s.NoError(err) + s.Equal("FOO", string(data)) } -func (s *BlobsSuite) TestBlobDecodeEncodeIdempotent(c *C) { +func (s *BlobsSuite) TestBlobDecodeEncodeIdempotent() { var objects []*plumbing.MemoryObject for _, str := range []string{"foo", "foo\n"} { obj := &plumbing.MemoryObject{} @@ -53,18 +60,18 @@ func (s *BlobsSuite) TestBlobDecodeEncodeIdempotent(c *C) { for _, object := range objects { blob := &Blob{} err := blob.Decode(object) - c.Assert(err, IsNil) + s.NoError(err) newObject := &plumbing.MemoryObject{} err = blob.Encode(newObject) - c.Assert(err, IsNil) + s.NoError(err) newObject.Hash() // Ensure Hash is pre-computed before deep comparison - c.Assert(newObject, DeepEquals, object) + s.Equal(object, newObject) } } -func (s *BlobsSuite) TestBlobIter(c *C) { +func (s *BlobsSuite) TestBlobIter() { encIter, err := s.Storer.IterEncodedObjects(plumbing.BlobObject) - c.Assert(err, IsNil) + s.NoError(err) iter := NewBlobIter(s.Storer, encIter) blobs := []*Blob{} @@ -73,11 +80,11 @@ func (s *BlobsSuite) TestBlobIter(c *C) { return nil }) - c.Assert(len(blobs) > 0, Equals, true) + s.True(len(blobs) > 0) iter.Close() encIter, err = s.Storer.IterEncodedObjects(plumbing.BlobObject) - c.Assert(err, IsNil) + s.NoError(err) iter = NewBlobIter(s.Storer, encIter) i := 0 @@ -87,26 +94,26 @@ func (s *BlobsSuite) TestBlobIter(c *C) { break } - c.Assert(err, IsNil) - c.Assert(b.ID(), Equals, blobs[i].ID()) - c.Assert(b.Size, Equals, blobs[i].Size) - c.Assert(b.Type(), Equals, blobs[i].Type()) + s.NoError(err) + s.Equal(blobs[i].ID(), b.ID()) + s.Equal(blobs[i].Size, b.Size) + s.Equal(blobs[i].Type(), b.Type()) r1, err := b.Reader() - c.Assert(err, IsNil) + s.NoError(err) b1, err := io.ReadAll(r1) - c.Assert(err, IsNil) - c.Assert(r1.Close(), IsNil) + s.NoError(err) + s.Nil(r1.Close()) r2, err := blobs[i].Reader() - c.Assert(err, IsNil) + s.NoError(err) b2, err := io.ReadAll(r2) - c.Assert(err, IsNil) - c.Assert(r2.Close(), IsNil) + s.NoError(err) + s.Nil(r2.Close()) - c.Assert(bytes.Compare(b1, b2), Equals, 0) + s.Equal(0, bytes.Compare(b1, b2)) i++ } diff --git a/plumbing/object/change.go b/plumbing/object/change.go index 3c619df86..5d33eda12 100644 --- a/plumbing/object/change.go +++ b/plumbing/object/change.go @@ -6,7 +6,7 @@ import ( "fmt" "strings" - "github.com/go-git/go-git/v5/utils/merkletrie" + "github.com/jesseduffield/go-git/v5/utils/merkletrie" ) // Change values represent a detected change between two git trees. For diff --git a/plumbing/object/change_adaptor.go b/plumbing/object/change_adaptor.go index b96ee84d9..c47894994 100644 --- a/plumbing/object/change_adaptor.go +++ b/plumbing/object/change_adaptor.go @@ -4,8 +4,8 @@ import ( "errors" "fmt" - "github.com/go-git/go-git/v5/utils/merkletrie" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" + "github.com/jesseduffield/go-git/v5/utils/merkletrie" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" ) // The following functions transform changes types form the merkletrie diff --git a/plumbing/object/change_adaptor_test.go b/plumbing/object/change_adaptor_test.go index b8dd5d115..a1d62503f 100644 --- a/plumbing/object/change_adaptor_test.go +++ b/plumbing/object/change_adaptor_test.go @@ -2,38 +2,46 @@ package object import ( "sort" + "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/filemode" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage/filesystem" - "github.com/go-git/go-git/v5/utils/merkletrie" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/utils/merkletrie" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) -type ChangeAdaptorSuite struct { +type ChangeAdaptorFixtureSuite struct { fixtures.Suite +} + +type ChangeAdaptorSuite struct { + suite.Suite + ChangeAdaptorFixtureSuite Storer storer.EncodedObjectStorer Fixture *fixtures.Fixture } -func (s *ChangeAdaptorSuite) SetUpSuite(c *C) { +func (s *ChangeAdaptorSuite) SetupSuite() { s.Fixture = fixtures.Basic().One() sto := filesystem.NewStorage(s.Fixture.DotGit(), cache.NewObjectLRUDefault()) s.Storer = sto } -func (s *ChangeAdaptorSuite) tree(c *C, h plumbing.Hash) *Tree { +func (s *ChangeAdaptorSuite) tree(h plumbing.Hash) *Tree { t, err := GetTree(s.Storer, h) - c.Assert(err, IsNil) + s.NoError(err) return t } -var _ = Suite(&ChangeAdaptorSuite{}) +func TestChangeAdaptorSuite(t *testing.T) { + suite.Run(t, new(ChangeAdaptorSuite)) +} // utility function to build Noders from a tree and an tree entry. func newNoder(t *Tree, e TreeEntry) noder.Noder { @@ -48,7 +56,7 @@ func newNoder(t *Tree, e TreeEntry) noder.Noder { // utility function to build Paths func newPath(nn ...noder.Noder) noder.Path { return noder.Path(nn) } -func (s *ChangeAdaptorSuite) TestTreeNoderHashHasMode(c *C) { +func (s *ChangeAdaptorSuite) TestTreeNoderHashHasMode() { hash := plumbing.NewHash("aaaa") mode := filemode.Regular @@ -66,10 +74,10 @@ func (s *ChangeAdaptorSuite) TestTreeNoderHashHasMode(c *C) { } expected = append(expected, filemode.Regular.Bytes()...) - c.Assert(treeNoder.Hash(), DeepEquals, expected) + s.Equal(expected, treeNoder.Hash()) } -func (s *ChangeAdaptorSuite) TestNewChangeInsert(c *C) { +func (s *ChangeAdaptorSuite) TestNewChangeInsert() { tree := &Tree{} entry := TreeEntry{ Name: "name", @@ -79,7 +87,7 @@ func (s *ChangeAdaptorSuite) TestNewChangeInsert(c *C) { path := newPath(newNoder(tree, entry)) expectedTo, err := newChangeEntry(path) - c.Assert(err, IsNil) + s.NoError(err) src := merkletrie.Change{ From: nil, @@ -87,15 +95,15 @@ func (s *ChangeAdaptorSuite) TestNewChangeInsert(c *C) { } obtained, err := newChange(src) - c.Assert(err, IsNil) + s.NoError(err) action, err := obtained.Action() - c.Assert(err, IsNil) - c.Assert(action, Equals, merkletrie.Insert) - c.Assert(obtained.From, Equals, ChangeEntry{}) - c.Assert(obtained.To, Equals, expectedTo) + s.NoError(err) + s.Equal(merkletrie.Insert, action) + s.Equal(ChangeEntry{}, obtained.From) + s.Equal(expectedTo, obtained.To) } -func (s *ChangeAdaptorSuite) TestNewChangeDelete(c *C) { +func (s *ChangeAdaptorSuite) TestNewChangeDelete() { tree := &Tree{} entry := TreeEntry{ Name: "name", @@ -105,7 +113,7 @@ func (s *ChangeAdaptorSuite) TestNewChangeDelete(c *C) { path := newPath(newNoder(tree, entry)) expectedFrom, err := newChangeEntry(path) - c.Assert(err, IsNil) + s.NoError(err) src := merkletrie.Change{ From: path, @@ -113,15 +121,15 @@ func (s *ChangeAdaptorSuite) TestNewChangeDelete(c *C) { } obtained, err := newChange(src) - c.Assert(err, IsNil) + s.NoError(err) action, err := obtained.Action() - c.Assert(err, IsNil) - c.Assert(action, Equals, merkletrie.Delete) - c.Assert(obtained.From, Equals, expectedFrom) - c.Assert(obtained.To, Equals, ChangeEntry{}) + s.NoError(err) + s.Equal(merkletrie.Delete, action) + s.Equal(expectedFrom, obtained.From) + s.Equal(ChangeEntry{}, obtained.To) } -func (s *ChangeAdaptorSuite) TestNewChangeModify(c *C) { +func (s *ChangeAdaptorSuite) TestNewChangeModify() { treeA := &Tree{} entryA := TreeEntry{ Name: "name", @@ -130,7 +138,7 @@ func (s *ChangeAdaptorSuite) TestNewChangeModify(c *C) { } pathA := newPath(newNoder(treeA, entryA)) expectedFrom, err := newChangeEntry(pathA) - c.Assert(err, IsNil) + s.NoError(err) treeB := &Tree{} entryB := TreeEntry{ @@ -140,7 +148,7 @@ func (s *ChangeAdaptorSuite) TestNewChangeModify(c *C) { } pathB := newPath(newNoder(treeB, entryB)) expectedTo, err := newChangeEntry(pathB) - c.Assert(err, IsNil) + s.NoError(err) src := merkletrie.Change{ From: pathA, @@ -148,67 +156,67 @@ func (s *ChangeAdaptorSuite) TestNewChangeModify(c *C) { } obtained, err := newChange(src) - c.Assert(err, IsNil) + s.NoError(err) action, err := obtained.Action() - c.Assert(err, IsNil) - c.Assert(action, Equals, merkletrie.Modify) - c.Assert(obtained.From, Equals, expectedFrom) - c.Assert(obtained.To, Equals, expectedTo) + s.NoError(err) + s.Equal(merkletrie.Modify, action) + s.Equal(expectedFrom, obtained.From) + s.Equal(expectedTo, obtained.To) } -func (s *ChangeAdaptorSuite) TestEmptyChangeFails(c *C) { +func (s *ChangeAdaptorSuite) TestEmptyChangeFails() { change := &Change{ From: empty, To: empty, } _, err := change.Action() - c.Assert(err, ErrorMatches, "malformed change.*") + s.ErrorContains(err, "malformed change") _, _, err = change.Files() - c.Assert(err, ErrorMatches, "malformed change.*") + s.ErrorContains(err, "malformed change") str := change.String() - c.Assert(str, Equals, "malformed change") + s.Equal("malformed change", str) } type noderMock struct{ noder.Noder } -func (s *ChangeAdaptorSuite) TestNewChangeFailsWithChangesFromOtherNoders(c *C) { +func (s *ChangeAdaptorSuite) TestNewChangeFailsWithChangesFromOtherNoders() { src := merkletrie.Change{ From: newPath(noderMock{}), To: nil, } _, err := newChange(src) - c.Assert(err, Not(IsNil)) + s.Error(err) src = merkletrie.Change{ From: nil, To: newPath(noderMock{}), } _, err = newChange(src) - c.Assert(err, Not(IsNil)) + s.Error(err) } -func (s *ChangeAdaptorSuite) TestChangeStringFrom(c *C) { +func (s *ChangeAdaptorSuite) TestChangeStringFrom() { expected := "" change := Change{} change.From.Name = "foo" obtained := change.String() - c.Assert(obtained, Equals, expected) + s.Equal(expected, obtained) } -func (s *ChangeAdaptorSuite) TestChangeStringTo(c *C) { +func (s *ChangeAdaptorSuite) TestChangeStringTo() { expected := "" change := Change{} change.To.Name = "foo" obtained := change.String() - c.Assert(obtained, Equals, expected) + s.Equal(expected, obtained) } -func (s *ChangeAdaptorSuite) TestChangeFilesInsert(c *C) { - tree := s.tree(c, plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")) +func (s *ChangeAdaptorSuite) TestChangeFilesInsert() { + tree := s.tree(plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")) change := Change{} change.To.Name = "json/long.json" @@ -217,13 +225,13 @@ func (s *ChangeAdaptorSuite) TestChangeFilesInsert(c *C) { change.To.TreeEntry.Hash = plumbing.NewHash("49c6bb89b17060d7b4deacb7b338fcc6ea2352a9") from, to, err := change.Files() - c.Assert(err, IsNil) - c.Assert(from, IsNil) - c.Assert(to.ID(), Equals, change.To.TreeEntry.Hash) + s.NoError(err) + s.Nil(from) + s.Equal(change.To.TreeEntry.Hash, to.ID()) } -func (s *ChangeAdaptorSuite) TestChangeFilesInsertNotFound(c *C) { - tree := s.tree(c, plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")) +func (s *ChangeAdaptorSuite) TestChangeFilesInsertNotFound() { + tree := s.tree(plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")) change := Change{} change.To.Name = "json/long.json" @@ -233,11 +241,11 @@ func (s *ChangeAdaptorSuite) TestChangeFilesInsertNotFound(c *C) { change.To.TreeEntry.Hash = plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") _, _, err := change.Files() - c.Assert(err, Not(IsNil)) + s.Error(err) } -func (s *ChangeAdaptorSuite) TestChangeFilesDelete(c *C) { - tree := s.tree(c, plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")) +func (s *ChangeAdaptorSuite) TestChangeFilesDelete() { + tree := s.tree(plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")) change := Change{} change.From.Name = "json/long.json" @@ -246,13 +254,13 @@ func (s *ChangeAdaptorSuite) TestChangeFilesDelete(c *C) { change.From.TreeEntry.Hash = plumbing.NewHash("49c6bb89b17060d7b4deacb7b338fcc6ea2352a9") from, to, err := change.Files() - c.Assert(err, IsNil) - c.Assert(to, IsNil) - c.Assert(from.ID(), Equals, change.From.TreeEntry.Hash) + s.NoError(err) + s.Nil(to) + s.Equal(change.From.TreeEntry.Hash, from.ID()) } -func (s *ChangeAdaptorSuite) TestChangeFilesDeleteNotFound(c *C) { - tree := s.tree(c, plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")) +func (s *ChangeAdaptorSuite) TestChangeFilesDeleteNotFound() { + tree := s.tree(plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")) change := Change{} change.From.Name = "json/long.json" @@ -262,11 +270,11 @@ func (s *ChangeAdaptorSuite) TestChangeFilesDeleteNotFound(c *C) { change.From.TreeEntry.Hash = plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") _, _, err := change.Files() - c.Assert(err, Not(IsNil)) + s.Error(err) } -func (s *ChangeAdaptorSuite) TestChangeFilesModify(c *C) { - tree := s.tree(c, plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")) +func (s *ChangeAdaptorSuite) TestChangeFilesModify() { + tree := s.tree(plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")) change := Change{} change.To.Name = "json/long.json" @@ -279,24 +287,24 @@ func (s *ChangeAdaptorSuite) TestChangeFilesModify(c *C) { change.From.TreeEntry.Hash = plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492") from, to, err := change.Files() - c.Assert(err, IsNil) - c.Assert(to.ID(), Equals, change.To.TreeEntry.Hash) - c.Assert(from.ID(), Equals, change.From.TreeEntry.Hash) + s.NoError(err) + s.Equal(change.To.TreeEntry.Hash, to.ID()) + s.Equal(change.From.TreeEntry.Hash, from.ID()) } -func (s *ChangeAdaptorSuite) TestChangeEntryFailsWithOtherNoders(c *C) { +func (s *ChangeAdaptorSuite) TestChangeEntryFailsWithOtherNoders() { path := noder.Path{noderMock{}} _, err := newChangeEntry(path) - c.Assert(err, Not(IsNil)) + s.Error(err) } -func (s *ChangeAdaptorSuite) TestChangeEntryFromNilIsZero(c *C) { +func (s *ChangeAdaptorSuite) TestChangeEntryFromNilIsZero() { obtained, err := newChangeEntry(nil) - c.Assert(err, IsNil) - c.Assert(obtained, Equals, ChangeEntry{}) + s.NoError(err) + s.Equal(ChangeEntry{}, obtained) } -func (s *ChangeAdaptorSuite) TestChangeEntryFromSortPath(c *C) { +func (s *ChangeAdaptorSuite) TestChangeEntryFromSortPath() { tree := &Tree{} entry := TreeEntry{ Name: "name", @@ -306,14 +314,14 @@ func (s *ChangeAdaptorSuite) TestChangeEntryFromSortPath(c *C) { path := newPath(newNoder(tree, entry)) obtained, err := newChangeEntry(path) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(obtained.Name, Equals, entry.Name) - c.Assert(obtained.Tree, Equals, tree) - c.Assert(obtained.TreeEntry, DeepEquals, entry) + s.Equal(entry.Name, obtained.Name) + s.Equal(tree, obtained.Tree) + s.Equal(entry, obtained.TreeEntry) } -func (s *ChangeAdaptorSuite) TestChangeEntryFromLongPath(c *C) { +func (s *ChangeAdaptorSuite) TestChangeEntryFromLongPath() { treeA := &Tree{} entryA := TreeEntry{ Name: "nameA", @@ -334,28 +342,28 @@ func (s *ChangeAdaptorSuite) TestChangeEntryFromLongPath(c *C) { ) obtained, err := newChangeEntry(path) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(obtained.Name, Equals, entryA.Name+"/"+entryB.Name) - c.Assert(obtained.Tree, Equals, treeB) - c.Assert(obtained.TreeEntry, Equals, entryB) + s.Equal(entryA.Name+"/"+entryB.Name, obtained.Name) + s.Equal(treeB, obtained.Tree) + s.Equal(entryB, obtained.TreeEntry) } -func (s *ChangeAdaptorSuite) TestNewChangesEmpty(c *C) { +func (s *ChangeAdaptorSuite) TestNewChangesEmpty() { expected := "[]" changes, err := newChanges(nil) - c.Assert(err, IsNil) + s.NoError(err) obtained := changes.String() - c.Assert(obtained, Equals, expected) + s.Equal(expected, obtained) expected = "[]" changes, err = newChanges(merkletrie.Changes{}) - c.Assert(err, IsNil) + s.NoError(err) obtained = changes.String() - c.Assert(obtained, Equals, expected) + s.Equal(expected, obtained) } -func (s *ChangeAdaptorSuite) TestNewChanges(c *C) { +func (s *ChangeAdaptorSuite) TestNewChanges() { treeA := &Tree{} entryA := TreeEntry{Name: "nameA"} pathA := newPath(newNoder(treeA, entryA)) @@ -374,19 +382,19 @@ func (s *ChangeAdaptorSuite) TestNewChanges(c *C) { src := merkletrie.Changes{changeA, changeB} changes, err := newChanges(src) - c.Assert(err, IsNil) - c.Assert(len(changes), Equals, 2) + s.NoError(err) + s.Len(changes, 2) action, err := changes[0].Action() - c.Assert(err, IsNil) - c.Assert(action, Equals, merkletrie.Insert) - c.Assert(changes[0].To.Name, Equals, "nameA") + s.NoError(err) + s.Equal(merkletrie.Insert, action) + s.Equal("nameA", changes[0].To.Name) action, err = changes[1].Action() - c.Assert(err, IsNil) - c.Assert(action, Equals, merkletrie.Delete) - c.Assert(changes[1].From.Name, Equals, "nameB") + s.NoError(err) + s.Equal(merkletrie.Delete, action) + s.Equal("nameB", changes[1].From.Name) } -func (s *ChangeAdaptorSuite) TestNewChangesFailsWithOtherNoders(c *C) { +func (s *ChangeAdaptorSuite) TestNewChangesFailsWithOtherNoders() { change := merkletrie.Change{ From: nil, To: newPath(noderMock{}), @@ -394,10 +402,10 @@ func (s *ChangeAdaptorSuite) TestNewChangesFailsWithOtherNoders(c *C) { src := merkletrie.Changes{change} _, err := newChanges(src) - c.Assert(err, Not(IsNil)) + s.Error(err) } -func (s *ChangeAdaptorSuite) TestSortChanges(c *C) { +func (s *ChangeAdaptorSuite) TestSortChanges() { c1 := &Change{} c1.To.Name = "1" @@ -411,7 +419,7 @@ func (s *ChangeAdaptorSuite) TestSortChanges(c *C) { changes := Changes{c3, c1, c2} sort.Sort(changes) - c.Assert(changes[0].String(), Equals, "") - c.Assert(changes[1].String(), Equals, "") - c.Assert(changes[2].String(), Equals, "") + s.Equal("", changes[0].String()) + s.Equal("", changes[1].String()) + s.Equal("", changes[2].String()) } diff --git a/plumbing/object/change_test.go b/plumbing/object/change_test.go index 0e97e4d62..b16144e1b 100644 --- a/plumbing/object/change_test.go +++ b/plumbing/object/change_test.go @@ -3,41 +3,48 @@ package object import ( "context" "sort" + "testing" fixtures "github.com/go-git/go-git-fixtures/v4" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/filemode" - "github.com/go-git/go-git/v5/plumbing/format/diff" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage/filesystem" - "github.com/go-git/go-git/v5/utils/merkletrie" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/plumbing/format/diff" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/utils/merkletrie" + "github.com/stretchr/testify/suite" ) -type ChangeSuite struct { +type ChangeFixtureSuite struct { fixtures.Suite +} + +type ChangeSuite struct { + suite.Suite + ChangeFixtureSuite Storer storer.EncodedObjectStorer Fixture *fixtures.Fixture } -func (s *ChangeSuite) SetUpSuite(c *C) { +func (s *ChangeSuite) SetupSuite() { s.Fixture = fixtures.ByURL("https://github.com/src-d/go-git.git"). ByTag(".git").One() sto := filesystem.NewStorage(s.Fixture.DotGit(), cache.NewObjectLRUDefault()) s.Storer = sto } -func (s *ChangeSuite) tree(c *C, h plumbing.Hash) *Tree { +func (s *ChangeSuite) tree(h plumbing.Hash) *Tree { t, err := GetTree(s.Storer, h) - c.Assert(err, IsNil) + s.NoError(err) return t } -var _ = Suite(&ChangeSuite{}) +func TestChangeSuite(t *testing.T) { + suite.Run(t, new(ChangeSuite)) +} -func (s *ChangeSuite) TestInsert(c *C) { +func (s *ChangeSuite) TestInsert() { // Commit a5078b19f08f63e7948abd0a5e2fb7d319d3a565 of the go-git // fixture inserted "examples/clone/main.go". // @@ -57,7 +64,7 @@ func (s *ChangeSuite) TestInsert(c *C) { From: empty, To: ChangeEntry{ Name: path, - Tree: s.tree(c, tree), + Tree: s.tree(tree), TreeEntry: TreeEntry{ Name: name, Mode: mode, @@ -67,32 +74,32 @@ func (s *ChangeSuite) TestInsert(c *C) { } action, err := change.Action() - c.Assert(err, IsNil) - c.Assert(action, Equals, merkletrie.Insert) + s.NoError(err) + s.Equal(merkletrie.Insert, action) from, to, err := change.Files() - c.Assert(err, IsNil) - c.Assert(from, IsNil) - c.Assert(to.Name, Equals, name) - c.Assert(to.Blob.Hash, Equals, blob) + s.NoError(err) + s.Nil(from) + s.Equal(name, to.Name) + s.Equal(blob, to.Blob.Hash) p, err := change.Patch() - c.Assert(err, IsNil) - c.Assert(len(p.FilePatches()), Equals, 1) - c.Assert(len(p.FilePatches()[0].Chunks()), Equals, 1) - c.Assert(p.FilePatches()[0].Chunks()[0].Type(), Equals, diff.Add) + s.NoError(err) + s.Equal(1, len(p.FilePatches())) + s.Equal(1, len(p.FilePatches()[0].Chunks())) + s.Equal(diff.Add, p.FilePatches()[0].Chunks()[0].Type()) p, err = change.PatchContext(context.Background()) - c.Assert(err, IsNil) - c.Assert(len(p.FilePatches()), Equals, 1) - c.Assert(len(p.FilePatches()[0].Chunks()), Equals, 1) - c.Assert(p.FilePatches()[0].Chunks()[0].Type(), Equals, diff.Add) + s.NoError(err) + s.Equal(1, len(p.FilePatches())) + s.Equal(1, len(p.FilePatches()[0].Chunks())) + s.Equal(diff.Add, p.FilePatches()[0].Chunks()[0].Type()) str := change.String() - c.Assert(str, Equals, "") + s.Equal("", str) } -func (s *ChangeSuite) TestDelete(c *C) { +func (s *ChangeSuite) TestDelete() { // Commit f6011d65d57c2a866e231fc21a39cb618f86f9ea of the go-git // fixture deleted "utils/difftree/difftree.go". // @@ -114,7 +121,7 @@ func (s *ChangeSuite) TestDelete(c *C) { change := &Change{ From: ChangeEntry{ Name: path, - Tree: s.tree(c, tree), + Tree: s.tree(tree), TreeEntry: TreeEntry{ Name: name, Mode: mode, @@ -125,32 +132,32 @@ func (s *ChangeSuite) TestDelete(c *C) { } action, err := change.Action() - c.Assert(err, IsNil) - c.Assert(action, Equals, merkletrie.Delete) + s.NoError(err) + s.Equal(merkletrie.Delete, action) from, to, err := change.Files() - c.Assert(err, IsNil) - c.Assert(to, IsNil) - c.Assert(from.Name, Equals, name) - c.Assert(from.Blob.Hash, Equals, blob) + s.NoError(err) + s.Nil(to) + s.Equal(name, from.Name) + s.Equal(blob, from.Blob.Hash) p, err := change.Patch() - c.Assert(err, IsNil) - c.Assert(len(p.FilePatches()), Equals, 1) - c.Assert(len(p.FilePatches()[0].Chunks()), Equals, 1) - c.Assert(p.FilePatches()[0].Chunks()[0].Type(), Equals, diff.Delete) + s.NoError(err) + s.Equal(1, len(p.FilePatches())) + s.Equal(1, len(p.FilePatches()[0].Chunks())) + s.Equal(diff.Delete, p.FilePatches()[0].Chunks()[0].Type()) p, err = change.PatchContext(context.Background()) - c.Assert(err, IsNil) - c.Assert(len(p.FilePatches()), Equals, 1) - c.Assert(len(p.FilePatches()[0].Chunks()), Equals, 1) - c.Assert(p.FilePatches()[0].Chunks()[0].Type(), Equals, diff.Delete) + s.NoError(err) + s.Equal(1, len(p.FilePatches())) + s.Equal(1, len(p.FilePatches()[0].Chunks())) + s.Equal(diff.Delete, p.FilePatches()[0].Chunks()[0].Type()) str := change.String() - c.Assert(str, Equals, "") + s.Equal("", str) } -func (s *ChangeSuite) TestModify(c *C) { +func (s *ChangeSuite) TestModify() { // Commit 7beaad711378a4daafccc2c04bc46d36df2a0fd1 of the go-git // fixture modified "examples/latest/latest.go". // the "examples/latest" tree is @@ -176,7 +183,7 @@ func (s *ChangeSuite) TestModify(c *C) { change := &Change{ From: ChangeEntry{ Name: path, - Tree: s.tree(c, fromTree), + Tree: s.tree(fromTree), TreeEntry: TreeEntry{ Name: name, Mode: mode, @@ -185,7 +192,7 @@ func (s *ChangeSuite) TestModify(c *C) { }, To: ChangeEntry{ Name: path, - Tree: s.tree(c, toTree), + Tree: s.tree(toTree), TreeEntry: TreeEntry{ Name: name, Mode: mode, @@ -195,71 +202,71 @@ func (s *ChangeSuite) TestModify(c *C) { } action, err := change.Action() - c.Assert(err, IsNil) - c.Assert(action, Equals, merkletrie.Modify) + s.NoError(err) + s.Equal(merkletrie.Modify, action) from, to, err := change.Files() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(from.Name, Equals, name) - c.Assert(from.Blob.Hash, Equals, fromBlob) - c.Assert(to.Name, Equals, name) - c.Assert(to.Blob.Hash, Equals, toBlob) + s.Equal(name, from.Name) + s.Equal(fromBlob, from.Blob.Hash) + s.Equal(name, to.Name) + s.Equal(toBlob, to.Blob.Hash) p, err := change.Patch() - c.Assert(err, IsNil) - c.Assert(len(p.FilePatches()), Equals, 1) - c.Assert(len(p.FilePatches()[0].Chunks()), Equals, 7) - c.Assert(p.FilePatches()[0].Chunks()[0].Type(), Equals, diff.Equal) - c.Assert(p.FilePatches()[0].Chunks()[1].Type(), Equals, diff.Delete) - c.Assert(p.FilePatches()[0].Chunks()[2].Type(), Equals, diff.Add) - c.Assert(p.FilePatches()[0].Chunks()[3].Type(), Equals, diff.Equal) - c.Assert(p.FilePatches()[0].Chunks()[4].Type(), Equals, diff.Delete) - c.Assert(p.FilePatches()[0].Chunks()[5].Type(), Equals, diff.Add) - c.Assert(p.FilePatches()[0].Chunks()[6].Type(), Equals, diff.Equal) + s.NoError(err) + s.Equal(1, len(p.FilePatches())) + s.Equal(7, len(p.FilePatches()[0].Chunks())) + s.Equal(diff.Equal, p.FilePatches()[0].Chunks()[0].Type()) + s.Equal(diff.Delete, p.FilePatches()[0].Chunks()[1].Type()) + s.Equal(diff.Add, p.FilePatches()[0].Chunks()[2].Type()) + s.Equal(diff.Equal, p.FilePatches()[0].Chunks()[3].Type()) + s.Equal(diff.Delete, p.FilePatches()[0].Chunks()[4].Type()) + s.Equal(diff.Add, p.FilePatches()[0].Chunks()[5].Type()) + s.Equal(diff.Equal, p.FilePatches()[0].Chunks()[6].Type()) p, err = change.PatchContext(context.Background()) - c.Assert(err, IsNil) - c.Assert(len(p.FilePatches()), Equals, 1) - c.Assert(len(p.FilePatches()[0].Chunks()), Equals, 7) - c.Assert(p.FilePatches()[0].Chunks()[0].Type(), Equals, diff.Equal) - c.Assert(p.FilePatches()[0].Chunks()[1].Type(), Equals, diff.Delete) - c.Assert(p.FilePatches()[0].Chunks()[2].Type(), Equals, diff.Add) - c.Assert(p.FilePatches()[0].Chunks()[3].Type(), Equals, diff.Equal) - c.Assert(p.FilePatches()[0].Chunks()[4].Type(), Equals, diff.Delete) - c.Assert(p.FilePatches()[0].Chunks()[5].Type(), Equals, diff.Add) - c.Assert(p.FilePatches()[0].Chunks()[6].Type(), Equals, diff.Equal) + s.NoError(err) + s.Equal(1, len(p.FilePatches())) + s.Equal(7, len(p.FilePatches()[0].Chunks())) + s.Equal(diff.Equal, p.FilePatches()[0].Chunks()[0].Type()) + s.Equal(diff.Delete, p.FilePatches()[0].Chunks()[1].Type()) + s.Equal(diff.Add, p.FilePatches()[0].Chunks()[2].Type()) + s.Equal(diff.Equal, p.FilePatches()[0].Chunks()[3].Type()) + s.Equal(diff.Delete, p.FilePatches()[0].Chunks()[4].Type()) + s.Equal(diff.Add, p.FilePatches()[0].Chunks()[5].Type()) + s.Equal(diff.Equal, p.FilePatches()[0].Chunks()[6].Type()) str := change.String() - c.Assert(str, Equals, "") + s.Equal("", str) } -func (s *ChangeSuite) TestEmptyChangeFails(c *C) { +func (s *ChangeSuite) TestEmptyChangeFails() { change := &Change{} _, err := change.Action() - c.Assert(err, ErrorMatches, "malformed.*") + s.ErrorContains(err, "malformed") _, _, err = change.Files() - c.Assert(err, ErrorMatches, "malformed.*") + s.ErrorContains(err, "malformed") str := change.String() - c.Assert(str, Equals, "malformed change") + s.Equal("malformed change", str) } // test reproducing bug #317 -func (s *ChangeSuite) TestNoFileFilemodes(c *C) { +func (s *ChangeSuite) TestNoFileFilemodes() { f := fixtures.ByURL("https://github.com/git-fixtures/submodule.git").One() sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) iter, err := sto.IterEncodedObjects(plumbing.AnyObject) - c.Assert(err, IsNil) + s.NoError(err) var commits []*Commit iter.ForEach(func(o plumbing.EncodedObject) error { if o.Type() == plumbing.CommitObject { commit, err := GetCommit(sto, o.Hash()) - c.Assert(err, IsNil) + s.NoError(err) commits = append(commits, commit) } @@ -267,7 +274,7 @@ func (s *ChangeSuite) TestNoFileFilemodes(c *C) { return nil }) - c.Assert(len(commits), Not(Equals), 0) + s.NotEqual(0, len(commits)) var prev *Commit for _, commit := range commits { @@ -276,21 +283,21 @@ func (s *ChangeSuite) TestNoFileFilemodes(c *C) { continue } tree, err := commit.Tree() - c.Assert(err, IsNil) + s.NoError(err) prevTree, err := prev.Tree() - c.Assert(err, IsNil) + s.NoError(err) changes, err := DiffTree(tree, prevTree) - c.Assert(err, IsNil) + s.NoError(err) for _, change := range changes { _, _, err := change.Files() - c.Assert(err, IsNil) + s.NoError(err) } prev = commit } } -func (s *ChangeSuite) TestErrorsFindingChildsAreDetected(c *C) { +func (s *ChangeSuite) TestErrorsFindingChildsAreDetected() { // Commit 7beaad711378a4daafccc2c04bc46d36df2a0fd1 of the go-git // fixture modified "examples/latest/latest.go". // the "examples/latest" tree is @@ -316,7 +323,7 @@ func (s *ChangeSuite) TestErrorsFindingChildsAreDetected(c *C) { change := &Change{ From: ChangeEntry{ Name: path, - Tree: s.tree(c, fromTree), + Tree: s.tree(fromTree), TreeEntry: TreeEntry{ Name: name, Mode: mode, @@ -327,13 +334,13 @@ func (s *ChangeSuite) TestErrorsFindingChildsAreDetected(c *C) { } _, _, err := change.Files() - c.Assert(err, ErrorMatches, "object not found") + s.ErrorContains(err, "object not found") change = &Change{ From: empty, To: ChangeEntry{ Name: path, - Tree: s.tree(c, toTree), + Tree: s.tree(toTree), TreeEntry: TreeEntry{ Name: name, Mode: mode, @@ -343,14 +350,14 @@ func (s *ChangeSuite) TestErrorsFindingChildsAreDetected(c *C) { } _, _, err = change.Files() - c.Assert(err, ErrorMatches, "object not found") + s.ErrorContains(err, "object not found") } -func (s *ChangeSuite) TestChangesString(c *C) { +func (s *ChangeSuite) TestChangesString() { expected := "[]" changes := Changes{} obtained := changes.String() - c.Assert(obtained, Equals, expected) + s.Equal(expected, obtained) expected = "[]" changes = make([]*Change, 1) @@ -359,7 +366,7 @@ func (s *ChangeSuite) TestChangesString(c *C) { changes[0].To.Name = "bla" obtained = changes.String() - c.Assert(obtained, Equals, expected) + s.Equal(expected, obtained) expected = "[, ]" changes = make([]*Change, 2) @@ -369,10 +376,10 @@ func (s *ChangeSuite) TestChangesString(c *C) { changes[1] = &Change{} changes[1].From.Name = "foo/bar" obtained = changes.String() - c.Assert(obtained, Equals, expected) + s.Equal(expected, obtained) } -func (s *ChangeSuite) TestChangesSort(c *C) { +func (s *ChangeSuite) TestChangesSort() { changes := make(Changes, 3) changes[0] = &Change{} changes[0].From.Name = "z" @@ -387,10 +394,10 @@ func (s *ChangeSuite) TestChangesSort(c *C) { "]" sort.Sort(changes) - c.Assert(changes.String(), Equals, expected) + s.Equal(expected, changes.String()) } -func (s *ChangeSuite) TestCancel(c *C) { +func (s *ChangeSuite) TestCancel() { // Commit a5078b19f08f63e7948abd0a5e2fb7d319d3a565 of the go-git // fixture inserted "examples/clone/main.go". // @@ -410,7 +417,7 @@ func (s *ChangeSuite) TestCancel(c *C) { From: empty, To: ChangeEntry{ Name: path, - Tree: s.tree(c, tree), + Tree: s.tree(tree), TreeEntry: TreeEntry{ Name: name, Mode: mode, @@ -422,6 +429,6 @@ func (s *ChangeSuite) TestCancel(c *C) { ctx, cancel := context.WithCancel(context.Background()) cancel() p, err := change.PatchContext(ctx) - c.Assert(p, IsNil) - c.Assert(err, ErrorMatches, "operation canceled") + s.Nil(p) + s.ErrorContains(err, "operation canceled") } diff --git a/plumbing/object/commit.go b/plumbing/object/commit.go index 3d096e18b..f6392c99a 100644 --- a/plumbing/object/commit.go +++ b/plumbing/object/commit.go @@ -10,10 +10,10 @@ import ( "github.com/ProtonMail/go-crypto/openpgp" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/utils/ioutil" - "github.com/go-git/go-git/v5/utils/sync" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/utils/sync" ) const ( diff --git a/plumbing/object/commit_stats_test.go b/plumbing/object/commit_stats_test.go index 4078ce819..70fa86fa5 100644 --- a/plumbing/object/commit_stats_test.go +++ b/plumbing/object/commit_stats_test.go @@ -2,93 +2,101 @@ package object_test import ( "context" + "testing" "time" - "github.com/go-git/go-git/v5" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/storage/memory" + "github.com/jesseduffield/go-git/v5" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/suite" "github.com/go-git/go-billy/v5/memfs" "github.com/go-git/go-billy/v5/util" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) -type CommitStatsSuite struct { +type CommitStatsFixtureSuite struct { fixtures.Suite } -var _ = Suite(&CommitStatsSuite{}) +type CommitStatsSuite struct { + suite.Suite + CommitStatsFixtureSuite +} + +func TestCommitStatsSuite(t *testing.T) { + suite.Run(t, new(CommitStatsSuite)) +} -func (s *CommitStatsSuite) TestStats(c *C) { - r, hash := s.writeHistory(c, []byte("foo\n"), []byte("foo\nbar\n")) +func (s *CommitStatsSuite) TestStats() { + r, hash := s.writeHistory([]byte("foo\n"), []byte("foo\nbar\n")) aCommit, err := r.CommitObject(hash) - c.Assert(err, IsNil) + s.NoError(err) fileStats, err := aCommit.StatsContext(context.Background()) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(fileStats[0].Name, Equals, "foo") - c.Assert(fileStats[0].Addition, Equals, 1) - c.Assert(fileStats[0].Deletion, Equals, 0) - c.Assert(fileStats[0].String(), Equals, " foo | 1 +\n") + s.Equal("foo", fileStats[0].Name) + s.Equal(1, fileStats[0].Addition) + s.Equal(0, fileStats[0].Deletion) + s.Equal(" foo | 1 +\n", fileStats[0].String()) } -func (s *CommitStatsSuite) TestStats_RootCommit(c *C) { - r, hash := s.writeHistory(c, []byte("foo\n")) +func (s *CommitStatsSuite) TestStats_RootCommit() { + r, hash := s.writeHistory([]byte("foo\n")) aCommit, err := r.CommitObject(hash) - c.Assert(err, IsNil) + s.NoError(err) fileStats, err := aCommit.Stats() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(fileStats, HasLen, 1) - c.Assert(fileStats[0].Name, Equals, "foo") - c.Assert(fileStats[0].Addition, Equals, 1) - c.Assert(fileStats[0].Deletion, Equals, 0) - c.Assert(fileStats[0].String(), Equals, " foo | 1 +\n") + s.Len(fileStats, 1) + s.Equal("foo", fileStats[0].Name) + s.Equal(1, fileStats[0].Addition) + s.Equal(0, fileStats[0].Deletion) + s.Equal(" foo | 1 +\n", fileStats[0].String()) } -func (s *CommitStatsSuite) TestStats_WithoutNewLine(c *C) { - r, hash := s.writeHistory(c, []byte("foo\nbar"), []byte("foo\nbar\n")) +func (s *CommitStatsSuite) TestStats_WithoutNewLine() { + r, hash := s.writeHistory([]byte("foo\nbar"), []byte("foo\nbar\n")) aCommit, err := r.CommitObject(hash) - c.Assert(err, IsNil) + s.NoError(err) fileStats, err := aCommit.Stats() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(fileStats[0].Name, Equals, "foo") - c.Assert(fileStats[0].Addition, Equals, 1) - c.Assert(fileStats[0].Deletion, Equals, 1) - c.Assert(fileStats[0].String(), Equals, " foo | 2 +-\n") + s.Equal("foo", fileStats[0].Name) + s.Equal(1, fileStats[0].Addition) + s.Equal(1, fileStats[0].Deletion) + s.Equal(" foo | 2 +-\n", fileStats[0].String()) } -func (s *CommitStatsSuite) writeHistory(c *C, files ...[]byte) (*git.Repository, plumbing.Hash) { +func (s *CommitStatsSuite) writeHistory(files ...[]byte) (*git.Repository, plumbing.Hash) { cm := &git.CommitOptions{ Author: &object.Signature{Name: "Foo", Email: "foo@example.local", When: time.Now()}, } fs := memfs.New() r, err := git.Init(memory.NewStorage(), fs) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) var hash plumbing.Hash for _, content := range files { util.WriteFile(fs, "foo", content, 0644) _, err = w.Add("foo") - c.Assert(err, IsNil) + s.NoError(err) hash, err = w.Commit("foo\n", cm) - c.Assert(err, IsNil) + s.NoError(err) } diff --git a/plumbing/object/commit_test.go b/plumbing/object/commit_test.go index a0489269a..a46f2ce64 100644 --- a/plumbing/object/commit_test.go +++ b/plumbing/object/commit_test.go @@ -6,52 +6,56 @@ import ( "fmt" "io" "strings" + "testing" "time" fixtures "github.com/go-git/go-git-fixtures/v4" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/stretchr/testify/suite" - "github.com/go-git/go-git/v5/storage/filesystem" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/storage/filesystem" ) type SuiteCommit struct { + suite.Suite BaseObjectsSuite Commit *Commit } -var _ = Suite(&SuiteCommit{}) +func TestSuiteCommit(t *testing.T) { + suite.Run(t, new(SuiteCommit)) +} -func (s *SuiteCommit) SetUpSuite(c *C) { - s.BaseObjectsSuite.SetUpSuite(c) +func (s *SuiteCommit) SetupSuite() { + s.BaseObjectsSuite.SetupSuite(s.T()) hash := plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea") - s.Commit = s.commit(c, hash) + s.Commit = s.commit(hash) } -func (s *SuiteCommit) TestDecodeNonCommit(c *C) { +func (s *SuiteCommit) TestDecodeNonCommit() { hash := plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492") blob, err := s.Storer.EncodedObject(plumbing.AnyObject, hash) - c.Assert(err, IsNil) + s.NoError(err) commit := &Commit{} err = commit.Decode(blob) - c.Assert(err, Equals, ErrUnsupportedObject) + s.ErrorIs(err, ErrUnsupportedObject) } -func (s *SuiteCommit) TestType(c *C) { - c.Assert(s.Commit.Type(), Equals, plumbing.CommitObject) +func (s *SuiteCommit) TestType() { + s.Equal(plumbing.CommitObject, s.Commit.Type()) } -func (s *SuiteCommit) TestTree(c *C) { +func (s *SuiteCommit) TestTree() { tree, err := s.Commit.Tree() - c.Assert(err, IsNil) - c.Assert(tree.ID().String(), Equals, "eba74343e2f15d62adedfd8c883ee0262b5c8021") + s.NoError(err) + s.Equal("eba74343e2f15d62adedfd8c883ee0262b5c8021", tree.ID().String()) } -func (s *SuiteCommit) TestParents(c *C) { +func (s *SuiteCommit) TestParents() { expected := []string{ "35e85108805c84807bc66a02d91535e1e24b38b9", "a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69", @@ -64,36 +68,36 @@ func (s *SuiteCommit) TestParents(c *C) { return nil }) - c.Assert(err, IsNil) - c.Assert(output, DeepEquals, expected) + s.NoError(err) + s.Equal(expected, output) i.Close() } -func (s *SuiteCommit) TestParent(c *C) { +func (s *SuiteCommit) TestParent() { commit, err := s.Commit.Parent(1) - c.Assert(err, IsNil) - c.Assert(commit.Hash.String(), Equals, "a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69") + s.NoError(err) + s.Equal("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69", commit.Hash.String()) } -func (s *SuiteCommit) TestParentNotFound(c *C) { +func (s *SuiteCommit) TestParentNotFound() { commit, err := s.Commit.Parent(42) - c.Assert(err, Equals, ErrParentNotFound) - c.Assert(commit, IsNil) + s.ErrorIs(err, ErrParentNotFound) + s.Nil(commit) } -func (s *SuiteCommit) TestPatch(c *C) { - from := s.commit(c, plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294")) - to := s.commit(c, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) +func (s *SuiteCommit) TestPatch() { + from := s.commit(plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294")) + to := s.commit(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) patch, err := from.Patch(to) - c.Assert(err, IsNil) + s.NoError(err) buf := bytes.NewBuffer(nil) err = patch.Encode(buf) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(buf.String(), Equals, `diff --git a/vendor/foo.go b/vendor/foo.go + s.Equal(`diff --git a/vendor/foo.go b/vendor/foo.go new file mode 100644 index 0000000000000000000000000000000000000000..9dea2395f5403188298c1dabe8bdafe562c491e3 --- /dev/null @@ -106,20 +110,21 @@ index 0000000000000000000000000000000000000000..9dea2395f5403188298c1dabe8bdafe5 +func main() { + fmt.Println("Hello, playground") +} -`) - c.Assert(buf.String(), Equals, patch.String()) +`, + buf.String()) + s.Equal(patch.String(), buf.String()) - from = s.commit(c, plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47")) - to = s.commit(c, plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9")) + from = s.commit(plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47")) + to = s.commit(plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9")) patch, err = from.Patch(to) - c.Assert(err, IsNil) + s.NoError(err) buf.Reset() err = patch.Encode(buf) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(buf.String(), Equals, `diff --git a/CHANGELOG b/CHANGELOG + s.Equal(`diff --git a/CHANGELOG b/CHANGELOG deleted file mode 100644 index d3ff53e0564a9f87d8e84b6e28e5060e517008aa..0000000000000000000000000000000000000000 --- a/CHANGELOG @@ -130,23 +135,24 @@ diff --git a/binary.jpg b/binary.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d5c0f4ab811897cadf03aec358ae60d21f91c50d Binary files /dev/null and b/binary.jpg differ -`) +`, + buf.String()) - c.Assert(buf.String(), Equals, patch.String()) + s.Equal(patch.String(), buf.String()) } -func (s *SuiteCommit) TestPatchContext(c *C) { - from := s.commit(c, plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294")) - to := s.commit(c, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) +func (s *SuiteCommit) TestPatchContext() { + from := s.commit(plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294")) + to := s.commit(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) patch, err := from.PatchContext(context.Background(), to) - c.Assert(err, IsNil) + s.NoError(err) buf := bytes.NewBuffer(nil) err = patch.Encode(buf) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(buf.String(), Equals, `diff --git a/vendor/foo.go b/vendor/foo.go + s.Equal(`diff --git a/vendor/foo.go b/vendor/foo.go new file mode 100644 index 0000000000000000000000000000000000000000..9dea2395f5403188298c1dabe8bdafe562c491e3 --- /dev/null @@ -159,20 +165,21 @@ index 0000000000000000000000000000000000000000..9dea2395f5403188298c1dabe8bdafe5 +func main() { + fmt.Println("Hello, playground") +} -`) - c.Assert(buf.String(), Equals, patch.String()) +`, + buf.String()) + s.Equal(patch.String(), buf.String()) - from = s.commit(c, plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47")) - to = s.commit(c, plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9")) + from = s.commit(plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47")) + to = s.commit(plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9")) patch, err = from.PatchContext(context.Background(), to) - c.Assert(err, IsNil) + s.NoError(err) buf.Reset() err = patch.Encode(buf) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(buf.String(), Equals, `diff --git a/CHANGELOG b/CHANGELOG + s.Equal(`diff --git a/CHANGELOG b/CHANGELOG deleted file mode 100644 index d3ff53e0564a9f87d8e84b6e28e5060e517008aa..0000000000000000000000000000000000000000 --- a/CHANGELOG @@ -183,21 +190,22 @@ diff --git a/binary.jpg b/binary.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d5c0f4ab811897cadf03aec358ae60d21f91c50d Binary files /dev/null and b/binary.jpg differ -`) +`, + buf.String()) - c.Assert(buf.String(), Equals, patch.String()) + s.Equal(patch.String(), buf.String()) } -func (s *SuiteCommit) TestPatchContext_ToNil(c *C) { - from := s.commit(c, plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294")) +func (s *SuiteCommit) TestPatchContext_ToNil() { + from := s.commit(plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294")) patch, err := from.PatchContext(context.Background(), nil) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(len(patch.String()), Equals, 242679) + s.Equal(242679, len(patch.String())) } -func (s *SuiteCommit) TestCommitEncodeDecodeIdempotent(c *C) { +func (s *SuiteCommit) TestCommitEncodeDecodeIdempotent() { pgpsignature := `-----BEGIN PGP SIGNATURE----- iQEcBAABAgAGBQJTZbQlAAoJEF0+sviABDDrZbQH/09PfE51KPVPlanr6q1v4/Ut @@ -220,7 +228,7 @@ change `, pgpsignature) ts, err := time.Parse(time.RFC3339, "2006-01-02T15:04:05-07:00") - c.Assert(err, IsNil) + s.NoError(err) commits := []*Commit{ { Author: Signature{Name: "Foo", Email: "foo@example.local", When: ts}, @@ -272,48 +280,49 @@ change for _, commit := range commits { obj := &plumbing.MemoryObject{} err = commit.Encode(obj) - c.Assert(err, IsNil) + s.NoError(err) newCommit := &Commit{} err = newCommit.Decode(obj) - c.Assert(err, IsNil) + s.NoError(err) commit.Hash = obj.Hash() - c.Assert(newCommit, DeepEquals, commit) + s.Equal(commit, newCommit) } } -func (s *SuiteCommit) TestFile(c *C) { +func (s *SuiteCommit) TestFile() { file, err := s.Commit.File("CHANGELOG") - c.Assert(err, IsNil) - c.Assert(file.Name, Equals, "CHANGELOG") + s.NoError(err) + s.Equal("CHANGELOG", file.Name) } -func (s *SuiteCommit) TestNumParents(c *C) { - c.Assert(s.Commit.NumParents(), Equals, 2) +func (s *SuiteCommit) TestNumParents() { + s.Equal(2, s.Commit.NumParents()) } -func (s *SuiteCommit) TestString(c *C) { - c.Assert(s.Commit.String(), Equals, ""+ +func (s *SuiteCommit) TestString() { + s.Equal(""+ "commit 1669dce138d9b841a518c64b10914d88f5e488ea\n"+ "Author: Máximo Cuadros Ortiz \n"+ "Date: Tue Mar 31 13:48:14 2015 +0200\n"+ "\n"+ " Merge branch 'master' of github.com:tyba/git-fixture\n"+ "\n", + s.Commit.String(), ) } -func (s *SuiteCommit) TestStringMultiLine(c *C) { +func (s *SuiteCommit) TestStringMultiLine() { hash := plumbing.NewHash("e7d896db87294e33ca3202e536d4d9bb16023db3") f := fixtures.ByURL("https://github.com/src-d/go-git.git").One() sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) o, err := sto.EncodedObject(plumbing.CommitObject, hash) - c.Assert(err, IsNil) + s.NoError(err) commit, err := DecodeCommit(sto, o) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(commit.String(), Equals, ""+ + s.Equal(""+ "commit e7d896db87294e33ca3202e536d4d9bb16023db3\n"+ "Author: Alberto Cortés \n"+ "Date: Wed Jan 27 11:13:49 2016 +0100\n"+ @@ -323,26 +332,27 @@ func (s *SuiteCommit) TestStringMultiLine(c *C) { " The return value of reads to the packfile were being ignored, so zlib\n"+ " was getting invalid data on it read buffers.\n"+ "\n", + commit.String(), ) } -func (s *SuiteCommit) TestCommitIterNext(c *C) { +func (s *SuiteCommit) TestCommitIterNext() { i := s.Commit.Parents() commit, err := i.Next() - c.Assert(err, IsNil) - c.Assert(commit.ID().String(), Equals, "35e85108805c84807bc66a02d91535e1e24b38b9") + s.NoError(err) + s.Equal("35e85108805c84807bc66a02d91535e1e24b38b9", commit.ID().String()) commit, err = i.Next() - c.Assert(err, IsNil) - c.Assert(commit.ID().String(), Equals, "a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69") + s.NoError(err) + s.Equal("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69", commit.ID().String()) commit, err = i.Next() - c.Assert(err, Equals, io.EOF) - c.Assert(commit, IsNil) + s.ErrorIs(err, io.EOF) + s.Nil(commit) } -func (s *SuiteCommit) TestLongCommitMessageSerialization(c *C) { +func (s *SuiteCommit) TestLongCommitMessageSerialization() { encoded := &plumbing.MemoryObject{} decoded := &Commit{} commit := *s.Commit @@ -351,14 +361,14 @@ func (s *SuiteCommit) TestLongCommitMessageSerialization(c *C) { commit.Message = longMessage err := commit.Encode(encoded) - c.Assert(err, IsNil) + s.NoError(err) err = decoded.Decode(encoded) - c.Assert(err, IsNil) - c.Assert(decoded.Message, Equals, longMessage) + s.NoError(err) + s.Equal(longMessage, decoded.Message) } -func (s *SuiteCommit) TestPGPSignatureSerialization(c *C) { +func (s *SuiteCommit) TestPGPSignatureSerialization() { encoded := &plumbing.MemoryObject{} decoded := &Commit{} commit := *s.Commit @@ -377,11 +387,11 @@ RUysgqjcpT8+iQM1PblGfHR4XAhuOqN5Fx06PSaFZhqvWFezJ28/CLyX5q+oIVk= commit.PGPSignature = pgpsignature err := commit.Encode(encoded) - c.Assert(err, IsNil) + s.NoError(err) err = decoded.Decode(encoded) - c.Assert(err, IsNil) - c.Assert(decoded.PGPSignature, Equals, pgpsignature) + s.NoError(err) + s.Equal(pgpsignature, decoded.PGPSignature) // signature with extra empty line, it caused "index out of range" when // parsing it @@ -393,11 +403,11 @@ RUysgqjcpT8+iQM1PblGfHR4XAhuOqN5Fx06PSaFZhqvWFezJ28/CLyX5q+oIVk= decoded = &Commit{} err = commit.Encode(encoded) - c.Assert(err, IsNil) + s.NoError(err) err = decoded.Decode(encoded) - c.Assert(err, IsNil) - c.Assert(decoded.PGPSignature, Equals, pgpsignature2) + s.NoError(err) + s.Equal(pgpsignature2, decoded.PGPSignature) // signature in author name @@ -407,12 +417,12 @@ RUysgqjcpT8+iQM1PblGfHR4XAhuOqN5Fx06PSaFZhqvWFezJ28/CLyX5q+oIVk= decoded = &Commit{} err = commit.Encode(encoded) - c.Assert(err, IsNil) + s.NoError(err) err = decoded.Decode(encoded) - c.Assert(err, IsNil) - c.Assert(decoded.PGPSignature, Equals, "") - c.Assert(decoded.Author.Name, Equals, beginpgp) + s.NoError(err) + s.Equal("", decoded.PGPSignature) + s.Equal(beginpgp, decoded.Author.Name) // broken signature @@ -425,40 +435,40 @@ RUysgqjcpT8+iQM1PblGfHR4XAhuOqN5Fx06PSaFZhqvWFezJ28/CLyX5q+oIVk= decoded = &Commit{} err = commit.Encode(encoded) - c.Assert(err, IsNil) + s.NoError(err) err = decoded.Decode(encoded) - c.Assert(err, IsNil) - c.Assert(decoded.PGPSignature, Equals, commit.PGPSignature) + s.NoError(err) + s.Equal(commit.PGPSignature, decoded.PGPSignature) } -func (s *SuiteCommit) TestStat(c *C) { - aCommit := s.commit(c, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) +func (s *SuiteCommit) TestStat() { + aCommit := s.commit(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) fileStats, err := aCommit.Stats() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(fileStats[0].Name, Equals, "vendor/foo.go") - c.Assert(fileStats[0].Addition, Equals, 7) - c.Assert(fileStats[0].Deletion, Equals, 0) - c.Assert(fileStats[0].String(), Equals, " vendor/foo.go | 7 +++++++\n") + s.Equal("vendor/foo.go", fileStats[0].Name) + s.Equal(7, fileStats[0].Addition) + s.Equal(0, fileStats[0].Deletion) + s.Equal(" vendor/foo.go | 7 +++++++\n", fileStats[0].String()) // Stats for another commit. - aCommit = s.commit(c, plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294")) + aCommit = s.commit(plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294")) fileStats, err = aCommit.Stats() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(fileStats[0].Name, Equals, "go/example.go") - c.Assert(fileStats[0].Addition, Equals, 142) - c.Assert(fileStats[0].Deletion, Equals, 0) - c.Assert(fileStats[0].String(), Equals, " go/example.go | 142 +++++++++++++++++++++++++++++++++++++++++++++++++++++\n") + s.Equal("go/example.go", fileStats[0].Name) + s.Equal(142, fileStats[0].Addition) + s.Equal(0, fileStats[0].Deletion) + s.Equal(" go/example.go | 142 +++++++++++++++++++++++++++++++++++++++++++++++++++++\n", fileStats[0].String()) - c.Assert(fileStats[1].Name, Equals, "php/crappy.php") - c.Assert(fileStats[1].Addition, Equals, 259) - c.Assert(fileStats[1].Deletion, Equals, 0) - c.Assert(fileStats[1].String(), Equals, " php/crappy.php | 259 +++++++++++++++++++++++++++++++++++++++++++++++++++++\n") + s.Equal("php/crappy.php", fileStats[1].Name) + s.Equal(259, fileStats[1].Addition) + s.Equal(0, fileStats[1].Deletion) + s.Equal(" php/crappy.php | 259 +++++++++++++++++++++++++++++++++++++++++++++++++++++\n", fileStats[1].String()) } -func (s *SuiteCommit) TestVerify(c *C) { +func (s *SuiteCommit) TestVerify() { ts := time.Unix(1617402711, 0) loc, _ := time.LoadLocation("UTC") commit := &Commit{ @@ -497,25 +507,25 @@ YIefGtzXfldDxg4= ` e, err := commit.Verify(armoredKeyRing) - c.Assert(err, IsNil) + s.NoError(err) _, ok := e.Identities["go-git test key"] - c.Assert(ok, Equals, true) + s.True(ok) } -func (s *SuiteCommit) TestPatchCancel(c *C) { - from := s.commit(c, plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294")) - to := s.commit(c, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) +func (s *SuiteCommit) TestPatchCancel() { + from := s.commit(plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294")) + to := s.commit(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) ctx, cancel := context.WithCancel(context.Background()) cancel() patch, err := from.PatchContext(ctx, to) - c.Assert(patch, IsNil) - c.Assert(err, ErrorMatches, "operation canceled") + s.Nil(patch) + s.ErrorContains(err, "operation canceled") } -func (s *SuiteCommit) TestMalformedHeader(c *C) { +func (s *SuiteCommit) TestMalformedHeader() { encoded := &plumbing.MemoryObject{} decoded := &Commit{} commit := *s.Commit @@ -527,33 +537,34 @@ func (s *SuiteCommit) TestMalformedHeader(c *C) { commit.Committer.Email = "\n" err := commit.Encode(encoded) - c.Assert(err, IsNil) + s.NoError(err) err = decoded.Decode(encoded) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *SuiteCommit) TestEncodeWithoutSignature(c *C) { +func (s *SuiteCommit) TestEncodeWithoutSignature() { // Similar to TestString since no signature encoded := &plumbing.MemoryObject{} err := s.Commit.EncodeWithoutSignature(encoded) - c.Assert(err, IsNil) + s.NoError(err) er, err := encoded.Reader() - c.Assert(err, IsNil) + s.NoError(err) payload, err := io.ReadAll(er) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(string(payload), Equals, ""+ + s.Equal(""+ "tree eba74343e2f15d62adedfd8c883ee0262b5c8021\n"+ "parent 35e85108805c84807bc66a02d91535e1e24b38b9\n"+ "parent a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69\n"+ "author Máximo Cuadros Ortiz 1427802494 +0200\n"+ "committer Máximo Cuadros Ortiz 1427802494 +0200\n"+ "\n"+ - "Merge branch 'master' of github.com:tyba/git-fixture\n") + "Merge branch 'master' of github.com:tyba/git-fixture\n", + string(payload)) } -func (s *SuiteCommit) TestLess(c *C) { +func (s *SuiteCommit) TestLess() { when1 := time.Now() when2 := when1.Add(time.Hour) @@ -619,6 +630,6 @@ func (s *SuiteCommit) TestLess(c *C) { When: t.Committer2When, }, } - c.Assert(commit1.Less(commit2), Equals, t.Exp) + s.Equal(t.Exp, commit1.Less(commit2)) } } diff --git a/plumbing/object/commit_walker.go b/plumbing/object/commit_walker.go index a96b6a4cf..60da75cad 100644 --- a/plumbing/object/commit_walker.go +++ b/plumbing/object/commit_walker.go @@ -4,9 +4,9 @@ import ( "container/list" "io" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage" ) type commitPreIterator struct { diff --git a/plumbing/object/commit_walker_bfs.go b/plumbing/object/commit_walker_bfs.go index 8047fa9bc..c9c744d6c 100644 --- a/plumbing/object/commit_walker_bfs.go +++ b/plumbing/object/commit_walker_bfs.go @@ -3,8 +3,8 @@ package object import ( "io" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" ) type bfsCommitIterator struct { diff --git a/plumbing/object/commit_walker_bfs_filtered.go b/plumbing/object/commit_walker_bfs_filtered.go index 9d518133e..72343a64b 100644 --- a/plumbing/object/commit_walker_bfs_filtered.go +++ b/plumbing/object/commit_walker_bfs_filtered.go @@ -3,8 +3,8 @@ package object import ( "io" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" ) // NewFilterCommitIter returns a CommitIter that walks the commit history, diff --git a/plumbing/object/commit_walker_bfs_filtered_test.go b/plumbing/object/commit_walker_bfs_filtered_test.go index 9ea7dc68c..f526968d2 100644 --- a/plumbing/object/commit_walker_bfs_filtered_test.go +++ b/plumbing/object/commit_walker_bfs_filtered_test.go @@ -3,16 +3,21 @@ package object import ( "fmt" "strings" + "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/storer" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/stretchr/testify/suite" ) -var _ = Suite(&filterCommitIterSuite{}) +func TestFilterCommitIterSuite(t *testing.T) { + // TODO: re-enable test + t.SkipNow() + suite.Run(t, new(filterCommitIterSuite)) +} type filterCommitIterSuite struct { + suite.Suite BaseObjectsSuite } @@ -26,7 +31,7 @@ func commitsFromIter(iter CommitIter) ([]*Commit, error) { return commits, err } -func assertHashes(c *C, commits []*Commit, hashes []string) { +func assertHashes(s *filterCommitIterSuite, commits []*Commit, hashes []string) { if len(commits) != len(hashes) { var expected []string expected = append(expected, hashes...) @@ -38,9 +43,9 @@ func assertHashes(c *C, commits []*Commit, hashes []string) { fmt.Println(" got:", strings.Join(got, ", ")) } - c.Assert(commits, HasLen, len(hashes)) + s.Len(commits, len(hashes)) for i, commit := range commits { - c.Assert(hashes[i], Equals, commit.Hash.String()) + s.Equal(commit.Hash.String(), hashes[i]) } } @@ -81,11 +86,11 @@ func not(filter CommitFilter) CommitFilter { // TestFilterCommitIter asserts that FilterCommitIter returns all commits from // history, but e8d3ffab552895c19b9fcf7aa264d277cde33881, that is not reachable // from HEAD -func (s *filterCommitIterSuite) TestFilterCommitIter(c *C) { - from := s.commit(c, plumbing.NewHash(s.Fixture.Head)) +func (s *filterCommitIterSuite) TestFilterCommitIter() { + from := s.commit(plumbing.NewHash(s.Fixture.Head)) commits, err := commitsFromIter(NewFilterCommitIter(from, nil, nil)) - c.Assert(err, IsNil) + s.NoError(err) expected := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", @@ -98,35 +103,35 @@ func (s *filterCommitIterSuite) TestFilterCommitIter(c *C) { "b8e471f58bcbca63b07bda20e428190409c2db47", } - assertHashes(c, commits, expected) + assertHashes(s, commits, expected) } // TestFilterCommitIterWithValid asserts that FilterCommitIter returns only commits // that matches the passed isValid filter; in this testcase, it was filtered out // all commits but one from history -func (s *filterCommitIterSuite) TestFilterCommitIterWithValid(c *C) { - from := s.commit(c, plumbing.NewHash(s.Fixture.Head)) +func (s *filterCommitIterSuite) TestFilterCommitIterWithValid() { + from := s.commit(plumbing.NewHash(s.Fixture.Head)) validIf := validIfCommit(plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9")) commits, err := commitsFromIter(NewFilterCommitIter(from, &validIf, nil)) - c.Assert(err, IsNil) + s.NoError(err) expected := []string{ "35e85108805c84807bc66a02d91535e1e24b38b9", } - assertHashes(c, commits, expected) + assertHashes(s, commits, expected) } // that matches the passed isValid filter; in this testcase, it was filtered out // only one commit from history -func (s *filterCommitIterSuite) TestFilterCommitIterWithInvalid(c *C) { - from := s.commit(c, plumbing.NewHash(s.Fixture.Head)) +func (s *filterCommitIterSuite) TestFilterCommitIterWithInvalid() { + from := s.commit(plumbing.NewHash(s.Fixture.Head)) validIf := validIfCommit(plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9")) validIfNot := not(validIf) commits, err := commitsFromIter(NewFilterCommitIter(from, &validIfNot, nil)) - c.Assert(err, IsNil) + s.NoError(err) expected := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", @@ -138,28 +143,28 @@ func (s *filterCommitIterSuite) TestFilterCommitIterWithInvalid(c *C) { "b8e471f58bcbca63b07bda20e428190409c2db47", } - assertHashes(c, commits, expected) + assertHashes(s, commits, expected) } // TestFilterCommitIterWithNoValidCommits asserts that FilterCommitIter returns // no commits if the passed isValid filter does not allow any commit -func (s *filterCommitIterSuite) TestFilterCommitIterWithNoValidCommits(c *C) { - from := s.commit(c, plumbing.NewHash(s.Fixture.Head)) +func (s *filterCommitIterSuite) TestFilterCommitIterWithNoValidCommits() { + from := s.commit(plumbing.NewHash(s.Fixture.Head)) validIf := validIfCommit(plumbing.NewHash("THIS_COMMIT_DOES_NOT_EXIST")) commits, err := commitsFromIter(NewFilterCommitIter(from, &validIf, nil)) - c.Assert(err, IsNil) - c.Assert(commits, HasLen, 0) + s.NoError(err) + s.Len(commits, 0) } // TestFilterCommitIterWithStopAt asserts that FilterCommitIter returns only commits // are not beyond a isLimit filter -func (s *filterCommitIterSuite) TestFilterCommitIterWithStopAt(c *C) { - from := s.commit(c, plumbing.NewHash(s.Fixture.Head)) +func (s *filterCommitIterSuite) TestFilterCommitIterWithStopAt() { + from := s.commit(plumbing.NewHash(s.Fixture.Head)) stopAtRule := validIfCommit(plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69")) commits, err := commitsFromIter(NewFilterCommitIter(from, nil, &stopAtRule)) - c.Assert(err, IsNil) + s.NoError(err) expected := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", @@ -171,19 +176,19 @@ func (s *filterCommitIterSuite) TestFilterCommitIterWithStopAt(c *C) { "b029517f6300c2da0f4b651b8642506cd6aaf45d", } - assertHashes(c, commits, expected) + assertHashes(s, commits, expected) } // TestFilterCommitIterWithStopAt asserts that FilterCommitIter works properly // with isValid and isLimit filters -func (s *filterCommitIterSuite) TestFilterCommitIterWithInvalidAndStopAt(c *C) { - from := s.commit(c, plumbing.NewHash(s.Fixture.Head)) +func (s *filterCommitIterSuite) TestFilterCommitIterWithInvalidAndStopAt() { + from := s.commit(plumbing.NewHash(s.Fixture.Head)) stopAtRule := validIfCommit(plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69")) validIf := validIfCommit(plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9")) validIfNot := not(validIf) commits, err := commitsFromIter(NewFilterCommitIter(from, &validIfNot, &stopAtRule)) - c.Assert(err, IsNil) + s.NoError(err) expected := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", @@ -194,7 +199,7 @@ func (s *filterCommitIterSuite) TestFilterCommitIterWithInvalidAndStopAt(c *C) { "b029517f6300c2da0f4b651b8642506cd6aaf45d", } - assertHashes(c, commits, expected) + assertHashes(s, commits, expected) } // TestIteratorForEachCallbackReturn that ForEach callback does not cause @@ -208,7 +213,7 @@ func (s *filterCommitIterSuite) TestFilterCommitIterWithInvalidAndStopAt(c *C) { // - a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69 // - b029517f6300c2da0f4b651b8642506cd6aaf45d // - b8e471f58bcbca63b07bda20e428190409c2db47 -func (s *filterCommitIterSuite) TestIteratorForEachCallbackReturn(c *C) { +func (s *filterCommitIterSuite) TestIteratorForEachCallbackReturn() { var visited []*Commit errUnexpected := fmt.Errorf("Could not continue") @@ -224,26 +229,26 @@ func (s *filterCommitIterSuite) TestIteratorForEachCallbackReturn(c *C) { return nil } - from := s.commit(c, plumbing.NewHash(s.Fixture.Head)) + from := s.commit(plumbing.NewHash(s.Fixture.Head)) iter := NewFilterCommitIter(from, nil, nil) err := iter.ForEach(cb) - c.Assert(err, IsNil) + s.NoError(err) expected := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", } - assertHashes(c, visited, expected) + assertHashes(s, visited, expected) err = iter.ForEach(cb) - c.Assert(err, Equals, errUnexpected) + s.ErrorIs(err, errUnexpected) expected = []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "af2d6a6954d532f8ffb47615169c8fdf9d383a1a", } - assertHashes(c, visited, expected) + assertHashes(s, visited, expected) err = iter.ForEach(cb) - c.Assert(err, IsNil) + s.NoError(err) expected = []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "af2d6a6954d532f8ffb47615169c8fdf9d383a1a", @@ -252,5 +257,5 @@ func (s *filterCommitIterSuite) TestIteratorForEachCallbackReturn(c *C) { "b029517f6300c2da0f4b651b8642506cd6aaf45d", "b8e471f58bcbca63b07bda20e428190409c2db47", } - assertHashes(c, visited, expected) + assertHashes(s, visited, expected) } diff --git a/plumbing/object/commit_walker_ctime.go b/plumbing/object/commit_walker_ctime.go index fbddf1d23..69ac2aa35 100644 --- a/plumbing/object/commit_walker_ctime.go +++ b/plumbing/object/commit_walker_ctime.go @@ -5,8 +5,8 @@ import ( "github.com/emirpasic/gods/trees/binaryheap" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" ) type commitIteratorByCTime struct { diff --git a/plumbing/object/commit_walker_limit.go b/plumbing/object/commit_walker_limit.go index ac56a71c4..5850394d3 100644 --- a/plumbing/object/commit_walker_limit.go +++ b/plumbing/object/commit_walker_limit.go @@ -4,7 +4,8 @@ import ( "io" "time" - "github.com/go-git/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" ) type commitLimitIter struct { @@ -13,8 +14,9 @@ type commitLimitIter struct { } type LogLimitOptions struct { - Since *time.Time - Until *time.Time + Since *time.Time + Until *time.Time + TailHash plumbing.Hash } func NewCommitLimitIterFromIter(commitIter CommitIter, limitOptions LogLimitOptions) CommitIter { @@ -37,6 +39,9 @@ func (c *commitLimitIter) Next() (*Commit, error) { if c.limitOptions.Until != nil && commit.Committer.When.After(*c.limitOptions.Until) { continue } + if c.limitOptions.TailHash == commit.Hash { + return commit, storer.ErrStop + } return commit, nil } } @@ -47,11 +52,11 @@ func (c *commitLimitIter) ForEach(cb func(*Commit) error) error { if nextErr == io.EOF { break } - if nextErr != nil { + if nextErr != nil && nextErr != storer.ErrStop { return nextErr } err := cb(commit) - if err == storer.ErrStop { + if err == storer.ErrStop || nextErr == storer.ErrStop { return nil } else if err != nil { return err diff --git a/plumbing/object/commit_walker_path.go b/plumbing/object/commit_walker_path.go index c1ec8ba7a..b54b7e1d2 100644 --- a/plumbing/object/commit_walker_path.go +++ b/plumbing/object/commit_walker_path.go @@ -3,8 +3,8 @@ package object import ( "io" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" ) type commitPathIter struct { diff --git a/plumbing/object/commit_walker_test.go b/plumbing/object/commit_walker_test.go index fa0ca7d32..aab026259 100644 --- a/plumbing/object/commit_walker_test.go +++ b/plumbing/object/commit_walker_test.go @@ -1,19 +1,28 @@ package object import ( - "github.com/go-git/go-git/v5/plumbing" + "testing" + "time" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/stretchr/testify/suite" ) type CommitWalkerSuite struct { + suite.Suite BaseObjectsSuite } -var _ = Suite(&CommitWalkerSuite{}) +func TestCommitWalkerSuite(t *testing.T) { + suite.Run(t, new(CommitWalkerSuite)) +} + +func (s *CommitWalkerSuite) SetupSuite() { + s.BaseObjectsSuite.SetupSuite(s.T()) +} -func (s *CommitWalkerSuite) TestCommitPreIterator(c *C) { - commit := s.commit(c, plumbing.NewHash(s.Fixture.Head)) +func (s *CommitWalkerSuite) TestCommitPreIterator() { + commit := s.commit(plumbing.NewHash(s.Fixture.Head)) var commits []*Commit NewCommitPreorderIter(commit, nil, nil).ForEach(func(c *Commit) error { @@ -21,7 +30,7 @@ func (s *CommitWalkerSuite) TestCommitPreIterator(c *C) { return nil }) - c.Assert(commits, HasLen, 8) + s.Len(commits, 8) expected := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", @@ -34,12 +43,12 @@ func (s *CommitWalkerSuite) TestCommitPreIterator(c *C) { "b8e471f58bcbca63b07bda20e428190409c2db47", } for i, commit := range commits { - c.Assert(commit.Hash.String(), Equals, expected[i]) + s.Equal(expected[i], commit.Hash.String()) } } -func (s *CommitWalkerSuite) TestCommitPreIteratorWithIgnore(c *C) { - commit := s.commit(c, plumbing.NewHash(s.Fixture.Head)) +func (s *CommitWalkerSuite) TestCommitPreIteratorWithIgnore() { + commit := s.commit(plumbing.NewHash(s.Fixture.Head)) var commits []*Commit NewCommitPreorderIter(commit, nil, []plumbing.Hash{ @@ -49,19 +58,69 @@ func (s *CommitWalkerSuite) TestCommitPreIteratorWithIgnore(c *C) { return nil }) - c.Assert(commits, HasLen, 2) + s.Len(commits, 2) + + expected := []string{ + "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", + "918c48b83bd081e863dbe1b80f8998f058cd8294", + } + for i, commit := range commits { + s.Equal(expected[i], commit.Hash.String()) + } +} + +func (s *CommitWalkerSuite) TestCommitLimitIterByTrailingHash() { + commit := s.commit(plumbing.NewHash(s.Fixture.Head)) + commitIter := NewCommitPreorderIter(commit, nil, nil) + var commits []*Commit + expected := []string{ + "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", + "918c48b83bd081e863dbe1b80f8998f058cd8294", + "af2d6a6954d532f8ffb47615169c8fdf9d383a1a", + "1669dce138d9b841a518c64b10914d88f5e488ea", + "35e85108805c84807bc66a02d91535e1e24b38b9", + "b029517f6300c2da0f4b651b8642506cd6aaf45d", + "a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69", + } + NewCommitLimitIterFromIter(commitIter, LogLimitOptions{ + TailHash: plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69"), + }).ForEach(func(c *Commit) error { + commits = append(commits, c) + return nil + }) + + for i, commit := range commits { + s.Equal(expected[i], commit.Hash.String()) + } +} +func (s *CommitWalkerSuite) TestCommitLimitIterByTime() { + commit := s.commit(plumbing.NewHash(s.Fixture.Head)) + commitIter := NewCommitPreorderIter(commit, nil, nil) + var commits []*Commit expected := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "918c48b83bd081e863dbe1b80f8998f058cd8294", + "af2d6a6954d532f8ffb47615169c8fdf9d383a1a", + "1669dce138d9b841a518c64b10914d88f5e488ea", } + since, err := time.Parse(time.RFC3339, "2015-03-31T13:48:14+02:00") + s.NoError(err) + NewCommitLimitIterFromIter(commitIter, LogLimitOptions{ + Since: &since, + TailHash: plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69"), + }).ForEach(func(c *Commit) error { + commits = append(commits, c) + return nil + }) + for i, commit := range commits { - c.Assert(commit.Hash.String(), Equals, expected[i]) + s.Equal(expected[i], commit.Hash.String()) } } -func (s *CommitWalkerSuite) TestCommitPreIteratorWithSeenExternal(c *C) { - commit := s.commit(c, plumbing.NewHash(s.Fixture.Head)) +func (s *CommitWalkerSuite) TestCommitPreIteratorWithSeenExternal() { + commit := s.commit(plumbing.NewHash(s.Fixture.Head)) var commits []*Commit seenExternal := map[plumbing.Hash]bool{ @@ -73,19 +132,19 @@ func (s *CommitWalkerSuite) TestCommitPreIteratorWithSeenExternal(c *C) { return nil }) - c.Assert(commits, HasLen, 2) + s.Len(commits, 2) expected := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "918c48b83bd081e863dbe1b80f8998f058cd8294", } for i, commit := range commits { - c.Assert(commit.Hash.String(), Equals, expected[i]) + s.Equal(expected[i], commit.Hash.String()) } } -func (s *CommitWalkerSuite) TestCommitPostIterator(c *C) { - commit := s.commit(c, plumbing.NewHash(s.Fixture.Head)) +func (s *CommitWalkerSuite) TestCommitPostIterator() { + commit := s.commit(plumbing.NewHash(s.Fixture.Head)) var commits []*Commit NewCommitPostorderIter(commit, nil).ForEach(func(c *Commit) error { @@ -93,7 +152,7 @@ func (s *CommitWalkerSuite) TestCommitPostIterator(c *C) { return nil }) - c.Assert(commits, HasLen, 8) + s.Len(commits, 8) expected := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", @@ -107,12 +166,12 @@ func (s *CommitWalkerSuite) TestCommitPostIterator(c *C) { } for i, commit := range commits { - c.Assert(commit.Hash.String(), Equals, expected[i]) + s.Equal(expected[i], commit.Hash.String()) } } -func (s *CommitWalkerSuite) TestCommitPostIteratorWithIgnore(c *C) { - commit := s.commit(c, plumbing.NewHash(s.Fixture.Head)) +func (s *CommitWalkerSuite) TestCommitPostIteratorWithIgnore() { + commit := s.commit(plumbing.NewHash(s.Fixture.Head)) var commits []*Commit NewCommitPostorderIter(commit, []plumbing.Hash{ @@ -122,19 +181,19 @@ func (s *CommitWalkerSuite) TestCommitPostIteratorWithIgnore(c *C) { return nil }) - c.Assert(commits, HasLen, 2) + s.Len(commits, 2) expected := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "918c48b83bd081e863dbe1b80f8998f058cd8294", } for i, commit := range commits { - c.Assert(commit.Hash.String(), Equals, expected[i]) + s.Equal(expected[i], commit.Hash.String()) } } -func (s *CommitWalkerSuite) TestCommitCTimeIterator(c *C) { - commit := s.commit(c, plumbing.NewHash(s.Fixture.Head)) +func (s *CommitWalkerSuite) TestCommitCTimeIterator() { + commit := s.commit(plumbing.NewHash(s.Fixture.Head)) var commits []*Commit NewCommitIterCTime(commit, nil, nil).ForEach(func(c *Commit) error { @@ -142,7 +201,7 @@ func (s *CommitWalkerSuite) TestCommitCTimeIterator(c *C) { return nil }) - c.Assert(commits, HasLen, 8) + s.Len(commits, 8) expected := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", // 2015-04-05T23:30:47+02:00 @@ -155,12 +214,12 @@ func (s *CommitWalkerSuite) TestCommitCTimeIterator(c *C) { "b029517f6300c2da0f4b651b8642506cd6aaf45d", // 2015-03-31T13:42:21+02:00 } for i, commit := range commits { - c.Assert(commit.Hash.String(), Equals, expected[i]) + s.Equal(expected[i], commit.Hash.String()) } } -func (s *CommitWalkerSuite) TestCommitCTimeIteratorWithIgnore(c *C) { - commit := s.commit(c, plumbing.NewHash(s.Fixture.Head)) +func (s *CommitWalkerSuite) TestCommitCTimeIteratorWithIgnore() { + commit := s.commit(plumbing.NewHash(s.Fixture.Head)) var commits []*Commit NewCommitIterCTime(commit, nil, []plumbing.Hash{ @@ -170,19 +229,19 @@ func (s *CommitWalkerSuite) TestCommitCTimeIteratorWithIgnore(c *C) { return nil }) - c.Assert(commits, HasLen, 2) + s.Len(commits, 2) expected := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "918c48b83bd081e863dbe1b80f8998f058cd8294", } for i, commit := range commits { - c.Assert(commit.Hash.String(), Equals, expected[i]) + s.Equal(expected[i], commit.Hash.String()) } } -func (s *CommitWalkerSuite) TestCommitBSFIterator(c *C) { - commit := s.commit(c, plumbing.NewHash(s.Fixture.Head)) +func (s *CommitWalkerSuite) TestCommitBSFIterator() { + commit := s.commit(plumbing.NewHash(s.Fixture.Head)) var commits []*Commit NewCommitIterBSF(commit, nil, nil).ForEach(func(c *Commit) error { @@ -190,7 +249,7 @@ func (s *CommitWalkerSuite) TestCommitBSFIterator(c *C) { return nil }) - c.Assert(commits, HasLen, 8) + s.Len(commits, 8) expected := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", @@ -203,12 +262,12 @@ func (s *CommitWalkerSuite) TestCommitBSFIterator(c *C) { "b8e471f58bcbca63b07bda20e428190409c2db47", } for i, commit := range commits { - c.Assert(commit.Hash.String(), Equals, expected[i]) + s.Equal(expected[i], commit.Hash.String()) } } -func (s *CommitWalkerSuite) TestCommitBSFIteratorWithIgnore(c *C) { - commit := s.commit(c, plumbing.NewHash(s.Fixture.Head)) +func (s *CommitWalkerSuite) TestCommitBSFIteratorWithIgnore() { + commit := s.commit(plumbing.NewHash(s.Fixture.Head)) var commits []*Commit NewCommitIterBSF(commit, nil, []plumbing.Hash{ @@ -218,19 +277,19 @@ func (s *CommitWalkerSuite) TestCommitBSFIteratorWithIgnore(c *C) { return nil }) - c.Assert(commits, HasLen, 2) + s.Len(commits, 2) expected := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "918c48b83bd081e863dbe1b80f8998f058cd8294", } for i, commit := range commits { - c.Assert(commit.Hash.String(), Equals, expected[i]) + s.Equal(expected[i], commit.Hash.String()) } } -func (s *CommitWalkerSuite) TestCommitPathIteratorInitialCommit(c *C) { - commit := s.commit(c, plumbing.NewHash(s.Fixture.Head)) +func (s *CommitWalkerSuite) TestCommitPathIteratorInitialCommit() { + commit := s.commit(plumbing.NewHash(s.Fixture.Head)) fileName := "LICENSE" @@ -248,9 +307,9 @@ func (s *CommitWalkerSuite) TestCommitPathIteratorInitialCommit(c *C) { "b029517f6300c2da0f4b651b8642506cd6aaf45d", } - c.Assert(commits, HasLen, len(expected)) + s.Len(commits, len(expected)) for i, commit := range commits { - c.Assert(commit.Hash.String(), Equals, expected[i]) + s.Equal(expected[i], commit.Hash.String()) } } diff --git a/plumbing/object/commitgraph/commitnode.go b/plumbing/object/commitgraph/commitnode.go index 47227d434..7fccde77c 100644 --- a/plumbing/object/commitgraph/commitnode.go +++ b/plumbing/object/commitgraph/commitnode.go @@ -4,9 +4,9 @@ import ( "io" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/plumbing/storer" ) // CommitNode is generic interface encapsulating a lightweight commit object retrieved diff --git a/plumbing/object/commitgraph/commitnode_graph.go b/plumbing/object/commitgraph/commitnode_graph.go index 0f51e3be9..4badd7e4c 100644 --- a/plumbing/object/commitgraph/commitnode_graph.go +++ b/plumbing/object/commitgraph/commitnode_graph.go @@ -4,10 +4,10 @@ import ( "fmt" "time" - "github.com/go-git/go-git/v5/plumbing" - commitgraph "github.com/go-git/go-git/v5/plumbing/format/commitgraph/v2" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing" + commitgraph "github.com/jesseduffield/go-git/v5/plumbing/format/commitgraph/v2" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/plumbing/storer" ) // graphCommitNode is a reduced representation of Commit as presented in the commit diff --git a/plumbing/object/commitgraph/commitnode_object.go b/plumbing/object/commitgraph/commitnode_object.go index 7256bed2f..2431c9566 100644 --- a/plumbing/object/commitgraph/commitnode_object.go +++ b/plumbing/object/commitgraph/commitnode_object.go @@ -4,9 +4,9 @@ import ( "math" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/plumbing/storer" ) // objectCommitNode is a representation of Commit as presented in the GIT object format. diff --git a/plumbing/object/commitgraph/commitnode_test.go b/plumbing/object/commitgraph/commitnode_test.go index 441ff6f0a..44ee012ca 100644 --- a/plumbing/object/commitgraph/commitnode_test.go +++ b/plumbing/object/commitgraph/commitnode_test.go @@ -4,23 +4,28 @@ import ( "path" "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - commitgraph "github.com/go-git/go-git/v5/plumbing/format/commitgraph/v2" - "github.com/go-git/go-git/v5/plumbing/format/packfile" - "github.com/go-git/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + commitgraph "github.com/jesseduffield/go-git/v5/plumbing/format/commitgraph/v2" + "github.com/jesseduffield/go-git/v5/plumbing/format/packfile" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) -func Test(t *testing.T) { TestingT(t) } +type CommitNodeFixtureSuite struct { + fixtures.Suite +} type CommitNodeSuite struct { - fixtures.Suite + suite.Suite + CommitNodeFixtureSuite } -var _ = Suite(&CommitNodeSuite{}) +func TestCommitNodeSuite(t *testing.T) { + suite.Run(t, new(CommitNodeSuite)) +} func unpackRepository(f *fixtures.Fixture) *filesystem.Storage { storer := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) @@ -30,9 +35,9 @@ func unpackRepository(f *fixtures.Fixture) *filesystem.Storage { return storer } -func testWalker(c *C, nodeIndex CommitNodeIndex) { +func testWalker(s *CommitNodeSuite, nodeIndex CommitNodeIndex) { head, err := nodeIndex.Get(plumbing.NewHash("b9d69064b190e7aedccf84731ca1d917871f8a1c")) - c.Assert(err, IsNil) + s.NoError(err) iter := NewCommitNodeIterCTime( head, @@ -46,7 +51,7 @@ func testWalker(c *C, nodeIndex CommitNodeIndex) { return nil }) - c.Assert(commits, HasLen, 9) + s.Len(commits, 9) expected := []string{ "b9d69064b190e7aedccf84731ca1d917871f8a1c", @@ -60,13 +65,13 @@ func testWalker(c *C, nodeIndex CommitNodeIndex) { "347c91919944a68e9413581a1bc15519550a3afe", } for i, commit := range commits { - c.Assert(commit.ID().String(), Equals, expected[i]) + s.Equal(expected[i], commit.ID().String()) } } -func testParents(c *C, nodeIndex CommitNodeIndex) { +func testParents(s *CommitNodeSuite, nodeIndex CommitNodeIndex) { merge3, err := nodeIndex.Get(plumbing.NewHash("6f6c5d2be7852c782be1dd13e36496dd7ad39560")) - c.Assert(err, IsNil) + s.NoError(err) var parents []CommitNode merge3.ParentNodes().ForEach(func(c CommitNode) error { @@ -74,7 +79,7 @@ func testParents(c *C, nodeIndex CommitNodeIndex) { return nil }) - c.Assert(parents, HasLen, 3) + s.Len(parents, 3) expected := []string{ "ce275064ad67d51e99f026084e20827901a8361c", @@ -82,57 +87,57 @@ func testParents(c *C, nodeIndex CommitNodeIndex) { "a45273fe2d63300e1962a9e26a6b15c276cd7082", } for i, parent := range parents { - c.Assert(parent.ID().String(), Equals, expected[i]) + s.Equal(expected[i], parent.ID().String()) } } -func testCommitAndTree(c *C, nodeIndex CommitNodeIndex) { +func testCommitAndTree(s *CommitNodeSuite, nodeIndex CommitNodeIndex) { merge3node, err := nodeIndex.Get(plumbing.NewHash("6f6c5d2be7852c782be1dd13e36496dd7ad39560")) - c.Assert(err, IsNil) + s.NoError(err) merge3commit, err := merge3node.Commit() - c.Assert(err, IsNil) - c.Assert(merge3node.ID().String(), Equals, merge3commit.ID().String()) + s.NoError(err) + s.Equal(merge3commit.ID().String(), merge3node.ID().String()) tree, err := merge3node.Tree() - c.Assert(err, IsNil) - c.Assert(tree.ID().String(), Equals, merge3commit.TreeHash.String()) + s.NoError(err) + s.Equal(merge3commit.TreeHash.String(), tree.ID().String()) } -func (s *CommitNodeSuite) TestObjectGraph(c *C) { +func (s *CommitNodeSuite) TestObjectGraph() { f := fixtures.ByTag("commit-graph").One() storer := unpackRepository(f) nodeIndex := NewObjectCommitNodeIndex(storer) - testWalker(c, nodeIndex) - testParents(c, nodeIndex) - testCommitAndTree(c, nodeIndex) + testWalker(s, nodeIndex) + testParents(s, nodeIndex) + testCommitAndTree(s, nodeIndex) } -func (s *CommitNodeSuite) TestCommitGraph(c *C) { +func (s *CommitNodeSuite) TestCommitGraph() { f := fixtures.ByTag("commit-graph").One() storer := unpackRepository(f) reader, err := storer.Filesystem().Open(path.Join("objects", "info", "commit-graph")) - c.Assert(err, IsNil) + s.NoError(err) defer reader.Close() index, err := commitgraph.OpenFileIndex(reader) - c.Assert(err, IsNil) + s.NoError(err) defer index.Close() nodeIndex := NewGraphCommitNodeIndex(index, storer) - testWalker(c, nodeIndex) - testParents(c, nodeIndex) - testCommitAndTree(c, nodeIndex) + testWalker(s, nodeIndex) + testParents(s, nodeIndex) + testCommitAndTree(s, nodeIndex) } -func (s *CommitNodeSuite) TestMixedGraph(c *C) { +func (s *CommitNodeSuite) TestMixedGraph() { f := fixtures.ByTag("commit-graph").One() storer := unpackRepository(f) // Take the commit-graph file and copy it to memory index without the last commit reader, err := storer.Filesystem().Open(path.Join("objects", "info", "commit-graph")) - c.Assert(err, IsNil) + s.NoError(err) defer reader.Close() fileIndex, err := commitgraph.OpenFileIndex(reader) - c.Assert(err, IsNil) + s.NoError(err) defer fileIndex.Close() memoryIndex := commitgraph.NewMemoryIndex() @@ -141,13 +146,13 @@ func (s *CommitNodeSuite) TestMixedGraph(c *C) { for i, hash := range fileIndex.Hashes() { if hash.String() != "b9d69064b190e7aedccf84731ca1d917871f8a1c" { node, err := fileIndex.GetCommitDataByIndex(uint32(i)) - c.Assert(err, IsNil) + s.NoError(err) memoryIndex.Add(hash, node) } } nodeIndex := NewGraphCommitNodeIndex(memoryIndex, storer) - testWalker(c, nodeIndex) - testParents(c, nodeIndex) - testCommitAndTree(c, nodeIndex) + testWalker(s, nodeIndex) + testParents(s, nodeIndex) + testCommitAndTree(s, nodeIndex) } diff --git a/plumbing/object/commitgraph/commitnode_walker_author_order.go b/plumbing/object/commitgraph/commitnode_walker_author_order.go index f5b23cc51..bb5c4780a 100644 --- a/plumbing/object/commitgraph/commitnode_walker_author_order.go +++ b/plumbing/object/commitgraph/commitnode_walker_author_order.go @@ -1,7 +1,7 @@ package commitgraph import ( - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" "github.com/emirpasic/gods/trees/binaryheap" ) diff --git a/plumbing/object/commitgraph/commitnode_walker_ctime.go b/plumbing/object/commitgraph/commitnode_walker_ctime.go index 3ab9e6e87..fa81826e1 100644 --- a/plumbing/object/commitgraph/commitnode_walker_ctime.go +++ b/plumbing/object/commitgraph/commitnode_walker_ctime.go @@ -3,8 +3,8 @@ package commitgraph import ( "io" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" "github.com/emirpasic/gods/trees/binaryheap" ) diff --git a/plumbing/object/commitgraph/commitnode_walker_date_order.go b/plumbing/object/commitgraph/commitnode_walker_date_order.go index 659a4fa44..0ce322c0f 100644 --- a/plumbing/object/commitgraph/commitnode_walker_date_order.go +++ b/plumbing/object/commitgraph/commitnode_walker_date_order.go @@ -1,7 +1,7 @@ package commitgraph import ( - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" "github.com/emirpasic/gods/trees/binaryheap" ) diff --git a/plumbing/object/commitgraph/commitnode_walker_helper.go b/plumbing/object/commitgraph/commitnode_walker_helper.go index c54f6caae..31212bf32 100644 --- a/plumbing/object/commitgraph/commitnode_walker_helper.go +++ b/plumbing/object/commitgraph/commitnode_walker_helper.go @@ -3,7 +3,7 @@ package commitgraph import ( "math" - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" "github.com/emirpasic/gods/trees/binaryheap" ) diff --git a/plumbing/object/commitgraph/commitnode_walker_test.go b/plumbing/object/commitgraph/commitnode_walker_test.go index 1e09c0be5..6980898d3 100644 --- a/plumbing/object/commitgraph/commitnode_walker_test.go +++ b/plumbing/object/commitgraph/commitnode_walker_test.go @@ -2,33 +2,47 @@ package commitgraph import ( "strings" + "testing" - "github.com/go-git/go-git/v5/plumbing" - commitgraph "github.com/go-git/go-git/v5/plumbing/format/commitgraph/v2" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + commitgraph "github.com/jesseduffield/go-git/v5/plumbing/format/commitgraph/v2" + "github.com/jesseduffield/go-git/v5/plumbing/format/packfile" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/stretchr/testify/assert" - fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" + fixtures "github.com/go-git/go-git-fixtures/v5" ) -func (s *CommitNodeSuite) TestCommitNodeIter(c *C) { +func TestCommitNodeIter(t *testing.T) { + t.Parallel() + f := fixtures.ByTag("commit-graph-chain-2").One() - storer := unpackRepository(f) + storer := newUnpackRepository(f) index, err := commitgraph.OpenChainOrFileIndex(storer.Filesystem()) - c.Assert(err, IsNil) + assert.NoError(t, err) nodeIndex := NewGraphCommitNodeIndex(index, storer) head, err := nodeIndex.Get(plumbing.NewHash("ec6f456c0e8c7058a29611429965aa05c190b54b")) - c.Assert(err, IsNil) + assert.NoError(t, err) + + testTopoOrder(t, head) + testDateOrder(t, head) + testAuthorDateOrder(t, head) +} - testTopoOrder(c, head) - testDateOrder(c, head) - testAuthorDateOrder(c, head) +func newUnpackRepository(f *fixtures.Fixture) *filesystem.Storage { + storer := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) + p := f.Packfile() + defer p.Close() + packfile.UpdateObjectStorage(storer, p) + return storer } -func testTopoOrder(c *C, head CommitNode) { +func testTopoOrder(t *testing.T, head CommitNode) { iter := NewCommitNodeIterTopoOrder( head, nil, @@ -40,7 +54,8 @@ func testTopoOrder(c *C, head CommitNode) { commits = append(commits, c.ID().String()) return nil }) - c.Assert(commits, DeepEquals, strings.Split(`ec6f456c0e8c7058a29611429965aa05c190b54b + + assert.Equal(t, commits, strings.Split(`ec6f456c0e8c7058a29611429965aa05c190b54b d82f291cde9987322c8a0c81a325e1ba6159684c 3048d280d2d5b258d9e582a226ff4bbed34fd5c9 27aa8cdd2431068606741a589383c02c149ea625 @@ -80,7 +95,7 @@ c088fd6a7e1a38e9d5a9815265cb575bb08d08ff 5d7303c49ac984a9fec60523f2d5297682e16646`, "\n")) } -func testDateOrder(c *C, head CommitNode) { +func testDateOrder(t *testing.T, head CommitNode) { iter := NewCommitNodeIterDateOrder( head, nil, @@ -93,7 +108,7 @@ func testDateOrder(c *C, head CommitNode) { return nil }) - c.Assert(commits, DeepEquals, strings.Split(`ec6f456c0e8c7058a29611429965aa05c190b54b + assert.Equal(t, commits, strings.Split(`ec6f456c0e8c7058a29611429965aa05c190b54b 3048d280d2d5b258d9e582a226ff4bbed34fd5c9 d82f291cde9987322c8a0c81a325e1ba6159684c 27aa8cdd2431068606741a589383c02c149ea625 @@ -133,7 +148,7 @@ c088fd6a7e1a38e9d5a9815265cb575bb08d08ff 5d7303c49ac984a9fec60523f2d5297682e16646`, "\n")) } -func testAuthorDateOrder(c *C, head CommitNode) { +func testAuthorDateOrder(t *testing.T, head CommitNode) { iter := NewCommitNodeIterAuthorDateOrder( head, nil, @@ -146,7 +161,7 @@ func testAuthorDateOrder(c *C, head CommitNode) { return nil }) - c.Assert(commits, DeepEquals, strings.Split(`ec6f456c0e8c7058a29611429965aa05c190b54b + assert.Equal(t, commits, strings.Split(`ec6f456c0e8c7058a29611429965aa05c190b54b 3048d280d2d5b258d9e582a226ff4bbed34fd5c9 d82f291cde9987322c8a0c81a325e1ba6159684c 27aa8cdd2431068606741a589383c02c149ea625 diff --git a/plumbing/object/commitgraph/commitnode_walker_topo_order.go b/plumbing/object/commitgraph/commitnode_walker_topo_order.go index 29f4bb72e..88d4c8866 100644 --- a/plumbing/object/commitgraph/commitnode_walker_topo_order.go +++ b/plumbing/object/commitgraph/commitnode_walker_topo_order.go @@ -3,8 +3,8 @@ package commitgraph import ( "io" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" "github.com/emirpasic/gods/trees/binaryheap" ) diff --git a/plumbing/object/difftree.go b/plumbing/object/difftree.go index 7c2222702..a2dd582be 100644 --- a/plumbing/object/difftree.go +++ b/plumbing/object/difftree.go @@ -4,8 +4,8 @@ import ( "bytes" "context" - "github.com/go-git/go-git/v5/utils/merkletrie" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" + "github.com/jesseduffield/go-git/v5/utils/merkletrie" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" ) // DiffTree compares the content and mode of the blobs found via two diff --git a/plumbing/object/difftree_test.go b/plumbing/object/difftree_test.go index 04416c7ac..4eaaa4d5b 100644 --- a/plumbing/object/difftree_test.go +++ b/plumbing/object/difftree_test.go @@ -1,40 +1,46 @@ package object import ( + "fmt" "sort" + "testing" fixtures "github.com/go-git/go-git-fixtures/v4" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/filemode" - "github.com/go-git/go-git/v5/plumbing/format/packfile" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage/filesystem" - "github.com/go-git/go-git/v5/storage/memory" - "github.com/go-git/go-git/v5/utils/merkletrie" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/plumbing/format/packfile" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/jesseduffield/go-git/v5/utils/merkletrie" + "github.com/stretchr/testify/suite" ) -type DiffTreeSuite struct { +type DiffTreeFixtureSuite struct { fixtures.Suite +} + +type DiffTreeSuite struct { + suite.Suite + DiffTreeFixtureSuite Storer storer.EncodedObjectStorer Fixture *fixtures.Fixture cache map[string]storer.EncodedObjectStorer } -func (s *DiffTreeSuite) SetUpSuite(c *C) { +func (s *DiffTreeSuite) SetupSuite() { s.Fixture = fixtures.Basic().One() sto := filesystem.NewStorage(s.Fixture.DotGit(), cache.NewObjectLRUDefault()) s.Storer = sto s.cache = make(map[string]storer.EncodedObjectStorer) } -func (s *DiffTreeSuite) commitFromStorer(c *C, sto storer.EncodedObjectStorer, +func (s *DiffTreeSuite) commitFromStorer(sto storer.EncodedObjectStorer, h plumbing.Hash) *Commit { commit, err := GetCommit(sto, h) - c.Assert(err, IsNil) + s.NoError(err) return commit } @@ -57,34 +63,36 @@ func (s *DiffTreeSuite) storageFromPackfile(f *fixtures.Fixture) storer.EncodedO return storer } -var _ = Suite(&DiffTreeSuite{}) +func TestDiffTreeSuite(t *testing.T) { + suite.Run(t, new(DiffTreeSuite)) +} type expectChange struct { Action merkletrie.Action Name string } -func assertChanges(a Changes, c *C) { +func assertChanges(a Changes, s *DiffTreeSuite) { for _, changes := range a { action, err := changes.Action() - c.Assert(err, IsNil) + s.NoError(err) switch action { case merkletrie.Insert: - c.Assert(changes.From.Tree, IsNil) - c.Assert(changes.To.Tree, NotNil) + s.Nil(changes.From.Tree) + s.NotNil(changes.To.Tree) case merkletrie.Delete: - c.Assert(changes.From.Tree, NotNil) - c.Assert(changes.To.Tree, IsNil) + s.NotNil(changes.From.Tree) + s.Nil(changes.To.Tree) case merkletrie.Modify: - c.Assert(changes.From.Tree, NotNil) - c.Assert(changes.To.Tree, NotNil) + s.NotNil(changes.From.Tree) + s.NotNil(changes.To.Tree) default: - c.Fatalf("unknown action: %d", action) + s.Fail("unknown action:", action) } } } -func equalChanges(a Changes, b []expectChange, c *C) bool { +func equalChanges(a Changes, b []expectChange, s *DiffTreeSuite) bool { if len(a) != len(b) { return false } @@ -94,7 +102,7 @@ func equalChanges(a Changes, b []expectChange, c *C) bool { for i, va := range a { vb := b[i] action, err := va.Action() - c.Assert(err, IsNil) + s.NoError(err) if action != vb.Action || va.name() != vb.Name { return false } @@ -103,7 +111,7 @@ func equalChanges(a Changes, b []expectChange, c *C) bool { return true } -func (s *DiffTreeSuite) TestDiffTree(c *C) { +func (s *DiffTreeSuite) TestDiffTree() { for i, t := range []struct { repository string // the repo name as in localRepos commit1 string // the commit of the first tree @@ -318,37 +326,37 @@ func (s *DiffTreeSuite) TestDiffTree(c *C) { var tree1, tree2 *Tree var err error if t.commit1 != "" { - tree1, err = s.commitFromStorer(c, sto, + tree1, err = s.commitFromStorer(sto, plumbing.NewHash(t.commit1)).Tree() - c.Assert(err, IsNil, - Commentf("subtest %d: unable to retrieve tree from commit %s and repo %s: %s", i, t.commit1, t.repository, err)) + s.NoError(err, + fmt.Sprintf("subtest %d: unable to retrieve tree from commit %s and repo %s: %s", i, t.commit1, t.repository, err)) } if t.commit2 != "" { - tree2, err = s.commitFromStorer(c, sto, + tree2, err = s.commitFromStorer(sto, plumbing.NewHash(t.commit2)).Tree() - c.Assert(err, IsNil, - Commentf("subtest %d: unable to retrieve tree from commit %s and repo %s", i, t.commit2, t.repository, err)) + s.NoError(err, + fmt.Sprintf("subtest %d: unable to retrieve tree from commit %s and repo %s", i, t.commit2, t.repository)) } obtained, err := DiffTree(tree1, tree2) - c.Assert(err, IsNil, - Commentf("subtest %d: unable to calculate difftree: %s", i, err)) + s.NoError(err, + fmt.Sprintf("subtest %d: unable to calculate difftree: %s", i, err)) obtainedFromMethod, err := tree1.Diff(tree2) - c.Assert(err, IsNil, - Commentf("subtest %d: unable to calculate difftree: %s. Result calling Diff method from Tree object returns an error", i, err)) + s.NoError(err, + fmt.Sprintf("subtest %d: unable to calculate difftree: %s. Result calling Diff method from Tree object returns an error", i, err)) - c.Assert(obtained, DeepEquals, obtainedFromMethod) + s.Equal(obtainedFromMethod, obtained) - c.Assert(equalChanges(obtained, t.expected, c), Equals, true, - Commentf("subtest:%d\nrepo=%s\ncommit1=%s\ncommit2=%s\nexpected=%s\nobtained=%s", + s.True(equalChanges(obtained, t.expected, s), + fmt.Sprintf("subtest:%d\nrepo=%s\ncommit1=%s\ncommit2=%s\nexpected=%s\nobtained=%s", i, t.repository, t.commit1, t.commit2, t.expected, obtained)) - assertChanges(obtained, c) + assertChanges(obtained, s) } } -func (s *DiffTreeSuite) TestIssue279(c *C) { +func (s *DiffTreeSuite) TestIssue279() { // treeNoders should have the same hash when their mode is // filemode.Deprecated and filemode.Regular. a := &treeNoder{ @@ -359,17 +367,17 @@ func (s *DiffTreeSuite) TestIssue279(c *C) { hash: plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), mode: filemode.Deprecated, } - c.Assert(a.Hash(), DeepEquals, b.Hash()) + s.Equal(b.Hash(), a.Hash()) // yet, they should have different hashes if their contents change. aa := &treeNoder{ hash: plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"), mode: filemode.Regular, } - c.Assert(a.Hash(), Not(DeepEquals), aa.Hash()) + s.NotEqual(aa.Hash(), a.Hash()) bb := &treeNoder{ hash: plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"), mode: filemode.Deprecated, } - c.Assert(b.Hash(), Not(DeepEquals), bb.Hash()) + s.NotEqual(bb.Hash(), b.Hash()) } diff --git a/plumbing/object/file.go b/plumbing/object/file.go index 6cc5367d8..755f87859 100644 --- a/plumbing/object/file.go +++ b/plumbing/object/file.go @@ -5,10 +5,10 @@ import ( "io" "strings" - "github.com/go-git/go-git/v5/plumbing/filemode" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/utils/binary" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/utils/binary" + "github.com/jesseduffield/go-git/v5/utils/ioutil" ) // File represents git file objects. diff --git a/plumbing/object/file_test.go b/plumbing/object/file_test.go index ada6654f4..96f23c882 100644 --- a/plumbing/object/file_test.go +++ b/plumbing/object/file_test.go @@ -1,23 +1,32 @@ package object import ( + "fmt" "io" + "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/filemode" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) type FileSuite struct { + suite.Suite BaseObjectsSuite } -var _ = Suite(&FileSuite{}) +func TestFileSuite(t *testing.T) { + suite.Run(t, new(FileSuite)) +} + +func (s *FileSuite) SetupSuite() { + s.BaseObjectsSuite.SetupSuite(s.T()) +} type fileIterExpectedEntry struct { Name string @@ -42,31 +51,31 @@ var fileIterTests = []struct { }}, } -func (s *FileSuite) TestIter(c *C) { +func (s *FileSuite) TestIter() { for i, t := range fileIterTests { f := fixtures.ByURL(t.repo).One() sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) h := plumbing.NewHash(t.commit) commit, err := GetCommit(sto, h) - c.Assert(err, IsNil, Commentf("subtest %d: %v (%s)", i, err, t.commit)) + s.NoError(err, fmt.Sprintf("subtest %d: %v (%s)", i, err, t.commit)) tree, err := commit.Tree() - c.Assert(err, IsNil) + s.NoError(err) iter := NewFileIter(sto, tree) for k := 0; k < len(t.files); k++ { exp := t.files[k] file, err := iter.Next() - c.Assert(err, IsNil, Commentf("subtest %d, iter %d, err=%v", i, k, err)) - c.Assert(file.Mode, Equals, filemode.Regular) - c.Assert(file.Hash.IsZero(), Equals, false) - c.Assert(file.Hash, Equals, file.ID()) - c.Assert(file.Name, Equals, exp.Name, Commentf("subtest %d, iter %d, name=%s, expected=%s", i, k, file.Name, exp.Hash)) - c.Assert(file.Hash.String(), Equals, exp.Hash, Commentf("subtest %d, iter %d, hash=%v, expected=%s", i, k, file.Hash.String(), exp.Hash)) + s.NoError(err, fmt.Sprintf("subtest %d, iter %d, err=%v", i, k, err)) + s.Equal(filemode.Regular, file.Mode) + s.False(file.Hash.IsZero()) + s.Equal(file.ID(), file.Hash) + s.Equal(exp.Name, file.Name, fmt.Sprintf("subtest %d, iter %d, name=%s, expected=%s", i, k, file.Name, exp.Hash)) + s.Equal(exp.Hash, file.Hash.String(), fmt.Sprintf("subtest %d, iter %d, hash=%v, expected=%s", i, k, file.Hash.String(), exp.Hash)) } _, err = iter.Next() - c.Assert(err, Equals, io.EOF) + s.ErrorIs(err, io.EOF) } } @@ -103,20 +112,20 @@ hs_err_pid* }, } -func (s *FileSuite) TestContents(c *C) { +func (s *FileSuite) TestContents() { for i, t := range contentsTests { f := fixtures.ByURL(t.repo).One() sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) h := plumbing.NewHash(t.commit) commit, err := GetCommit(sto, h) - c.Assert(err, IsNil, Commentf("subtest %d: %v (%s)", i, err, t.commit)) + s.NoError(err, fmt.Sprintf("subtest %d: %v (%s)", i, err, t.commit)) file, err := commit.File(t.path) - c.Assert(err, IsNil) + s.NoError(err) content, err := file.Contents() - c.Assert(err, IsNil) - c.Assert(content, Equals, t.contents, Commentf( + s.NoError(err) + s.Equal(t.contents, content, fmt.Sprintf( "subtest %d: commit=%s, path=%s", i, t.commit, t.path)) } } @@ -156,20 +165,20 @@ var linesTests = []struct { }, } -func (s *FileSuite) TestLines(c *C) { +func (s *FileSuite) TestLines() { for i, t := range linesTests { f := fixtures.ByURL(t.repo).One() sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) h := plumbing.NewHash(t.commit) commit, err := GetCommit(sto, h) - c.Assert(err, IsNil, Commentf("subtest %d: %v (%s)", i, err, t.commit)) + s.NoError(err, fmt.Sprintf("subtest %d: %v (%s)", i, err, t.commit)) file, err := commit.File(t.path) - c.Assert(err, IsNil) + s.NoError(err) lines, err := file.Lines() - c.Assert(err, IsNil) - c.Assert(lines, DeepEquals, t.lines, Commentf( + s.NoError(err) + s.Equal(t.lines, lines, fmt.Sprintf( "subtest %d: commit=%s, path=%s", i, t.commit, t.path)) } } @@ -190,17 +199,17 @@ var ignoreEmptyDirEntriesTests = []struct { // // At least this test has a high chance of panicking if // we don't ignore empty dirs. -func (s *FileSuite) TestIgnoreEmptyDirEntries(c *C) { +func (s *FileSuite) TestIgnoreEmptyDirEntries() { for i, t := range ignoreEmptyDirEntriesTests { f := fixtures.ByURL(t.repo).One() sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) h := plumbing.NewHash(t.commit) commit, err := GetCommit(sto, h) - c.Assert(err, IsNil, Commentf("subtest %d: %v (%s)", i, err, t.commit)) + s.NoError(err, fmt.Sprintf("subtest %d: %v (%s)", i, err, t.commit)) tree, err := commit.Tree() - c.Assert(err, IsNil) + s.NoError(err) iter := tree.Files() defer iter.Close() @@ -211,13 +220,13 @@ func (s *FileSuite) TestIgnoreEmptyDirEntries(c *C) { } } -func (s *FileSuite) TestFileIter(c *C) { +func (s *FileSuite) TestFileIter() { hash := plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea") commit, err := GetCommit(s.Storer, hash) - c.Assert(err, IsNil) + s.NoError(err) tree, err := commit.Tree() - c.Assert(err, IsNil) + s.NoError(err) expected := []string{ ".gitignore", @@ -229,12 +238,12 @@ func (s *FileSuite) TestFileIter(c *C) { var count int i := tree.Files() i.ForEach(func(f *File) error { - c.Assert(f.Name, Equals, expected[count]) + s.Equal(expected[count], f.Name) count++ return nil }) - c.Assert(count, Equals, 4) + s.Equal(4, count) count = 0 i = tree.Files() @@ -243,19 +252,19 @@ func (s *FileSuite) TestFileIter(c *C) { return storer.ErrStop }) - c.Assert(count, Equals, 1) + s.Equal(1, count) } -func (s *FileSuite) TestFileIterSubmodule(c *C) { +func (s *FileSuite) TestFileIterSubmodule() { dotgit := fixtures.ByURL("https://github.com/git-fixtures/submodule.git").One().DotGit() st := filesystem.NewStorage(dotgit, cache.NewObjectLRUDefault()) hash := plumbing.NewHash("b685400c1f9316f350965a5993d350bc746b0bf4") commit, err := GetCommit(st, hash) - c.Assert(err, IsNil) + s.NoError(err) tree, err := commit.Tree() - c.Assert(err, IsNil) + s.NoError(err) expected := []string{ ".gitmodules", @@ -265,10 +274,10 @@ func (s *FileSuite) TestFileIterSubmodule(c *C) { var count int i := tree.Files() i.ForEach(func(f *File) error { - c.Assert(f.Name, Equals, expected[count]) + s.Equal(expected[count], f.Name) count++ return nil }) - c.Assert(count, Equals, 2) + s.Equal(2, count) } diff --git a/plumbing/object/merge_base.go b/plumbing/object/merge_base.go index b412361d0..33eb5d8b0 100644 --- a/plumbing/object/merge_base.go +++ b/plumbing/object/merge_base.go @@ -4,8 +4,8 @@ import ( "fmt" "sort" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" ) // errIsReachable is thrown when first commit is an ancestor of the second diff --git a/plumbing/object/merge_base_test.go b/plumbing/object/merge_base_test.go index 2a40f6e83..b845b73b5 100644 --- a/plumbing/object/merge_base_test.go +++ b/plumbing/object/merge_base_test.go @@ -3,13 +3,14 @@ package object import ( "fmt" "sort" + "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) func alphabeticSortCommits(commits []*Commit) { @@ -60,13 +61,16 @@ passed result M, N false Commits with unrelated history, will return false */ -var _ = Suite(&mergeBaseSuite{}) +func TestMergeBaseSuite(t *testing.T) { + suite.Run(t, new(mergeBaseSuite)) +} type mergeBaseSuite struct { + suite.Suite BaseObjectsSuite } -func (s *mergeBaseSuite) SetUpSuite(c *C) { +func (s *mergeBaseSuite) SetupSuite() { s.Fixture = fixtures.ByTag("merge-base").One() s.Storer = filesystem.NewStorage(s.Fixture.DotGit(), cache.NewObjectLRUDefault()) } @@ -96,7 +100,7 @@ var revisionIndex = map[string]plumbing.Hash{ "N^": plumbing.NewHash("b6e1fc8dad4f1068fb42774ec5fc65c065b2c312"), } -func (s *mergeBaseSuite) commitsFromRevs(c *C, revs []string) ([]*Commit, error) { +func (s *mergeBaseSuite) commitsFromRevs(revs []string) ([]*Commit, error) { var commits []*Commit for _, rev := range revs { hash, ok := revisionIndex[rev] @@ -104,7 +108,7 @@ func (s *mergeBaseSuite) commitsFromRevs(c *C, revs []string) ([]*Commit, error) return nil, fmt.Errorf("Revision not found '%s'", rev) } - commits = append(commits, s.commit(c, hash)) + commits = append(commits, s.commit(hash)) } return commits, nil @@ -112,211 +116,211 @@ func (s *mergeBaseSuite) commitsFromRevs(c *C, revs []string) ([]*Commit, error) // AssertMergeBase validates that the merge-base of the passed revs, // matches the expected result -func (s *mergeBaseSuite) AssertMergeBase(c *C, revs, expectedRevs []string) { - c.Assert(revs, HasLen, 2) +func (s *mergeBaseSuite) AssertMergeBase(revs, expectedRevs []string) { + s.Len(revs, 2) - commits, err := s.commitsFromRevs(c, revs) - c.Assert(err, IsNil) + commits, err := s.commitsFromRevs(revs) + s.NoError(err) results, err := commits[0].MergeBase(commits[1]) - c.Assert(err, IsNil) + s.NoError(err) - expected, err := s.commitsFromRevs(c, expectedRevs) - c.Assert(err, IsNil) + expected, err := s.commitsFromRevs(expectedRevs) + s.NoError(err) - c.Assert(results, HasLen, len(expected)) + s.Len(results, len(expected)) alphabeticSortCommits(results) alphabeticSortCommits(expected) for i, commit := range results { - c.Assert(commit.Hash.String(), Equals, expected[i].Hash.String()) + s.Equal(expected[i].Hash.String(), commit.Hash.String()) } } // AssertIndependents validates the independent commits of the passed list -func (s *mergeBaseSuite) AssertIndependents(c *C, revs, expectedRevs []string) { - commits, err := s.commitsFromRevs(c, revs) - c.Assert(err, IsNil) +func (s *mergeBaseSuite) AssertIndependents(revs, expectedRevs []string) { + commits, err := s.commitsFromRevs(revs) + s.NoError(err) results, err := Independents(commits) - c.Assert(err, IsNil) + s.NoError(err) - expected, err := s.commitsFromRevs(c, expectedRevs) - c.Assert(err, IsNil) + expected, err := s.commitsFromRevs(expectedRevs) + s.NoError(err) - c.Assert(results, HasLen, len(expected)) + s.Len(results, len(expected)) alphabeticSortCommits(results) alphabeticSortCommits(expected) for i, commit := range results { - c.Assert(commit.Hash.String(), Equals, expected[i].Hash.String()) + s.Equal(expected[i].Hash.String(), commit.Hash.String()) } } // AssertAncestor validates if the first rev is ancestor of the second one -func (s *mergeBaseSuite) AssertAncestor(c *C, revs []string, shouldBeAncestor bool) { - c.Assert(revs, HasLen, 2) +func (s *mergeBaseSuite) AssertAncestor(revs []string, shouldBeAncestor bool) { + s.Len(revs, 2) - commits, err := s.commitsFromRevs(c, revs) - c.Assert(err, IsNil) + commits, err := s.commitsFromRevs(revs) + s.NoError(err) isAncestor, err := commits[0].IsAncestor(commits[1]) - c.Assert(err, IsNil) - c.Assert(isAncestor, Equals, shouldBeAncestor) + s.NoError(err) + s.Equal(shouldBeAncestor, isAncestor) } // TestNoAncestorsWhenNoCommonHistory validates that merge-base returns no commits // when there is no common history (M, N -> none) -func (s *mergeBaseSuite) TestNoAncestorsWhenNoCommonHistory(c *C) { +func (s *mergeBaseSuite) TestNoAncestorsWhenNoCommonHistory() { revs := []string{"M", "N"} nothing := []string{} - s.AssertMergeBase(c, revs, nothing) + s.AssertMergeBase(revs, nothing) } // TestCommonAncestorInMergedOrphans validates that merge-base returns a common // ancestor in orphan branches when they where merged (A, B -> AB) -func (s *mergeBaseSuite) TestCommonAncestorInMergedOrphans(c *C) { +func (s *mergeBaseSuite) TestCommonAncestorInMergedOrphans() { revs := []string{"A", "B"} expectedRevs := []string{"AB"} - s.AssertMergeBase(c, revs, expectedRevs) + s.AssertMergeBase(revs, expectedRevs) } // TestMergeBaseWithSelf validates that merge-base between equal commits, returns // the same commit (A, A -> A) -func (s *mergeBaseSuite) TestMergeBaseWithSelf(c *C) { +func (s *mergeBaseSuite) TestMergeBaseWithSelf() { revs := []string{"A", "A"} expectedRevs := []string{"A"} - s.AssertMergeBase(c, revs, expectedRevs) + s.AssertMergeBase(revs, expectedRevs) } // TestMergeBaseWithAncestor validates that merge-base between a commit an its // ancestor returns the ancestor (Q, N -> N) -func (s *mergeBaseSuite) TestMergeBaseWithAncestor(c *C) { +func (s *mergeBaseSuite) TestMergeBaseWithAncestor() { revs := []string{"Q", "N"} expectedRevs := []string{"N"} - s.AssertMergeBase(c, revs, expectedRevs) + s.AssertMergeBase(revs, expectedRevs) } // TestDoubleCommonAncestorInCrossMerge validates that merge-base returns two // common ancestors when there are cross merges (C, D -> CD1, CD2) -func (s *mergeBaseSuite) TestDoubleCommonAncestorInCrossMerge(c *C) { +func (s *mergeBaseSuite) TestDoubleCommonAncestorInCrossMerge() { revs := []string{"C", "D"} expectedRevs := []string{"CD1", "CD2"} - s.AssertMergeBase(c, revs, expectedRevs) + s.AssertMergeBase(revs, expectedRevs) } // TestDoubleCommonInSubFeatureBranches validates that merge-base returns two // common ancestors when two branches where partially merged (G, Q -> GQ1, GQ2) -func (s *mergeBaseSuite) TestDoubleCommonInSubFeatureBranches(c *C) { +func (s *mergeBaseSuite) TestDoubleCommonInSubFeatureBranches() { revs := []string{"G", "Q"} expectedRevs := []string{"GQ1", "GQ2"} - s.AssertMergeBase(c, revs, expectedRevs) + s.AssertMergeBase(revs, expectedRevs) } // TestIndependentOnlyOne validates that Independents for one commit returns // that same commit (A -> A) -func (s *mergeBaseSuite) TestIndependentOnlyOne(c *C) { +func (s *mergeBaseSuite) TestIndependentOnlyOne() { revs := []string{"A"} expectedRevs := []string{"A"} - s.AssertIndependents(c, revs, expectedRevs) + s.AssertIndependents(revs, expectedRevs) } // TestIndependentOnlyRepeated validates that Independents for one repeated commit // returns that same commit (A, A, A -> A) -func (s *mergeBaseSuite) TestIndependentOnlyRepeated(c *C) { +func (s *mergeBaseSuite) TestIndependentOnlyRepeated() { revs := []string{"A", "A", "A"} expectedRevs := []string{"A"} - s.AssertIndependents(c, revs, expectedRevs) + s.AssertIndependents(revs, expectedRevs) } // TestIndependentWithRepeatedAncestors validates that Independents works well // when there are repeated ancestors (A, A, M, M, N -> A, N) -func (s *mergeBaseSuite) TestIndependentWithRepeatedAncestors(c *C) { +func (s *mergeBaseSuite) TestIndependentWithRepeatedAncestors() { revs := []string{"A", "A", "M", "M", "N"} expectedRevs := []string{"A", "N"} - s.AssertIndependents(c, revs, expectedRevs) + s.AssertIndependents(revs, expectedRevs) } // TestIndependentBeyondShortcut validates that Independents does not stop walking // in all paths when one of them is known (S, G, P -> S, G) -func (s *mergeBaseSuite) TestIndependentBeyondShortcut(c *C) { +func (s *mergeBaseSuite) TestIndependentBeyondShortcut() { revs := []string{"S", "G", "P"} expectedRevs := []string{"S", "G"} - s.AssertIndependents(c, revs, expectedRevs) + s.AssertIndependents(revs, expectedRevs) } // TestIndependentBeyondShortcutBis validates that Independents does not stop walking // in all paths when one of them is known (CD1, CD2, M, N -> CD1, CD2) -func (s *mergeBaseSuite) TestIndependentBeyondShortcutBis(c *C) { +func (s *mergeBaseSuite) TestIndependentBeyondShortcutBis() { revs := []string{"CD1", "CD2", "M", "N"} expectedRevs := []string{"CD1", "CD2"} - s.AssertIndependents(c, revs, expectedRevs) + s.AssertIndependents(revs, expectedRevs) } // TestIndependentWithPairOfAncestors validates that Independents excluded all // the ancestors (C, D, M, N -> C, D) -func (s *mergeBaseSuite) TestIndependentWithPairOfAncestors(c *C) { +func (s *mergeBaseSuite) TestIndependentWithPairOfAncestors() { revs := []string{"C", "D", "M", "N"} expectedRevs := []string{"C", "D"} - s.AssertIndependents(c, revs, expectedRevs) + s.AssertIndependents(revs, expectedRevs) } // TestIndependentAcrossCrossMerges validates that Independents works well // along cross merges (C, G, dev, M -> C, G, dev) -func (s *mergeBaseSuite) TestIndependentAcrossCrossMerges(c *C) { +func (s *mergeBaseSuite) TestIndependentAcrossCrossMerges() { revs := []string{"C", "G", "dev", "M", "N"} expectedRevs := []string{"C", "G", "dev"} - s.AssertIndependents(c, revs, expectedRevs) + s.AssertIndependents(revs, expectedRevs) } // TestIndependentChangingOrderRepetition validates that Independents works well // when the order and repetition is tricky (A, A^, A, N, N^ -> A, N) -func (s *mergeBaseSuite) TestIndependentChangingOrderRepetition(c *C) { +func (s *mergeBaseSuite) TestIndependentChangingOrderRepetition() { revs := []string{"A", "A^", "A", "N", "N^"} expectedRevs := []string{"A", "N"} - s.AssertIndependents(c, revs, expectedRevs) + s.AssertIndependents(revs, expectedRevs) } // TestIndependentChangingOrder validates that Independents works well // when the order is tricky (A^^^, A^, A^^, A, N -> A, N) -func (s *mergeBaseSuite) TestIndependentChangingOrder(c *C) { +func (s *mergeBaseSuite) TestIndependentChangingOrder() { revs := []string{"A^^^", "A^", "A^^", "A", "N"} expectedRevs := []string{"A", "N"} - s.AssertIndependents(c, revs, expectedRevs) + s.AssertIndependents(revs, expectedRevs) } // TestAncestor validates that IsAncestor returns true if walking from first // commit, through its parents, it can be reached the second ( A^^, A -> true ) -func (s *mergeBaseSuite) TestAncestor(c *C) { +func (s *mergeBaseSuite) TestAncestor() { revs := []string{"A^^", "A"} - s.AssertAncestor(c, revs, true) + s.AssertAncestor(revs, true) revs = []string{"A", "A^^"} - s.AssertAncestor(c, revs, false) + s.AssertAncestor(revs, false) } // TestAncestorBeyondMerges validates that IsAncestor returns true also if first can be // be reached from first one even crossing merge commits in between ( M, G -> true ) -func (s *mergeBaseSuite) TestAncestorBeyondMerges(c *C) { +func (s *mergeBaseSuite) TestAncestorBeyondMerges() { revs := []string{"M", "G"} - s.AssertAncestor(c, revs, true) + s.AssertAncestor(revs, true) revs = []string{"G", "M"} - s.AssertAncestor(c, revs, false) + s.AssertAncestor(revs, false) } // TestAncestorSame validates that IsAncestor returns both are the same ( A, A -> true ) -func (s *mergeBaseSuite) TestAncestorSame(c *C) { +func (s *mergeBaseSuite) TestAncestorSame() { revs := []string{"A", "A"} - s.AssertAncestor(c, revs, true) + s.AssertAncestor(revs, true) } // TestAncestorUnrelated validates that IsAncestor returns false when the passed commits // does not share any history, no matter the order used ( M, N -> false ) -func (s *mergeBaseSuite) TestAncestorUnrelated(c *C) { +func (s *mergeBaseSuite) TestAncestorUnrelated() { revs := []string{"M", "N"} - s.AssertAncestor(c, revs, false) + s.AssertAncestor(revs, false) revs = []string{"N", "M"} - s.AssertAncestor(c, revs, false) + s.AssertAncestor(revs, false) } diff --git a/plumbing/object/object.go b/plumbing/object/object.go index 13b1e91c9..d77b358e3 100644 --- a/plumbing/object/object.go +++ b/plumbing/object/object.go @@ -10,8 +10,8 @@ import ( "strconv" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" ) // ErrUnsupportedObject trigger when a non-supported object is being decoded. diff --git a/plumbing/object/object_test.go b/plumbing/object/object_test.go index c4fdb4c7a..f03b01aff 100644 --- a/plumbing/object/object_test.go +++ b/plumbing/object/object_test.go @@ -6,92 +6,102 @@ import ( "time" fixtures "github.com/go-git/go-git-fixtures/v4" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/filemode" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage/filesystem" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } +type BaseObjectsFixtureSuite struct { +} type BaseObjectsSuite struct { fixtures.Suite Storer storer.EncodedObjectStorer Fixture *fixtures.Fixture + t *testing.T } -func (s *BaseObjectsSuite) SetUpSuite(c *C) { +func (s *BaseObjectsSuite) SetupSuite(t *testing.T) { s.Fixture = fixtures.Basic().One() storer := filesystem.NewStorage(s.Fixture.DotGit(), cache.NewObjectLRUDefault()) s.Storer = storer + s.t = t } -func (s *BaseObjectsSuite) tag(c *C, h plumbing.Hash) *Tag { +func (s *BaseObjectsSuite) tag(h plumbing.Hash) *Tag { t, err := GetTag(s.Storer, h) - c.Assert(err, IsNil) + assert.NoError(s.t, err) return t } -func (s *BaseObjectsSuite) tree(c *C, h plumbing.Hash) *Tree { +func (s *BaseObjectsSuite) tree(h plumbing.Hash) *Tree { t, err := GetTree(s.Storer, h) - c.Assert(err, IsNil) + assert.NoError(s.t, err) return t } -func (s *BaseObjectsSuite) commit(c *C, h plumbing.Hash) *Commit { +func (s *BaseObjectsSuite) commit(h plumbing.Hash) *Commit { commit, err := GetCommit(s.Storer, h) - c.Assert(err, IsNil) + assert.NoError(s.t, err) return commit } type ObjectsSuite struct { + suite.Suite BaseObjectsSuite } -var _ = Suite(&ObjectsSuite{}) +func TestObjectsSuite(t *testing.T) { + suite.Run(t, new(ObjectsSuite)) +} + +func (s *ObjectsSuite) SetupSuite() { + s.BaseObjectsSuite.SetupSuite(s.T()) +} -func (s *ObjectsSuite) TestNewCommit(c *C) { +func (s *ObjectsSuite) TestNewCommit() { hash := plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69") - commit := s.commit(c, hash) + commit := s.commit(hash) - c.Assert(commit.Hash, Equals, commit.ID()) - c.Assert(commit.Hash.String(), Equals, "a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69") + s.Equal(commit.ID(), commit.Hash) + s.Equal("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69", commit.Hash.String()) tree, err := commit.Tree() - c.Assert(err, IsNil) - c.Assert(tree.Hash.String(), Equals, "c2d30fa8ef288618f65f6eed6e168e0d514886f4") + s.NoError(err) + s.Equal("c2d30fa8ef288618f65f6eed6e168e0d514886f4", tree.Hash.String()) parents := commit.Parents() parentCommit, err := parents.Next() - c.Assert(err, IsNil) - c.Assert(parentCommit.Hash.String(), Equals, "b029517f6300c2da0f4b651b8642506cd6aaf45d") + s.NoError(err) + s.Equal("b029517f6300c2da0f4b651b8642506cd6aaf45d", parentCommit.Hash.String()) parentCommit, err = parents.Next() - c.Assert(err, IsNil) - c.Assert(parentCommit.Hash.String(), Equals, "b8e471f58bcbca63b07bda20e428190409c2db47") - - c.Assert(commit.Author.Email, Equals, "mcuadros@gmail.com") - c.Assert(commit.Author.Name, Equals, "Máximo Cuadros") - c.Assert(commit.Author.When.Format(time.RFC3339), Equals, "2015-03-31T13:47:14+02:00") - c.Assert(commit.Committer.Email, Equals, "mcuadros@gmail.com") - c.Assert(commit.Message, Equals, "Merge pull request #1 from dripolles/feature\n\nCreating changelog") + s.NoError(err) + s.Equal("b8e471f58bcbca63b07bda20e428190409c2db47", parentCommit.Hash.String()) + + s.Equal("mcuadros@gmail.com", commit.Author.Email) + s.Equal("Máximo Cuadros", commit.Author.Name) + s.Equal("2015-03-31T13:47:14+02:00", commit.Author.When.Format(time.RFC3339)) + s.Equal("mcuadros@gmail.com", commit.Committer.Email) + s.Equal("Merge pull request #1 from dripolles/feature\n\nCreating changelog", commit.Message) } -func (s *ObjectsSuite) TestParseTree(c *C) { +func (s *ObjectsSuite) TestParseTree() { hash := plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c") tree, err := GetTree(s.Storer, hash) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(tree.Entries, HasLen, 8) + s.Len(tree.Entries, 8) tree.buildMap() - c.Assert(tree.m, HasLen, 8) - c.Assert(tree.m[".gitignore"].Name, Equals, ".gitignore") - c.Assert(tree.m[".gitignore"].Mode, Equals, filemode.Regular) - c.Assert(tree.m[".gitignore"].Hash.String(), Equals, "32858aad3c383ed1ff0a0f9bdf231d54a00c9e88") + s.Len(tree.m, 8) + s.Equal(".gitignore", tree.m[".gitignore"].Name) + s.Equal(filemode.Regular, tree.m[".gitignore"].Mode) + s.Equal("32858aad3c383ed1ff0a0f9bdf231d54a00c9e88", tree.m[".gitignore"].Hash.String()) count := 0 iter := tree.Files() @@ -100,17 +110,17 @@ func (s *ObjectsSuite) TestParseTree(c *C) { count++ if f.Name == "go/example.go" { reader, err := f.Reader() - c.Assert(err, IsNil) - defer func() { c.Assert(reader.Close(), IsNil) }() + s.NoError(err) + defer func() { s.Nil(reader.Close()) }() content, _ := io.ReadAll(reader) - c.Assert(content, HasLen, 2780) + s.Len(content, 2780) } } - c.Assert(count, Equals, 9) + s.Equal(9, count) } -func (s *ObjectsSuite) TestParseSignature(c *C) { +func (s *ObjectsSuite) TestParseSignature() { cases := map[string]Signature{ `Foo Bar 1257894000 +0100`: { Name: "Foo Bar", @@ -163,15 +173,15 @@ func (s *ObjectsSuite) TestParseSignature(c *C) { got := &Signature{} got.Decode([]byte(raw)) - c.Assert(got.Name, Equals, exp.Name) - c.Assert(got.Email, Equals, exp.Email) - c.Assert(got.When.Format(time.RFC3339), Equals, exp.When.Format(time.RFC3339)) + s.Equal(exp.Name, got.Name) + s.Equal(exp.Email, got.Email) + s.Equal(exp.When.Format(time.RFC3339), got.When.Format(time.RFC3339)) } } -func (s *ObjectsSuite) TestObjectIter(c *C) { +func (s *ObjectsSuite) TestObjectIter() { encIter, err := s.Storer.IterEncodedObjects(plumbing.AnyObject) - c.Assert(err, IsNil) + s.NoError(err) iter := NewObjectIter(s.Storer, encIter) objects := []Object{} @@ -180,11 +190,11 @@ func (s *ObjectsSuite) TestObjectIter(c *C) { return nil }) - c.Assert(len(objects) > 0, Equals, true) + s.True(len(objects) > 0) iter.Close() encIter, err = s.Storer.IterEncodedObjects(plumbing.AnyObject) - c.Assert(err, IsNil) + s.NoError(err) iter = NewObjectIter(s.Storer, encIter) i := 0 @@ -194,9 +204,9 @@ func (s *ObjectsSuite) TestObjectIter(c *C) { break } - c.Assert(err, IsNil) - c.Assert(o.ID(), Equals, objects[i].ID()) - c.Assert(o.Type(), Equals, objects[i].Type()) + s.NoError(err) + s.Equal(objects[i].ID(), o.ID()) + s.Equal(objects[i].Type(), o.Type()) i++ } diff --git a/plumbing/object/patch.go b/plumbing/object/patch.go index 3c61f626a..7a35b07ec 100644 --- a/plumbing/object/patch.go +++ b/plumbing/object/patch.go @@ -9,10 +9,10 @@ import ( "strconv" "strings" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/filemode" - fdiff "github.com/go-git/go-git/v5/plumbing/format/diff" - "github.com/go-git/go-git/v5/utils/diff" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + fdiff "github.com/jesseduffield/go-git/v5/plumbing/format/diff" + "github.com/jesseduffield/go-git/v5/utils/diff" dmp "github.com/sergi/go-diff/diffmatchpatch" ) diff --git a/plumbing/object/patch_stats_test.go b/plumbing/object/patch_stats_test.go index f393c30c4..6efebcd6a 100644 --- a/plumbing/object/patch_stats_test.go +++ b/plumbing/object/patch_stats_test.go @@ -1,54 +1,62 @@ package object_test import ( + "testing" "time" "github.com/go-git/go-billy/v5/memfs" "github.com/go-git/go-billy/v5/util" - "github.com/go-git/go-git/v5" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/storage/memory" + "github.com/jesseduffield/go-git/v5" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) -type PatchStatsSuite struct { +type PatchStatsFixtureSuite struct { fixtures.Suite } -var _ = Suite(&PatchStatsSuite{}) +type PatchStatsSuite struct { + suite.Suite + PatchStatsFixtureSuite +} + +func TestPatchStatsSuite(t *testing.T) { + suite.Run(t, new(PatchStatsSuite)) +} -func (s *PatchStatsSuite) TestStatsWithRename(c *C) { +func (s *PatchStatsSuite) TestStatsWithRename() { cm := &git.CommitOptions{ Author: &object.Signature{Name: "Foo", Email: "foo@example.local", When: time.Now()}, } fs := memfs.New() r, err := git.Init(memory.NewStorage(), fs) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) util.WriteFile(fs, "foo", []byte("foo\nbar\n"), 0644) _, err = w.Add("foo") - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Commit("foo\n", cm) - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Move("foo", "bar") - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Commit("rename foo to bar", cm) - c.Assert(err, IsNil) + s.NoError(err) commit, err := r.CommitObject(hash) - c.Assert(err, IsNil) + s.NoError(err) fileStats, err := commit.Stats() - c.Assert(err, IsNil) - c.Assert(fileStats[0].Name, Equals, "foo => bar") + s.NoError(err) + s.Equal("foo => bar", fileStats[0].Name) } diff --git a/plumbing/object/patch_test.go b/plumbing/object/patch_test.go index e0e63a507..2ede2be4a 100644 --- a/plumbing/object/patch_test.go +++ b/plumbing/object/patch_test.go @@ -1,32 +1,37 @@ package object import ( - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/storage/filesystem" + "testing" + + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) type PatchSuite struct { + suite.Suite BaseObjectsSuite } -var _ = Suite(&PatchSuite{}) +func TestPatchSuite(t *testing.T) { + suite.Run(t, new(PatchSuite)) +} -func (s *PatchSuite) TestStatsWithSubmodules(c *C) { +func (s *PatchSuite) TestStatsWithSubmodules() { storer := filesystem.NewStorage( fixtures.ByURL("https://github.com/git-fixtures/submodule.git").One().DotGit(), cache.NewObjectLRUDefault()) commit, err := GetCommit(storer, plumbing.NewHash("b685400c1f9316f350965a5993d350bc746b0bf4")) - c.Assert(err, IsNil) + s.NoError(err) tree, err := commit.Tree() - c.Assert(err, IsNil) + s.NoError(err) e, err := tree.entry("basic") - c.Assert(err, IsNil) + s.NoError(err) ch := &Change{ From: ChangeEntry{ @@ -42,11 +47,11 @@ func (s *PatchSuite) TestStatsWithSubmodules(c *C) { } p, err := getPatch("", ch) - c.Assert(err, IsNil) - c.Assert(p, NotNil) + s.NoError(err) + s.NotNil(p) } -func (s *PatchSuite) TestFileStatsString(c *C) { +func (s *PatchSuite) TestFileStatsString() { testCases := []struct { description string input FileStats @@ -151,7 +156,7 @@ func (s *PatchSuite) TestFileStatsString(c *C) { } for _, tc := range testCases { - c.Log("Executing test cases:", tc.description) - c.Assert(printStat(tc.input), Equals, tc.expected) + s.T().Log("Executing test cases:", tc.description) + s.Equal(tc.expected, printStat(tc.input)) } } diff --git a/plumbing/object/rename.go b/plumbing/object/rename.go index ad2b902c2..9d27dd1c3 100644 --- a/plumbing/object/rename.go +++ b/plumbing/object/rename.go @@ -6,10 +6,10 @@ import ( "sort" "strings" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/filemode" - "github.com/go-git/go-git/v5/utils/ioutil" - "github.com/go-git/go-git/v5/utils/merkletrie" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/utils/merkletrie" ) // DetectRenames detects the renames in the given changes on two trees with diff --git a/plumbing/object/rename_test.go b/plumbing/object/rename_test.go index 5dd77e865..8e30d9d72 100644 --- a/plumbing/object/rename_test.go +++ b/plumbing/object/rename_test.go @@ -3,20 +3,24 @@ package object import ( "path/filepath" "strings" + "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/filemode" - "github.com/go-git/go-git/v5/storage/memory" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/suite" ) type RenameSuite struct { + suite.Suite BaseObjectsSuite } -var _ = Suite(&RenameSuite{}) +func TestRenameSuite(t *testing.T) { + suite.Run(t, new(RenameSuite)) +} -func (s *RenameSuite) TestNameSimilarityScore(c *C) { +func (s *RenameSuite) TestNameSimilarityScore() { testCases := []struct { a, b string score int @@ -31,7 +35,7 @@ func (s *RenameSuite) TestNameSimilarityScore(c *C) { } for _, tt := range testCases { - c.Assert(nameSimilarityScore(tt.a, tt.b), Equals, tt.score) + s.Equal(tt.score, nameSimilarityScore(tt.a, tt.b)) } } @@ -42,299 +46,306 @@ const ( pathQ = "src/Q" ) -func (s *RenameSuite) TestExactRename_OneRename(c *C) { - a := makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo")) - b := makeDelete(c, makeFile(c, pathQ, filemode.Regular, "foo")) +func (s *RenameSuite) TestExactRename_OneRename() { + a := makeAdd(s, makeFile(s, pathA, filemode.Regular, "foo")) + b := makeDelete(s, makeFile(s, pathQ, filemode.Regular, "foo")) - result := detectRenames(c, Changes{a, b}, nil, 1) - assertRename(c, b, a, result[0]) + result := detectRenames(s, Changes{a, b}, nil, 1) + assertRename(s, b, a, result[0]) } -func (s *RenameSuite) TestExactRename_DifferentObjects(c *C) { - a := makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo")) - h := makeAdd(c, makeFile(c, pathH, filemode.Regular, "foo")) - q := makeDelete(c, makeFile(c, pathQ, filemode.Regular, "bar")) +func (s *RenameSuite) TestExactRename_DifferentObjects() { + a := makeAdd(s, makeFile(s, pathA, filemode.Regular, "foo")) + h := makeAdd(s, makeFile(s, pathH, filemode.Regular, "foo")) + q := makeDelete(s, makeFile(s, pathQ, filemode.Regular, "bar")) - result := detectRenames(c, Changes{a, h, q}, nil, 3) - c.Assert(result[0], DeepEquals, a) - c.Assert(result[1], DeepEquals, h) - c.Assert(result[2], DeepEquals, q) + result := detectRenames(s, Changes{a, h, q}, nil, 3) + s.Equal(a, result[0]) + s.Equal(h, result[1]) + s.Equal(q, result[2]) } -func (s *RenameSuite) TestExactRename_OneRenameOneModify(c *C) { - c1 := makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo")) - c2 := makeDelete(c, makeFile(c, pathQ, filemode.Regular, "foo")) - c3 := makeChange(c, - makeFile(c, pathH, filemode.Regular, "bar"), - makeFile(c, pathH, filemode.Regular, "bar"), +func (s *RenameSuite) TestExactRename_OneRenameOneModify() { + c1 := makeAdd(s, makeFile(s, pathA, filemode.Regular, "foo")) + c2 := makeDelete(s, makeFile(s, pathQ, filemode.Regular, "foo")) + c3 := makeChange(s, + makeFile(s, pathH, filemode.Regular, "bar"), + makeFile(s, pathH, filemode.Regular, "bar"), ) - result := detectRenames(c, Changes{c1, c2, c3}, nil, 2) - c.Assert(result[0], DeepEquals, c3) - assertRename(c, c2, c1, result[1]) + result := detectRenames(s, Changes{c1, c2, c3}, nil, 2) + s.Equal(c3, result[0]) + assertRename(s, c2, c1, result[1]) } -func (s *RenameSuite) TestExactRename_ManyRenames(c *C) { - c1 := makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo")) - c2 := makeDelete(c, makeFile(c, pathQ, filemode.Regular, "foo")) - c3 := makeAdd(c, makeFile(c, pathH, filemode.Regular, "bar")) - c4 := makeDelete(c, makeFile(c, pathB, filemode.Regular, "bar")) +func (s *RenameSuite) TestExactRename_ManyRenames() { + c1 := makeAdd(s, makeFile(s, pathA, filemode.Regular, "foo")) + c2 := makeDelete(s, makeFile(s, pathQ, filemode.Regular, "foo")) + c3 := makeAdd(s, makeFile(s, pathH, filemode.Regular, "bar")) + c4 := makeDelete(s, makeFile(s, pathB, filemode.Regular, "bar")) - result := detectRenames(c, Changes{c1, c2, c3, c4}, nil, 2) - assertRename(c, c4, c3, result[0]) - assertRename(c, c2, c1, result[1]) + result := detectRenames(s, Changes{c1, c2, c3, c4}, nil, 2) + assertRename(s, c4, c3, result[0]) + assertRename(s, c2, c1, result[1]) } -func (s *RenameSuite) TestExactRename_MultipleIdenticalDeletes(c *C) { +func (s *RenameSuite) TestExactRename_MultipleIdenticalDeletes() { changes := Changes{ - makeDelete(c, makeFile(c, pathA, filemode.Regular, "foo")), - makeDelete(c, makeFile(c, pathB, filemode.Regular, "foo")), - makeDelete(c, makeFile(c, pathH, filemode.Regular, "foo")), - makeAdd(c, makeFile(c, pathQ, filemode.Regular, "foo")), + makeDelete(s, makeFile(s, pathA, filemode.Regular, "foo")), + makeDelete(s, makeFile(s, pathB, filemode.Regular, "foo")), + makeDelete(s, makeFile(s, pathH, filemode.Regular, "foo")), + makeAdd(s, makeFile(s, pathQ, filemode.Regular, "foo")), } - result := detectRenames(c, changes, nil, 3) - assertRename(c, changes[0], changes[3], result[0]) - c.Assert(result[1], DeepEquals, changes[1]) - c.Assert(result[2], DeepEquals, changes[2]) + result := detectRenames(s, changes, nil, 3) + assertRename(s, changes[0], changes[3], result[0]) + s.Equal(changes[1], result[1]) + s.Equal(changes[2], result[2]) } -func (s *RenameSuite) TestRenameExact_PathBreaksTie(c *C) { +func (s *RenameSuite) TestRenameExact_PathBreaksTie() { changes := Changes{ - makeAdd(c, makeFile(c, "src/com/foo/a.java", filemode.Regular, "foo")), - makeDelete(c, makeFile(c, "src/com/foo/b.java", filemode.Regular, "foo")), - makeAdd(c, makeFile(c, "c.txt", filemode.Regular, "foo")), - makeDelete(c, makeFile(c, "d.txt", filemode.Regular, "foo")), - makeAdd(c, makeFile(c, "the_e_file.txt", filemode.Regular, "foo")), + makeAdd(s, makeFile(s, "src/com/foo/a.java", filemode.Regular, "foo")), + makeDelete(s, makeFile(s, "src/com/foo/b.java", filemode.Regular, "foo")), + makeAdd(s, makeFile(s, "c.txt", filemode.Regular, "foo")), + makeDelete(s, makeFile(s, "d.txt", filemode.Regular, "foo")), + makeAdd(s, makeFile(s, "the_e_file.txt", filemode.Regular, "foo")), } // Add out of order to avoid first-match succeeding - result := detectRenames(c, Changes{ + result := detectRenames(s, Changes{ changes[0], changes[3], changes[4], changes[1], changes[2], }, nil, 3) - assertRename(c, changes[3], changes[2], result[0]) - assertRename(c, changes[1], changes[0], result[1]) - c.Assert(result[2], DeepEquals, changes[4]) + assertRename(s, changes[3], changes[2], result[0]) + assertRename(s, changes[1], changes[0], result[1]) + s.Equal(changes[4], result[2]) } -func (s *RenameSuite) TestExactRename_OneDeleteManyAdds(c *C) { +func (s *RenameSuite) TestExactRename_OneDeleteManyAdds() { changes := Changes{ - makeAdd(c, makeFile(c, "src/com/foo/a.java", filemode.Regular, "foo")), - makeAdd(c, makeFile(c, "src/com/foo/b.java", filemode.Regular, "foo")), - makeAdd(c, makeFile(c, "c.txt", filemode.Regular, "foo")), - makeDelete(c, makeFile(c, "d.txt", filemode.Regular, "foo")), + makeAdd(s, makeFile(s, "src/com/foo/a.java", filemode.Regular, "foo")), + makeAdd(s, makeFile(s, "src/com/foo/b.java", filemode.Regular, "foo")), + makeAdd(s, makeFile(s, "c.txt", filemode.Regular, "foo")), + makeDelete(s, makeFile(s, "d.txt", filemode.Regular, "foo")), } - result := detectRenames(c, changes, nil, 3) - assertRename(c, changes[3], changes[2], result[0]) - c.Assert(result[1], DeepEquals, changes[0]) - c.Assert(result[2], DeepEquals, changes[1]) + result := detectRenames(s, changes, nil, 3) + assertRename(s, changes[3], changes[2], result[0]) + s.Equal(changes[0], result[1]) + s.Equal(changes[1], result[2]) } -func (s *RenameSuite) TestExactRename_UnstagedFile(c *C) { +func (s *RenameSuite) TestExactRename_UnstagedFile() { changes := Changes{ - makeDelete(c, makeFile(c, pathA, filemode.Regular, "foo")), - makeAdd(c, makeFile(c, pathB, filemode.Regular, "foo")), + makeDelete(s, makeFile(s, pathA, filemode.Regular, "foo")), + makeAdd(s, makeFile(s, pathB, filemode.Regular, "foo")), } - result := detectRenames(c, changes, nil, 1) - assertRename(c, changes[0], changes[1], result[0]) + result := detectRenames(s, changes, nil, 1) + assertRename(s, changes[0], changes[1], result[0]) } -func (s *RenameSuite) TestContentRename_OnePair(c *C) { +func (s *RenameSuite) TestContentRename_OnePair() { changes := Changes{ - makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo\nbar\nbaz\nblarg\n")), - makeDelete(c, makeFile(c, pathA, filemode.Regular, "foo\nbar\nbaz\nblah\n")), + makeAdd(s, makeFile(s, pathA, filemode.Regular, "foo\nbar\nbaz\nblarg\n")), + makeDelete(s, makeFile(s, pathA, filemode.Regular, "foo\nbar\nbaz\nblah\n")), } - result := detectRenames(c, changes, nil, 1) - assertRename(c, changes[1], changes[0], result[0]) + result := detectRenames(s, changes, nil, 1) + assertRename(s, changes[1], changes[0], result[0]) } -func (s *RenameSuite) TestContentRename_OneRenameTwoUnrelatedFiles(c *C) { +func (s *RenameSuite) TestContentRename_OneRenameTwoUnrelatedFiles() { changes := Changes{ - makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo\nbar\nbaz\nblarg\n")), - makeDelete(c, makeFile(c, pathQ, filemode.Regular, "foo\nbar\nbaz\nblah\n")), - makeAdd(c, makeFile(c, pathB, filemode.Regular, "some\nsort\nof\ntext\n")), - makeDelete(c, makeFile(c, pathH, filemode.Regular, "completely\nunrelated\ntext\n")), + makeAdd(s, makeFile(s, pathA, filemode.Regular, "foo\nbar\nbaz\nblarg\n")), + makeDelete(s, makeFile(s, pathQ, filemode.Regular, "foo\nbar\nbaz\nblah\n")), + makeAdd(s, makeFile(s, pathB, filemode.Regular, "some\nsort\nof\ntext\n")), + makeDelete(s, makeFile(s, pathH, filemode.Regular, "completely\nunrelated\ntext\n")), } - result := detectRenames(c, changes, nil, 3) - c.Assert(result[0], DeepEquals, changes[2]) - c.Assert(result[1], DeepEquals, changes[3]) - assertRename(c, changes[1], changes[0], result[2]) + result := detectRenames(s, changes, nil, 3) + s.Equal(changes[2], result[0]) + s.Equal(changes[3], result[1]) + assertRename(s, changes[1], changes[0], result[2]) } -func (s *RenameSuite) TestContentRename_LastByteDifferent(c *C) { +func (s *RenameSuite) TestContentRename_LastByteDifferent() { changes := Changes{ - makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo\nbar\na")), - makeDelete(c, makeFile(c, pathQ, filemode.Regular, "foo\nbar\nb")), + makeAdd(s, makeFile(s, pathA, filemode.Regular, "foo\nbar\na")), + makeDelete(s, makeFile(s, pathQ, filemode.Regular, "foo\nbar\nb")), } - result := detectRenames(c, changes, nil, 1) - assertRename(c, changes[1], changes[0], result[0]) + result := detectRenames(s, changes, nil, 1) + assertRename(s, changes[1], changes[0], result[0]) } -func (s *RenameSuite) TestContentRename_NewlinesOnly(c *C) { +func (s *RenameSuite) TestContentRename_NewlinesOnly() { changes := Changes{ - makeAdd(c, makeFile(c, pathA, filemode.Regular, strings.Repeat("\n", 3))), - makeDelete(c, makeFile(c, pathQ, filemode.Regular, strings.Repeat("\n", 4))), + makeAdd(s, makeFile(s, pathA, filemode.Regular, strings.Repeat("\n", 3))), + makeDelete(s, makeFile(s, pathQ, filemode.Regular, strings.Repeat("\n", 4))), } - result := detectRenames(c, changes, nil, 1) - assertRename(c, changes[1], changes[0], result[0]) + result := detectRenames(s, changes, nil, 1) + assertRename(s, changes[1], changes[0], result[0]) } -func (s *RenameSuite) TestContentRename_SameContentMultipleTimes(c *C) { +func (s *RenameSuite) TestContentRename_SameContentMultipleTimes() { changes := Changes{ - makeAdd(c, makeFile(c, pathA, filemode.Regular, "a\na\na\na\n")), - makeDelete(c, makeFile(c, pathQ, filemode.Regular, "a\na\na\n")), + makeAdd(s, makeFile(s, pathA, filemode.Regular, "a\na\na\na\n")), + makeDelete(s, makeFile(s, pathQ, filemode.Regular, "a\na\na\n")), } - result := detectRenames(c, changes, nil, 1) - assertRename(c, changes[1], changes[0], result[0]) + result := detectRenames(s, changes, nil, 1) + assertRename(s, changes[1], changes[0], result[0]) } -func (s *RenameSuite) TestContentRename_OnePairRenameScore50(c *C) { +func (s *RenameSuite) TestContentRename_OnePairRenameScore50() { changes := Changes{ - makeAdd(c, makeFile(c, pathA, filemode.Regular, "ab\nab\nab\nac\nad\nae\n")), - makeDelete(c, makeFile(c, pathQ, filemode.Regular, "ac\nab\nab\nab\naa\na0\na1\n")), + makeAdd(s, makeFile(s, pathA, filemode.Regular, "ab\nab\nab\nac\nad\nae\n")), + makeDelete(s, makeFile(s, pathQ, filemode.Regular, "ac\nab\nab\nab\naa\na0\na1\n")), } - result := detectRenames(c, changes, &DiffTreeOptions{RenameScore: 50}, 1) - assertRename(c, changes[1], changes[0], result[0]) + result := detectRenames(s, changes, &DiffTreeOptions{RenameScore: 50}, 1) + assertRename(s, changes[1], changes[0], result[0]) } -func (s *RenameSuite) TestNoRenames_SingleByteFiles(c *C) { +func (s *RenameSuite) TestNoRenames_SingleByteFiles() { changes := Changes{ - makeAdd(c, makeFile(c, pathA, filemode.Regular, "a")), - makeAdd(c, makeFile(c, pathQ, filemode.Regular, "b")), + makeAdd(s, makeFile(s, pathA, filemode.Regular, "a")), + makeAdd(s, makeFile(s, pathQ, filemode.Regular, "b")), } - result := detectRenames(c, changes, nil, 2) - c.Assert(result[0], DeepEquals, changes[0]) - c.Assert(result[1], DeepEquals, changes[1]) + result := detectRenames(s, changes, nil, 2) + s.Equal(changes[0], result[0]) + s.Equal(changes[1], result[1]) } -func (s *RenameSuite) TestNoRenames_EmptyFile(c *C) { +func (s *RenameSuite) TestNoRenames_EmptyFile() { changes := Changes{ - makeAdd(c, makeFile(c, pathA, filemode.Regular, "")), + makeAdd(s, makeFile(s, pathA, filemode.Regular, "")), } - result := detectRenames(c, changes, nil, 1) - c.Assert(result[0], DeepEquals, changes[0]) + result := detectRenames(s, changes, nil, 1) + s.Equal(changes[0], result[0]) } -func (s *RenameSuite) TestNoRenames_EmptyFile2(c *C) { +func (s *RenameSuite) TestNoRenames_EmptyFile2() { changes := Changes{ - makeAdd(c, makeFile(c, pathA, filemode.Regular, "")), - makeDelete(c, makeFile(c, pathQ, filemode.Regular, "blah")), + makeAdd(s, makeFile(s, pathA, filemode.Regular, "")), + makeDelete(s, makeFile(s, pathQ, filemode.Regular, "blah")), } - result := detectRenames(c, changes, nil, 2) - c.Assert(result[0], DeepEquals, changes[0]) - c.Assert(result[1], DeepEquals, changes[1]) + result := detectRenames(s, changes, nil, 2) + s.Equal(changes[0], result[0]) + s.Equal(changes[1], result[1]) } -func (s *RenameSuite) TestNoRenames_SymlinkAndFile(c *C) { +func (s *RenameSuite) TestNoRenames_SymlinkAndFile() { changes := Changes{ - makeAdd(c, makeFile(c, pathA, filemode.Regular, "src/dest")), - makeDelete(c, makeFile(c, pathQ, filemode.Symlink, "src/dest")), + makeAdd(s, makeFile(s, pathA, filemode.Regular, "src/dest")), + makeDelete(s, makeFile(s, pathQ, filemode.Symlink, "src/dest")), } - result := detectRenames(c, changes, nil, 2) - c.Assert(result[0], DeepEquals, changes[0]) - c.Assert(result[1], DeepEquals, changes[1]) + result := detectRenames(s, changes, nil, 2) + s.Equal(changes[0], result[0]) + s.Equal(changes[1], result[1]) } -func (s *RenameSuite) TestNoRenames_SymlinkAndFileSamePath(c *C) { +func (s *RenameSuite) TestNoRenames_SymlinkAndFileSamePath() { changes := Changes{ - makeAdd(c, makeFile(c, pathA, filemode.Regular, "src/dest")), - makeDelete(c, makeFile(c, pathA, filemode.Symlink, "src/dest")), + makeAdd(s, makeFile(s, pathA, filemode.Regular, "src/dest")), + makeDelete(s, makeFile(s, pathA, filemode.Symlink, "src/dest")), } - result := detectRenames(c, changes, nil, 2) - c.Assert(result[0], DeepEquals, changes[0]) - c.Assert(result[1], DeepEquals, changes[1]) + result := detectRenames(s, changes, nil, 2) + s.Equal(changes[0], result[0]) + s.Equal(changes[1], result[1]) } -func (s *RenameSuite) TestRenameLimit(c *C) { +func (s *RenameSuite) TestRenameLimit() { changes := Changes{ - makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo\nbar\nbaz\nblarg\n")), - makeDelete(c, makeFile(c, pathB, filemode.Regular, "foo\nbar\nbaz\nblah\n")), - makeAdd(c, makeFile(c, pathH, filemode.Regular, "a\nb\nc\nd\n")), - makeDelete(c, makeFile(c, pathQ, filemode.Regular, "a\nb\nc\n")), + makeAdd(s, makeFile(s, pathA, filemode.Regular, "foo\nbar\nbaz\nblarg\n")), + makeDelete(s, makeFile(s, pathB, filemode.Regular, "foo\nbar\nbaz\nblah\n")), + makeAdd(s, makeFile(s, pathH, filemode.Regular, "a\nb\nc\nd\n")), + makeDelete(s, makeFile(s, pathQ, filemode.Regular, "a\nb\nc\n")), } - result := detectRenames(c, changes, &DiffTreeOptions{RenameLimit: 1}, 4) + result := detectRenames(s, changes, &DiffTreeOptions{RenameLimit: 1}, 4) for i, res := range result { - c.Assert(res, DeepEquals, changes[i]) + s.Equal(changes[i], res) } } -func (s *RenameSuite) TestRenameExactManyAddsManyDeletesNoGaps(c *C) { +func (s *RenameSuite) TestRenameExactManyAddsManyDeletesNoGaps() { content := "a" detector := &renameDetector{ added: []*Change{ - makeAdd(c, makeFile(c, pathA, filemode.Regular, content)), - makeAdd(c, makeFile(c, pathQ, filemode.Regular, content)), - makeAdd(c, makeFile(c, "something", filemode.Regular, content)), + makeAdd(s, makeFile(s, pathA, filemode.Regular, content)), + makeAdd(s, makeFile(s, pathQ, filemode.Regular, content)), + makeAdd(s, makeFile(s, "something", filemode.Regular, content)), }, deleted: []*Change{ - makeDelete(c, makeFile(c, pathA, filemode.Regular, content)), - makeDelete(c, makeFile(c, pathB, filemode.Regular, content)), - makeDelete(c, makeFile(c, "foo/bar/other", filemode.Regular, content)), + makeDelete(s, makeFile(s, pathA, filemode.Regular, content)), + makeDelete(s, makeFile(s, pathB, filemode.Regular, content)), + makeDelete(s, makeFile(s, "foo/bar/other", filemode.Regular, content)), }, } detector.detectExactRenames() for _, added := range detector.added { - c.Assert(added, NotNil) + s.NotNil(added) } for _, deleted := range detector.deleted { - c.Assert(deleted, NotNil) + s.NotNil(deleted) } } -func detectRenames(c *C, changes Changes, opts *DiffTreeOptions, expectedResults int) Changes { +func detectRenames(s *RenameSuite, changes Changes, opts *DiffTreeOptions, expectedResults int) Changes { result, err := DetectRenames(changes, opts) - c.Assert(err, IsNil) - c.Assert(result, HasLen, expectedResults) + s.NoError(err) + s.Len(result, expectedResults) return result } -func assertRename(c *C, from, to *Change, rename *Change) { - c.Assert(&Change{From: from.From, To: to.To}, DeepEquals, rename) +func assertRename(s *RenameSuite, from, to *Change, rename *Change) { + s.Equal(rename, &Change{From: from.From, To: to.To}) } type SimilarityIndexSuite struct { + suite.Suite BaseObjectsSuite } -var _ = Suite(&SimilarityIndexSuite{}) +func TestSimilarityIndexSuite(t *testing.T) { + suite.Run(t, new(SimilarityIndexSuite)) +} + +func (s *SimilarityIndexSuite) SetupSuite() { + s.BaseObjectsSuite.SetupSuite(s.T()) +} -func (s *SimilarityIndexSuite) TestScoreFiles(c *C) { - tree := s.tree(c, plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")) +func (s *SimilarityIndexSuite) TestScoreFiles() { + tree := s.tree(plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")) binary, err := tree.File("binary.jpg") - c.Assert(err, IsNil) + s.NoError(err) binIndex, err := fileSimilarityIndex(binary) - c.Assert(err, IsNil) + s.NoError(err) long, err := tree.File("json/long.json") - c.Assert(err, IsNil) + s.NoError(err) longIndex, err := fileSimilarityIndex(long) - c.Assert(err, IsNil) + s.NoError(err) short, err := tree.File("json/short.json") - c.Assert(err, IsNil) + s.NoError(err) shortIndex, err := fileSimilarityIndex(short) - c.Assert(err, IsNil) + s.NoError(err) php, err := tree.File("php/crappy.php") - c.Assert(err, IsNil) + s.NoError(err) phpIndex, err := fileSimilarityIndex(php) - c.Assert(err, IsNil) + s.NoError(err) testCases := []struct { src, dst *similarityIndex @@ -349,95 +360,95 @@ func (s *SimilarityIndexSuite) TestScoreFiles(c *C) { for _, tt := range testCases { score := tt.src.score(tt.dst, 10000) - c.Assert(score, Equals, tt.expectedScore) + s.Equal(tt.expectedScore, score) } } -func (s *SimilarityIndexSuite) TestHashContent(c *C) { - idx := textIndex(c, "A\n"+ +func (s *SimilarityIndexSuite) TestHashContent() { + idx := textIndex(s, "A\n"+ "B\n"+ "D\n"+ "B\n") - keyA := keyFor(c, "A\n") - keyB := keyFor(c, "B\n") - keyD := keyFor(c, "D\n") + keyA := keyFor(s, "A\n") + keyB := keyFor(s, "B\n") + keyD := keyFor(s, "D\n") - c.Assert(keyA, Not(Equals), keyB) - c.Assert(keyA, Not(Equals), keyD) - c.Assert(keyD, Not(Equals), keyB) + s.NotEqual(keyB, keyA) + s.NotEqual(keyD, keyA) + s.NotEqual(keyB, keyD) - c.Assert(idx.numHashes, Equals, 3) - c.Assert(idx.hashes[findIndex(idx, keyA)].count(), Equals, uint64(2)) - c.Assert(idx.hashes[findIndex(idx, keyB)].count(), Equals, uint64(4)) - c.Assert(idx.hashes[findIndex(idx, keyD)].count(), Equals, uint64(2)) + s.Equal(3, idx.numHashes) + s.Equal(uint64(2), idx.hashes[findIndex(idx, keyA)].count()) + s.Equal(uint64(4), idx.hashes[findIndex(idx, keyB)].count()) + s.Equal(uint64(2), idx.hashes[findIndex(idx, keyD)].count()) } -func (s *SimilarityIndexSuite) TestCommonSameFiles(c *C) { +func (s *SimilarityIndexSuite) TestCommonSameFiles() { content := "A\n" + "B\n" + "D\n" + "B\n" - src := textIndex(c, content) - dst := textIndex(c, content) + src := textIndex(s, content) + dst := textIndex(s, content) - c.Assert(src.common(dst), Equals, uint64(8)) - c.Assert(dst.common(src), Equals, uint64(8)) + s.Equal(uint64(8), src.common(dst)) + s.Equal(uint64(8), dst.common(src)) - c.Assert(src.score(dst, 100), Equals, 100) - c.Assert(dst.score(src, 100), Equals, 100) + s.Equal(100, src.score(dst, 100)) + s.Equal(100, dst.score(src, 100)) } -func (s *SimilarityIndexSuite) TestCommonSameFilesCR(c *C) { +func (s *SimilarityIndexSuite) TestCommonSameFilesCR() { content := "A\r\n" + "B\r\n" + "D\r\n" + "B\r\n" - src := textIndex(c, content) - dst := textIndex(c, strings.ReplaceAll(content, "\r", "")) + src := textIndex(s, content) + dst := textIndex(s, strings.ReplaceAll(content, "\r", "")) - c.Assert(src.common(dst), Equals, uint64(8)) - c.Assert(dst.common(src), Equals, uint64(8)) + s.Equal(uint64(8), src.common(dst)) + s.Equal(uint64(8), dst.common(src)) - c.Assert(src.score(dst, 100), Equals, 100) - c.Assert(dst.score(src, 100), Equals, 100) + s.Equal(100, src.score(dst, 100)) + s.Equal(100, dst.score(src, 100)) } -func (s *SimilarityIndexSuite) TestCommonEmptyFiles(c *C) { - src := textIndex(c, "") - dst := textIndex(c, "") +func (s *SimilarityIndexSuite) TestCommonEmptyFiles() { + src := textIndex(s, "") + dst := textIndex(s, "") - c.Assert(src.common(dst), Equals, uint64(0)) - c.Assert(dst.common(src), Equals, uint64(0)) + s.Equal(uint64(0), src.common(dst)) + s.Equal(uint64(0), dst.common(src)) } -func (s *SimilarityIndexSuite) TestCommonTotallyDifferentFiles(c *C) { - src := textIndex(c, "A\n") - dst := textIndex(c, "D\n") +func (s *SimilarityIndexSuite) TestCommonTotallyDifferentFiles() { + src := textIndex(s, "A\n") + dst := textIndex(s, "D\n") - c.Assert(src.common(dst), Equals, uint64(0)) - c.Assert(dst.common(src), Equals, uint64(0)) + s.Equal(uint64(0), src.common(dst)) + s.Equal(uint64(0), dst.common(src)) } -func (s *SimilarityIndexSuite) TestSimilarity75(c *C) { - src := textIndex(c, "A\nB\nC\nD\n") - dst := textIndex(c, "A\nB\nC\nQ\n") +func (s *SimilarityIndexSuite) TestSimilarity75() { + src := textIndex(s, "A\nB\nC\nD\n") + dst := textIndex(s, "A\nB\nC\nQ\n") - c.Assert(src.common(dst), Equals, uint64(6)) - c.Assert(dst.common(src), Equals, uint64(6)) + s.Equal(uint64(6), src.common(dst)) + s.Equal(uint64(6), dst.common(src)) - c.Assert(src.score(dst, 100), Equals, 75) - c.Assert(dst.score(src, 100), Equals, 75) + s.Equal(75, src.score(dst, 100)) + s.Equal(75, dst.score(src, 100)) } -func keyFor(c *C, line string) int { +func keyFor(s *SimilarityIndexSuite, line string) int { idx := newSimilarityIndex() err := idx.hashContent(strings.NewReader(line), int64(len(line)), false) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(idx.numHashes, Equals, 1) + s.Equal(1, idx.numHashes) for _, h := range idx.hashes { if h != 0 { return h.key() @@ -447,10 +458,10 @@ func keyFor(c *C, line string) int { return -1 } -func textIndex(c *C, content string) *similarityIndex { +func textIndex(s *SimilarityIndexSuite, content string) *similarityIndex { idx := newSimilarityIndex() err := idx.hashContent(strings.NewReader(content), int64(len(content)), false) - c.Assert(err, IsNil) + s.NoError(err) return idx } @@ -463,11 +474,11 @@ func findIndex(idx *similarityIndex, key int) int { return -1 } -func makeFile(c *C, name string, mode filemode.FileMode, content string) *File { +func makeFile(s *RenameSuite, name string, mode filemode.FileMode, content string) *File { obj := new(plumbing.MemoryObject) obj.SetType(plumbing.BlobObject) _, err := obj.Write([]byte(content)) - c.Assert(err, IsNil) + s.NoError(err) return &File{ Name: name, Mode: mode, @@ -491,15 +502,15 @@ func makeChangeEntry(f *File) ChangeEntry { } } -func makeAdd(c *C, f *File) *Change { - return makeChange(c, nil, f) +func makeAdd(s *RenameSuite, f *File) *Change { + return makeChange(s, nil, f) } -func makeDelete(c *C, f *File) *Change { - return makeChange(c, f, nil) +func makeDelete(s *RenameSuite, f *File) *Change { + return makeChange(s, f, nil) } -func makeChange(c *C, from *File, to *File) *Change { +func makeChange(s *RenameSuite, from *File, to *File) *Change { if from == nil { return &Change{To: makeChangeEntry(to)} } @@ -509,7 +520,7 @@ func makeChange(c *C, from *File, to *File) *Change { } if from == nil && to == nil { - c.Error("cannot make change without from or to") + s.Fail("cannot make change without from or to") } return &Change{From: makeChangeEntry(from), To: makeChangeEntry(to)} diff --git a/plumbing/object/signature.go b/plumbing/object/signature.go index 91cf371f0..f9c3d306b 100644 --- a/plumbing/object/signature.go +++ b/plumbing/object/signature.go @@ -19,6 +19,7 @@ var ( // a PKCS#7 (S/MIME) signature. x509SignatureFormat = signatureFormat{ []byte("-----BEGIN CERTIFICATE-----"), + []byte("-----BEGIN SIGNED MESSAGE-----"), } // sshSignatureFormat is the format of an SSH signature. diff --git a/plumbing/object/signature_test.go b/plumbing/object/signature_test.go index 3b20cded4..c4dabf07e 100644 --- a/plumbing/object/signature_test.go +++ b/plumbing/object/signature_test.go @@ -33,7 +33,7 @@ MKEQruIQWJb+8HVXwssA4= want: signatureTypeSSH, }, { - name: "known signature format (X509)", + name: "known signature format (X509) CERTIFICATE", b: []byte(`-----BEGIN CERTIFICATE----- MIIDZjCCAk6gAwIBAgIJALZ9Z3Z9Z3Z9MA0GCSqGSIb3DQEBCwUAMIGIMQswCQYD VQQGEwJTRTEOMAwGA1UECAwFVGV4YXMxDjAMBgNVBAcMBVRleGFzMQ4wDAYDVQQK @@ -45,6 +45,19 @@ ggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDQZ9Z3Z9Z3Z9Z3Z9Z3Z9Z3 -----END CERTIFICATE-----`), want: signatureTypeX509, }, + { + name: "known signature format (x509) SIGNED MESSAGE", + b: []byte(`-----BEGIN SIGNED MESSAGE----- +MIIDZjCCAk6gAwIBAgIJALZ9Z3Z9Z3Z9MA0GCSqGSIb3DQEBCwUAMIGIMQswCQYD +VQQGEwJTRTEOMAwGA1UECAwFVGV4YXMxDjAMBgNVBAcMBVRleGFzMQ4wDAYDVQQK +DAVUZXhhczEOMAwGA1UECwwFVGV4YXMxGDAWBgNVBAMMD1RleGFzIENlcnRpZmlj +YXRlMB4XDTE3MDUyNjE3MjY0MloXDTI3MDUyNDE3MjY0MlowgYgxCzAJBgNVBAYT +AlNFMQ4wDAYDVQQIDAVUZXhhczEOMAwGA1UEBwwFVGV4YXMxDjAMBgNVBAoMBVRl +eGFzMQ4wDAYDVQQLDAVUZXhhczEYMBYGA1UEAwwPVGV4YXMgQ2VydGlmaWNhdGUw +ggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDQZ9Z3Z9Z3Z9Z3Z9Z3Z9Z3 +-----END SIGNED MESSAGE-----`), + want: signatureTypeX509, + }, { name: "unknown signature format", b: []byte(`-----BEGIN ARBITRARY SIGNATURE----- @@ -180,6 +193,9 @@ signed tag`), } func FuzzParseSignedBytes(f *testing.F) { + f.Add([]byte(openPGPSignatureFormat[0])) + f.Add([]byte(x509SignatureFormat[0])) + f.Add([]byte(sshSignatureFormat[0])) f.Fuzz(func(t *testing.T, input []byte) { parseSignedBytes(input) diff --git a/plumbing/object/tag.go b/plumbing/object/tag.go index cf46c08e1..6e303af4c 100644 --- a/plumbing/object/tag.go +++ b/plumbing/object/tag.go @@ -7,10 +7,10 @@ import ( "strings" "github.com/ProtonMail/go-crypto/openpgp" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/utils/ioutil" - "github.com/go-git/go-git/v5/utils/sync" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/utils/sync" ) // Tag represents an annotated tag object. It points to a single git object of diff --git a/plumbing/object/tag_test.go b/plumbing/object/tag_test.go index d374c6c54..e2b9b0274 100644 --- a/plumbing/object/tag_test.go +++ b/plumbing/object/tag_test.go @@ -4,158 +4,161 @@ import ( "fmt" "io" "strings" + "testing" "time" fixtures "github.com/go-git/go-git-fixtures/v4" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/storage/filesystem" - "github.com/go-git/go-git/v5/storage/memory" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/suite" ) type TagSuite struct { + suite.Suite BaseObjectsSuite } -var _ = Suite(&TagSuite{}) +func TestTagSuite(t *testing.T) { + suite.Run(t, new(TagSuite)) +} -func (s *TagSuite) SetUpSuite(c *C) { - s.BaseObjectsSuite.SetUpSuite(c) +func (s *TagSuite) SetupSuite() { + s.BaseObjectsSuite.SetupSuite(s.T()) storer := filesystem.NewStorage(fixtures.ByURL("https://github.com/git-fixtures/tags.git").One().DotGit(), cache.NewObjectLRUDefault()) s.Storer = storer } -func (s *TagSuite) TestNameIDAndType(c *C) { +func (s *TagSuite) TestNameIDAndType() { h := plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69") - tag := s.tag(c, h) - c.Assert(tag.Name, Equals, "annotated-tag") - c.Assert(h, Equals, tag.ID()) - c.Assert(plumbing.TagObject, Equals, tag.Type()) + tag := s.tag(h) + s.Equal("annotated-tag", tag.Name) + s.Equal(tag.ID(), h) + s.Equal(tag.Type(), plumbing.TagObject) } -func (s *TagSuite) TestTagger(c *C) { - tag := s.tag(c, plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69")) - c.Assert(tag.Tagger.String(), Equals, "Máximo Cuadros ") +func (s *TagSuite) TestTagger() { + tag := s.tag(plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69")) + s.Equal("Máximo Cuadros ", tag.Tagger.String()) } -func (s *TagSuite) TestAnnotated(c *C) { - tag := s.tag(c, plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69")) - c.Assert(tag.Message, Equals, "example annotated tag\n") +func (s *TagSuite) TestAnnotated() { + tag := s.tag(plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69")) + s.Equal("example annotated tag\n", tag.Message) commit, err := tag.Commit() - c.Assert(err, IsNil) - c.Assert(commit.Type(), Equals, plumbing.CommitObject) - c.Assert(commit.ID().String(), Equals, "f7b877701fbf855b44c0a9e86f3fdce2c298b07f") + s.NoError(err) + s.Equal(plumbing.CommitObject, commit.Type()) + s.Equal("f7b877701fbf855b44c0a9e86f3fdce2c298b07f", commit.ID().String()) } -func (s *TagSuite) TestCommitError(c *C) { - tag := s.tag(c, plumbing.NewHash("fe6cb94756faa81e5ed9240f9191b833db5f40ae")) +func (s *TagSuite) TestCommitError() { + tag := s.tag(plumbing.NewHash("fe6cb94756faa81e5ed9240f9191b833db5f40ae")) commit, err := tag.Commit() - c.Assert(commit, IsNil) - c.Assert(err, NotNil) - c.Assert(err, Equals, ErrUnsupportedObject) + s.Nil(commit) + s.NotNil(err) + s.ErrorIs(err, ErrUnsupportedObject) } -func (s *TagSuite) TestCommit(c *C) { - tag := s.tag(c, plumbing.NewHash("ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc")) - c.Assert(tag.Message, Equals, "a tagged commit\n") +func (s *TagSuite) TestCommit() { + tag := s.tag(plumbing.NewHash("ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc")) + s.Equal("a tagged commit\n", tag.Message) commit, err := tag.Commit() - c.Assert(err, IsNil) - c.Assert(commit.Type(), Equals, plumbing.CommitObject) - c.Assert(commit.ID().String(), Equals, "f7b877701fbf855b44c0a9e86f3fdce2c298b07f") + s.NoError(err) + s.Equal(plumbing.CommitObject, commit.Type()) + s.Equal("f7b877701fbf855b44c0a9e86f3fdce2c298b07f", commit.ID().String()) } -func (s *TagSuite) TestBlobError(c *C) { - tag := s.tag(c, plumbing.NewHash("ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc")) +func (s *TagSuite) TestBlobError() { + tag := s.tag(plumbing.NewHash("ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc")) commit, err := tag.Blob() - c.Assert(commit, IsNil) - c.Assert(err, NotNil) - c.Assert(err, Equals, ErrUnsupportedObject) + s.Nil(commit) + s.NotNil(err) + s.ErrorIs(err, ErrUnsupportedObject) } -func (s *TagSuite) TestBlob(c *C) { - tag := s.tag(c, plumbing.NewHash("fe6cb94756faa81e5ed9240f9191b833db5f40ae")) - c.Assert(tag.Message, Equals, "a tagged blob\n") +func (s *TagSuite) TestBlob() { + tag := s.tag(plumbing.NewHash("fe6cb94756faa81e5ed9240f9191b833db5f40ae")) + s.Equal("a tagged blob\n", tag.Message) blob, err := tag.Blob() - c.Assert(err, IsNil) - c.Assert(blob.Type(), Equals, plumbing.BlobObject) - c.Assert(blob.ID().String(), Equals, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391") + s.NoError(err) + s.Equal(plumbing.BlobObject, blob.Type()) + s.Equal("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", blob.ID().String()) } -func (s *TagSuite) TestTreeError(c *C) { - tag := s.tag(c, plumbing.NewHash("fe6cb94756faa81e5ed9240f9191b833db5f40ae")) +func (s *TagSuite) TestTreeError() { + tag := s.tag(plumbing.NewHash("fe6cb94756faa81e5ed9240f9191b833db5f40ae")) tree, err := tag.Tree() - c.Assert(tree, IsNil) - c.Assert(err, NotNil) - c.Assert(err, Equals, ErrUnsupportedObject) + s.Nil(tree) + s.NotNil(err) + s.ErrorIs(err, ErrUnsupportedObject) } -func (s *TagSuite) TestTree(c *C) { - tag := s.tag(c, plumbing.NewHash("152175bf7e5580299fa1f0ba41ef6474cc043b70")) - c.Assert(tag.Message, Equals, "a tagged tree\n") +func (s *TagSuite) TestTree() { + tag := s.tag(plumbing.NewHash("152175bf7e5580299fa1f0ba41ef6474cc043b70")) + s.Equal("a tagged tree\n", tag.Message) tree, err := tag.Tree() - c.Assert(err, IsNil) - c.Assert(tree.Type(), Equals, plumbing.TreeObject) - c.Assert(tree.ID().String(), Equals, "70846e9a10ef7b41064b40f07713d5b8b9a8fc73") + s.NoError(err) + s.Equal(plumbing.TreeObject, tree.Type()) + s.Equal("70846e9a10ef7b41064b40f07713d5b8b9a8fc73", tree.ID().String()) } -func (s *TagSuite) TestTreeFromCommit(c *C) { - tag := s.tag(c, plumbing.NewHash("ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc")) - c.Assert(tag.Message, Equals, "a tagged commit\n") +func (s *TagSuite) TestTreeFromCommit() { + tag := s.tag(plumbing.NewHash("ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc")) + s.Equal("a tagged commit\n", tag.Message) tree, err := tag.Tree() - c.Assert(err, IsNil) - c.Assert(tree.Type(), Equals, plumbing.TreeObject) - c.Assert(tree.ID().String(), Equals, "70846e9a10ef7b41064b40f07713d5b8b9a8fc73") + s.NoError(err) + s.Equal(plumbing.TreeObject, tree.Type()) + s.Equal("70846e9a10ef7b41064b40f07713d5b8b9a8fc73", tree.ID().String()) } -func (s *TagSuite) TestObject(c *C) { - tag := s.tag(c, plumbing.NewHash("ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc")) +func (s *TagSuite) TestObject() { + tag := s.tag(plumbing.NewHash("ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc")) obj, err := tag.Object() - c.Assert(err, IsNil) - c.Assert(obj.Type(), Equals, plumbing.CommitObject) - c.Assert(obj.ID().String(), Equals, "f7b877701fbf855b44c0a9e86f3fdce2c298b07f") + s.NoError(err) + s.Equal(plumbing.CommitObject, obj.Type()) + s.Equal("f7b877701fbf855b44c0a9e86f3fdce2c298b07f", obj.ID().String()) } -func (s *TagSuite) TestTagItter(c *C) { +func (s *TagSuite) TestTagItter() { iter, err := s.Storer.IterEncodedObjects(plumbing.TagObject) - c.Assert(err, IsNil) + s.NoError(err) var count int i := NewTagIter(s.Storer, iter) tag, err := i.Next() - c.Assert(err, IsNil) - c.Assert(tag, NotNil) - c.Assert(tag.Type(), Equals, plumbing.TagObject) + s.NoError(err) + s.NotNil(tag) + s.Equal(plumbing.TagObject, tag.Type()) err = i.ForEach(func(t *Tag) error { - c.Assert(t, NotNil) - c.Assert(t.Type(), Equals, plumbing.TagObject) + s.NotNil(t) + s.Equal(plumbing.TagObject, t.Type()) count++ return nil }) - c.Assert(err, IsNil) - c.Assert(count, Equals, 3) + s.NoError(err) + s.Equal(3, count) tag, err = i.Next() - c.Assert(err, Equals, io.EOF) - c.Assert(tag, IsNil) + s.ErrorIs(err, io.EOF) + s.Nil(tag) } -func (s *TagSuite) TestTagIterError(c *C) { +func (s *TagSuite) TestTagIterError() { iter, err := s.Storer.IterEncodedObjects(plumbing.TagObject) - c.Assert(err, IsNil) + s.NoError(err) randomErr := fmt.Errorf("a random error") i := NewTagIter(s.Storer, iter) @@ -163,21 +166,21 @@ func (s *TagSuite) TestTagIterError(c *C) { return randomErr }) - c.Assert(err, NotNil) - c.Assert(err, Equals, randomErr) + s.NotNil(err) + s.ErrorIs(err, randomErr) } -func (s *TagSuite) TestTagDecodeWrongType(c *C) { +func (s *TagSuite) TestTagDecodeWrongType() { newTag := &Tag{} obj := &plumbing.MemoryObject{} obj.SetType(plumbing.BlobObject) err := newTag.Decode(obj) - c.Assert(err, Equals, ErrUnsupportedObject) + s.ErrorIs(err, ErrUnsupportedObject) } -func (s *TagSuite) TestTagEncodeDecodeIdempotent(c *C) { +func (s *TagSuite) TestTagEncodeDecodeIdempotent() { ts, err := time.Parse(time.RFC3339, "2006-01-02T15:04:05-07:00") - c.Assert(err, IsNil) + s.NoError(err) tags := []*Tag{ { Name: "foo", @@ -196,18 +199,18 @@ func (s *TagSuite) TestTagEncodeDecodeIdempotent(c *C) { for _, tag := range tags { obj := &plumbing.MemoryObject{} err = tag.Encode(obj) - c.Assert(err, IsNil) + s.NoError(err) newTag := &Tag{} err = newTag.Decode(obj) - c.Assert(err, IsNil) + s.NoError(err) tag.Hash = obj.Hash() - c.Assert(newTag, DeepEquals, tag) + s.Equal(tag, newTag) } } -func (s *TagSuite) TestString(c *C) { - tag := s.tag(c, plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69")) - c.Assert(tag.String(), Equals, ""+ +func (s *TagSuite) TestString() { + tag := s.tag(plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69")) + s.Equal(""+ "tag annotated-tag\n"+ "Tagger: Máximo Cuadros \n"+ "Date: Wed Sep 21 21:13:35 2016 +0200\n"+ @@ -220,20 +223,22 @@ func (s *TagSuite) TestString(c *C) { "\n"+ " initial\n"+ "\n", + tag.String(), ) - tag = s.tag(c, plumbing.NewHash("152175bf7e5580299fa1f0ba41ef6474cc043b70")) - c.Assert(tag.String(), Equals, ""+ + tag = s.tag(plumbing.NewHash("152175bf7e5580299fa1f0ba41ef6474cc043b70")) + s.Equal(""+ "tag tree-tag\n"+ "Tagger: Máximo Cuadros \n"+ "Date: Wed Sep 21 21:17:56 2016 +0200\n"+ "\n"+ "a tagged tree\n"+ "\n", + tag.String(), ) } -func (s *TagSuite) TestStringNonCommit(c *C) { +func (s *TagSuite) TestStringNonCommit() { store := memory.NewStorage() target := &Tag{ @@ -259,36 +264,38 @@ func (s *TagSuite) TestStringNonCommit(c *C) { store.SetEncodedObject(tagObj) tag, err := GetTag(store, tagObj.Hash()) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(tag.String(), Equals, + s.Equal( "tag TAG TWO\n"+ "Tagger: <>\n"+ "Date: Thu Jan 01 00:00:00 1970 +0000\n"+ "\n"+ - "tag two\n") + "tag two\n", + tag.String(), + ) } -func (s *TagSuite) TestLongTagNameSerialization(c *C) { +func (s *TagSuite) TestLongTagNameSerialization() { encoded := &plumbing.MemoryObject{} decoded := &Tag{} - tag := s.tag(c, plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69")) + tag := s.tag(plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69")) longName := "my tag: name " + strings.Repeat("test", 4096) + " OK" tag.Name = longName err := tag.Encode(encoded) - c.Assert(err, IsNil) + s.NoError(err) err = decoded.Decode(encoded) - c.Assert(err, IsNil) - c.Assert(decoded.Name, Equals, longName) + s.NoError(err) + s.Equal(longName, decoded.Name) } -func (s *TagSuite) TestPGPSignatureSerialization(c *C) { +func (s *TagSuite) TestPGPSignatureSerialization() { encoded := &plumbing.MemoryObject{} decoded := &Tag{} - tag := s.tag(c, plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69")) + tag := s.tag(plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69")) pgpsignature := `-----BEGIN PGP SIGNATURE----- @@ -304,17 +311,17 @@ RUysgqjcpT8+iQM1PblGfHR4XAhuOqN5Fx06PSaFZhqvWFezJ28/CLyX5q+oIVk= tag.PGPSignature = pgpsignature err := tag.Encode(encoded) - c.Assert(err, IsNil) + s.NoError(err) err = decoded.Decode(encoded) - c.Assert(err, IsNil) - c.Assert(decoded.PGPSignature, Equals, pgpsignature) + s.NoError(err) + s.Equal(pgpsignature, decoded.PGPSignature) } -func (s *TagSuite) TestSSHSignatureSerialization(c *C) { +func (s *TagSuite) TestSSHSignatureSerialization() { encoded := &plumbing.MemoryObject{} decoded := &Tag{} - tag := s.tag(c, plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69")) + tag := s.tag(plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69")) signature := `-----BEGIN SSH SIGNATURE----- U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgij/EfHS8tCjolj5uEANXgKzFfp @@ -325,14 +332,14 @@ MKEQruIQWJb+8HVXwssA4= tag.PGPSignature = signature err := tag.Encode(encoded) - c.Assert(err, IsNil) + s.NoError(err) err = decoded.Decode(encoded) - c.Assert(err, IsNil) - c.Assert(decoded.PGPSignature, Equals, signature) + s.NoError(err) + s.Equal(signature, decoded.PGPSignature) } -func (s *TagSuite) TestVerify(c *C) { +func (s *TagSuite) TestVerify() { ts := time.Unix(1617403017, 0) loc, _ := time.LoadLocation("UTC") tag := &Tag{ @@ -370,13 +377,13 @@ YIefGtzXfldDxg4= ` e, err := tag.Verify(armoredKeyRing) - c.Assert(err, IsNil) + s.NoError(err) _, ok := e.Identities["go-git test key"] - c.Assert(ok, Equals, true) + s.True(ok) } -func (s *TagSuite) TestDecodeAndVerify(c *C) { +func (s *TagSuite) TestDecodeAndVerify() { objectText := `object f6685df0aac4b5adf9eeb760e6d447145c5d0b56 type commit tag v1.5 @@ -447,33 +454,34 @@ eQnkGpsz85DfEviLtk8cZjY/t6o8lPDLiwVjIzUBaA== _, err := tagEncodedObject.Write([]byte(objectText)) tagEncodedObject.SetType(plumbing.TagObject) - c.Assert(err, IsNil) + s.NoError(err) tag := &Tag{} err = tag.Decode(tagEncodedObject) - c.Assert(err, IsNil) + s.NoError(err) _, err = tag.Verify(armoredKeyRing) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *TagSuite) TestEncodeWithoutSignature(c *C) { +func (s *TagSuite) TestEncodeWithoutSignature() { //Similar to TestString since no signature encoded := &plumbing.MemoryObject{} - tag := s.tag(c, plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69")) + tag := s.tag(plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69")) err := tag.EncodeWithoutSignature(encoded) - c.Assert(err, IsNil) + s.NoError(err) er, err := encoded.Reader() - c.Assert(err, IsNil) + s.NoError(err) payload, err := io.ReadAll(er) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(string(payload), Equals, ""+ + s.Equal(""+ "object f7b877701fbf855b44c0a9e86f3fdce2c298b07f\n"+ "type commit\n"+ "tag annotated-tag\n"+ "tagger Máximo Cuadros 1474485215 +0200\n"+ "\n"+ "example annotated tag\n", + string(payload), ) } diff --git a/plumbing/object/tree.go b/plumbing/object/tree.go index 0fd0e5139..35a30958a 100644 --- a/plumbing/object/tree.go +++ b/plumbing/object/tree.go @@ -10,11 +10,11 @@ import ( "sort" "strings" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/filemode" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/utils/ioutil" - "github.com/go-git/go-git/v5/utils/sync" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/utils/sync" ) const ( @@ -295,6 +295,7 @@ func (s TreeEntrySorter) Swap(i, j int) { } // Encode transforms a Tree into a plumbing.EncodedObject. +// The tree entries must be sorted by name. func (t *Tree) Encode(o plumbing.EncodedObject) (err error) { o.SetType(plumbing.TreeObject) w, err := o.Writer() diff --git a/plumbing/object/tree_test.go b/plumbing/object/tree_test.go index feb058a68..7d64faa4f 100644 --- a/plumbing/object/tree_test.go +++ b/plumbing/object/tree_test.go @@ -8,129 +8,131 @@ import ( "testing" fixtures "github.com/go-git/go-git-fixtures/v4" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/filemode" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage/filesystem" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/stretchr/testify/suite" ) type TreeSuite struct { + suite.Suite BaseObjectsSuite Tree *Tree } -var _ = Suite(&TreeSuite{}) +func TestTreeSuite(t *testing.T) { + suite.Run(t, new(TreeSuite)) +} -func (s *TreeSuite) SetUpSuite(c *C) { - s.BaseObjectsSuite.SetUpSuite(c) +func (s *TreeSuite) SetupSuite() { + s.BaseObjectsSuite.SetupSuite(s.T()) hash := plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c") - s.Tree = s.tree(c, hash) + s.Tree = s.tree(hash) } -func (s *TreeSuite) TestDecode(c *C) { - c.Assert(s.Tree.Entries, HasLen, 8) - c.Assert(s.Tree.Entries[0].Name, Equals, ".gitignore") - c.Assert(s.Tree.Entries[0].Hash.String(), Equals, "32858aad3c383ed1ff0a0f9bdf231d54a00c9e88") - c.Assert(s.Tree.Entries[0].Mode, Equals, filemode.Regular) - c.Assert(s.Tree.Entries[4].Name, Equals, "go") - c.Assert(s.Tree.Entries[4].Hash.String(), Equals, "a39771a7651f97faf5c72e08224d857fc35133db") - c.Assert(s.Tree.Entries[4].Mode, Equals, filemode.Dir) +func (s *TreeSuite) TestDecode() { + s.Len(s.Tree.Entries, 8) + s.Equal(".gitignore", s.Tree.Entries[0].Name) + s.Equal("32858aad3c383ed1ff0a0f9bdf231d54a00c9e88", s.Tree.Entries[0].Hash.String()) + s.Equal(filemode.Regular, s.Tree.Entries[0].Mode) + s.Equal("go", s.Tree.Entries[4].Name) + s.Equal("a39771a7651f97faf5c72e08224d857fc35133db", s.Tree.Entries[4].Hash.String()) + s.Equal(filemode.Dir, s.Tree.Entries[4].Mode) } -func (s *TreeSuite) TestDecodeNonTree(c *C) { +func (s *TreeSuite) TestDecodeNonTree() { hash := plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492") blob, err := s.Storer.EncodedObject(plumbing.BlobObject, hash) - c.Assert(err, IsNil) + s.NoError(err) tree := &Tree{} err = tree.Decode(blob) - c.Assert(err, Equals, ErrUnsupportedObject) + s.ErrorIs(err, ErrUnsupportedObject) } -func (s *TreeSuite) TestType(c *C) { - c.Assert(s.Tree.Type(), Equals, plumbing.TreeObject) +func (s *TreeSuite) TestType() { + s.Equal(plumbing.TreeObject, s.Tree.Type()) } -func (s *TreeSuite) TestTree(c *C) { +func (s *TreeSuite) TestTree() { expectedEntry, ok := s.Tree.m["vendor"] - c.Assert(ok, Equals, true) + s.True(ok) expected := expectedEntry.Hash obtainedTree, err := s.Tree.Tree("vendor") - c.Assert(err, IsNil) - c.Assert(obtainedTree.Hash, Equals, expected) + s.NoError(err) + s.Equal(expected, obtainedTree.Hash) } -func (s *TreeSuite) TestTreeNotFound(c *C) { +func (s *TreeSuite) TestTreeNotFound() { d, err := s.Tree.Tree("not-found") - c.Assert(d, IsNil) - c.Assert(err, Equals, ErrDirectoryNotFound) + s.Nil(d) + s.ErrorIs(err, ErrDirectoryNotFound) } -func (s *TreeSuite) TestTreeFailsWithExistingFiles(c *C) { +func (s *TreeSuite) TestTreeFailsWithExistingFiles() { _, err := s.Tree.File("LICENSE") - c.Assert(err, IsNil) + s.NoError(err) d, err := s.Tree.Tree("LICENSE") - c.Assert(d, IsNil) - c.Assert(err, Equals, ErrDirectoryNotFound) + s.Nil(d) + s.ErrorIs(err, ErrDirectoryNotFound) } -func (s *TreeSuite) TestFile(c *C) { +func (s *TreeSuite) TestFile() { f, err := s.Tree.File("LICENSE") - c.Assert(err, IsNil) - c.Assert(f.Name, Equals, "LICENSE") + s.NoError(err) + s.Equal("LICENSE", f.Name) } -func (s *TreeSuite) TestFileNotFound(c *C) { +func (s *TreeSuite) TestFileNotFound() { f, err := s.Tree.File("not-found") - c.Assert(f, IsNil) - c.Assert(err, Equals, ErrFileNotFound) + s.Nil(f) + s.ErrorIs(err, ErrFileNotFound) } -func (s *TreeSuite) TestFileFailsWithExistingTrees(c *C) { +func (s *TreeSuite) TestFileFailsWithExistingTrees() { _, err := s.Tree.Tree("vendor") - c.Assert(err, IsNil) + s.NoError(err) f, err := s.Tree.File("vendor") - c.Assert(f, IsNil) - c.Assert(err, Equals, ErrFileNotFound) + s.Nil(f) + s.ErrorIs(err, ErrFileNotFound) } -func (s *TreeSuite) TestSize(c *C) { +func (s *TreeSuite) TestSize() { size, err := s.Tree.Size("LICENSE") - c.Assert(err, IsNil) - c.Assert(size, Equals, int64(1072)) + s.NoError(err) + s.Equal(int64(1072), size) } -func (s *TreeSuite) TestFiles(c *C) { +func (s *TreeSuite) TestFiles() { var count int err := s.Tree.Files().ForEach(func(f *File) error { count++ return nil }) - c.Assert(err, IsNil) - c.Assert(count, Equals, 9) + s.NoError(err) + s.Equal(9, count) } -func (s *TreeSuite) TestFindEntry(c *C) { +func (s *TreeSuite) TestFindEntry() { e, err := s.Tree.FindEntry("vendor/foo.go") - c.Assert(err, IsNil) - c.Assert(e.Name, Equals, "foo.go") + s.NoError(err) + s.Equal("foo.go", e.Name) } -func (s *TreeSuite) TestFindEntryNotFound(c *C) { +func (s *TreeSuite) TestFindEntryNotFound() { e, err := s.Tree.FindEntry("not-found") - c.Assert(e, IsNil) - c.Assert(err, Equals, ErrEntryNotFound) + s.Nil(e) + s.ErrorIs(err, ErrEntryNotFound) e, err = s.Tree.FindEntry("not-found/not-found/not-found") - c.Assert(e, IsNil) - c.Assert(err, Equals, ErrDirectoryNotFound) + s.Nil(e) + s.ErrorIs(err, ErrDirectoryNotFound) } // Overrides returned plumbing.EncodedObject for given hash. @@ -155,18 +157,18 @@ func (fe fakeEncodedObject) Reader() (io.ReadCloser, error) { return nil, errors.New("Simulate encoded object can't be read") } -func (s *TreeSuite) TestDir(c *C) { +func (s *TreeSuite) TestDir() { vendor, err := s.Tree.dir("vendor") - c.Assert(err, IsNil) + s.NoError(err) t, err := GetTree(s.Tree.s, s.Tree.ID()) - c.Assert(err, IsNil) + s.NoError(err) o, err := t.s.EncodedObject(plumbing.AnyObject, vendor.ID()) - c.Assert(err, IsNil) + s.NoError(err) t.s = fakeStorer{t.s, vendor.ID(), fakeEncodedObject{o}} _, err = t.dir("vendor") - c.Assert(err, NotNil) + s.NotNil(err) } // This plumbing.EncodedObject implementation has a reader that only returns 6 @@ -221,7 +223,7 @@ func (o *SortReadCloser) Read(p []byte) (int, error) { return nw, nil } -func (s *TreeSuite) TestTreeEntriesSorted(c *C) { +func (s *TreeSuite) TestTreeEntriesSorted() { tree := &Tree{ Entries: []TreeEntry{ {"foo", filemode.Empty, plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d")}, @@ -231,21 +233,21 @@ func (s *TreeSuite) TestTreeEntriesSorted(c *C) { } { - c.Assert(sort.IsSorted(TreeEntrySorter(tree.Entries)), Equals, false) + s.False(sort.IsSorted(TreeEntrySorter(tree.Entries))) obj := &plumbing.MemoryObject{} err := tree.Encode(obj) - c.Assert(err, Equals, ErrEntriesNotSorted) + s.ErrorIs(err, ErrEntriesNotSorted) } { sort.Sort(TreeEntrySorter(tree.Entries)) obj := &plumbing.MemoryObject{} err := tree.Encode(obj) - c.Assert(err, IsNil) + s.NoError(err) } } -func (s *TreeSuite) TestTreeDecodeEncodeIdempotent(c *C) { +func (s *TreeSuite) TestTreeDecodeEncodeIdempotent() { trees := []*Tree{ { Entries: []TreeEntry{ @@ -259,45 +261,45 @@ func (s *TreeSuite) TestTreeDecodeEncodeIdempotent(c *C) { sort.Sort(TreeEntrySorter(tree.Entries)) obj := &plumbing.MemoryObject{} err := tree.Encode(obj) - c.Assert(err, IsNil) + s.NoError(err) newTree := &Tree{} err = newTree.Decode(obj) - c.Assert(err, IsNil) + s.NoError(err) tree.Hash = obj.Hash() - c.Assert(newTree, DeepEquals, tree) + s.Equal(tree, newTree) } } -func (s *TreeSuite) TestTreeDiff(c *C) { +func (s *TreeSuite) TestTreeDiff() { f := fixtures.ByURL("https://github.com/src-d/go-git.git").One() storer := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) commit, err := GetCommit(storer, plumbing.NewHash("89f8bda31d29767a6d6ba8f9d0dfb941d598e843")) - c.Assert(err, IsNil) + s.NoError(err) tree, err := commit.Tree() - c.Assert(err, IsNil) + s.NoError(err) parentCommit, err := commit.Parent(0) - c.Assert(err, IsNil) + s.NoError(err) parentTree, err := parentCommit.Tree() - c.Assert(err, IsNil) + s.NoError(err) ch, err := parentTree.Diff(tree) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(ch, HasLen, 3) - c.Assert(ch[0].From.Name, Equals, "examples/object_storage/main.go") - c.Assert(ch[0].To.Name, Equals, "examples/storage/main.go") + s.Len(ch, 3) + s.Equal("examples/object_storage/main.go", ch[0].From.Name) + s.Equal("examples/storage/main.go", ch[0].To.Name) ch, err = parentTree.DiffContext(context.Background(), tree) - c.Assert(err, IsNil) - c.Assert(ch, HasLen, 3) + s.NoError(err) + s.Len(ch, 3) } -func (s *TreeSuite) TestTreeIter(c *C) { +func (s *TreeSuite) TestTreeIter() { encIter, err := s.Storer.IterEncodedObjects(plumbing.TreeObject) - c.Assert(err, IsNil) + s.NoError(err) iter := NewTreeIter(s.Storer, encIter) trees := []*Tree{} @@ -307,11 +309,11 @@ func (s *TreeSuite) TestTreeIter(c *C) { return nil }) - c.Assert(len(trees) > 0, Equals, true) + s.True(len(trees) > 0) iter.Close() encIter, err = s.Storer.IterEncodedObjects(plumbing.TreeObject) - c.Assert(err, IsNil) + s.NoError(err) iter = NewTreeIter(s.Storer, encIter) i := 0 @@ -322,19 +324,19 @@ func (s *TreeSuite) TestTreeIter(c *C) { } t.s = nil - c.Assert(err, IsNil) - c.Assert(t, DeepEquals, trees[i]) + s.NoError(err) + s.Equal(trees[i], t) i += 1 } iter.Close() } -func (s *TreeSuite) TestTreeWalkerNext(c *C) { +func (s *TreeSuite) TestTreeWalkerNext() { commit, err := GetCommit(s.Storer, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) - c.Assert(err, IsNil) + s.NoError(err) tree, err := commit.Tree() - c.Assert(err, IsNil) + s.NoError(err) walker := NewTreeWalker(tree, true, nil) for _, e := range treeWalkerExpects { @@ -343,21 +345,21 @@ func (s *TreeSuite) TestTreeWalkerNext(c *C) { break } - c.Assert(err, IsNil) - c.Assert(name, Equals, e.Path) - c.Assert(entry.Name, Equals, e.Name) - c.Assert(entry.Mode, Equals, e.Mode) - c.Assert(entry.Hash.String(), Equals, e.Hash) + s.NoError(err) + s.Equal(e.Path, name) + s.Equal(e.Name, entry.Name) + s.Equal(e.Mode, entry.Mode) + s.Equal(e.Hash, entry.Hash.String()) - c.Assert(walker.Tree().ID().String(), Equals, e.Tree) + s.Equal(e.Tree, walker.Tree().ID().String()) } } -func (s *TreeSuite) TestTreeWalkerNextSkipSeen(c *C) { +func (s *TreeSuite) TestTreeWalkerNextSkipSeen() { commit, err := GetCommit(s.Storer, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) - c.Assert(err, IsNil) + s.NoError(err) tree, err := commit.Tree() - c.Assert(err, IsNil) + s.NoError(err) seen := map[plumbing.Hash]bool{ plumbing.NewHash(treeWalkerExpects[0].Hash): true, @@ -369,20 +371,20 @@ func (s *TreeSuite) TestTreeWalkerNextSkipSeen(c *C) { break } - c.Assert(err, IsNil) - c.Assert(name, Equals, e.Path) - c.Assert(entry.Name, Equals, e.Name) - c.Assert(entry.Mode, Equals, e.Mode) - c.Assert(entry.Hash.String(), Equals, e.Hash) + s.NoError(err) + s.Equal(e.Path, name) + s.Equal(e.Name, entry.Name) + s.Equal(e.Mode, entry.Mode) + s.Equal(e.Hash, entry.Hash.String()) - c.Assert(walker.Tree().ID().String(), Equals, e.Tree) + s.Equal(e.Tree, walker.Tree().ID().String()) } } -func (s *TreeSuite) TestTreeWalkerNextNonRecursive(c *C) { - commit := s.commit(c, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) +func (s *TreeSuite) TestTreeWalkerNextNonRecursive() { + commit := s.commit(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) tree, err := commit.Tree() - c.Assert(err, IsNil) + s.NoError(err) var count int walker := NewTreeWalker(tree, false, nil) @@ -392,39 +394,39 @@ func (s *TreeSuite) TestTreeWalkerNextNonRecursive(c *C) { break } - c.Assert(err, IsNil) - c.Assert(name, Not(Equals), "") - c.Assert(entry, NotNil) + s.NoError(err) + s.NotEqual("", name) + s.NotNil(entry) - c.Assert(walker.Tree().ID().String(), Equals, "a8d315b2b1c615d43042c3a62402b8a54288cf5c") + s.Equal("a8d315b2b1c615d43042c3a62402b8a54288cf5c", walker.Tree().ID().String()) count++ } - c.Assert(count, Equals, 8) + s.Equal(8, count) } -func (s *TreeSuite) TestPatchContext_ToNil(c *C) { - commit := s.commit(c, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) +func (s *TreeSuite) TestPatchContext_ToNil() { + commit := s.commit(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) tree, err := commit.Tree() - c.Assert(err, IsNil) + s.NoError(err) patch, err := tree.PatchContext(context.Background(), nil) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(len(patch.String()), Equals, 242971) + s.Equal(242971, len(patch.String())) } -func (s *TreeSuite) TestTreeWalkerNextSubmodule(c *C) { +func (s *TreeSuite) TestTreeWalkerNextSubmodule() { dotgit := fixtures.ByURL("https://github.com/git-fixtures/submodule.git").One().DotGit() st := filesystem.NewStorage(dotgit, cache.NewObjectLRUDefault()) hash := plumbing.NewHash("b685400c1f9316f350965a5993d350bc746b0bf4") commit, err := GetCommit(st, hash) - c.Assert(err, IsNil) + s.NoError(err) tree, err := commit.Tree() - c.Assert(err, IsNil) + s.NoError(err) expected := []string{ ".gitmodules", @@ -443,14 +445,14 @@ func (s *TreeSuite) TestTreeWalkerNextSubmodule(c *C) { break } - c.Assert(err, IsNil) - c.Assert(entry, NotNil) - c.Assert(name, Equals, expected[count]) + s.NoError(err) + s.NotNil(entry) + s.Equal(expected[count], name) count++ } - c.Assert(count, Equals, 4) + s.Equal(4, count) } var treeWalkerExpects = []struct { @@ -531,7 +533,7 @@ func entriesEquals(a, b []TreeEntry) bool { // // This tests is performed with that object but using a SortReadObject to // simulate incomplete reads on all platforms and operating systems. -func (s *TreeSuite) TestTreeDecodeReadBug(c *C) { +func (s *TreeSuite) TestTreeDecodeReadBug() { cont := []byte{ 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x2e, 0x63, 0x0, 0xa4, 0x9d, 0x33, 0x49, 0xd7, @@ -1647,22 +1649,6 @@ func (s *TreeSuite) TestTreeDecodeReadBug(c *C) { var obtained Tree err := obtained.Decode(obj) - c.Assert(err, IsNil) - c.Assert(entriesEquals(obtained.Entries, expected.Entries), Equals, true) -} - -func FuzzDecode(f *testing.F) { - - f.Fuzz(func(t *testing.T, input []byte) { - - obj := &SortReadObject{ - t: plumbing.TreeObject, - h: plumbing.ZeroHash, - cont: input, - sz: int64(len(input)), - } - - newTree := &Tree{} - newTree.Decode(obj) - }) + s.NoError(err) + s.True(entriesEquals(obtained.Entries, expected.Entries)) } diff --git a/plumbing/object/treenoder.go b/plumbing/object/treenoder.go index 2adb64528..ae281b0f0 100644 --- a/plumbing/object/treenoder.go +++ b/plumbing/object/treenoder.go @@ -3,9 +3,9 @@ package object import ( "io" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/filemode" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" ) // A treenoder is a helper type that wraps git trees into merkletrie diff --git a/plumbing/object_test.go b/plumbing/object_test.go index 4d2dbe291..ecd6838cc 100644 --- a/plumbing/object_test.go +++ b/plumbing/object_test.go @@ -1,33 +1,41 @@ package plumbing -import . "gopkg.in/check.v1" +import ( + "testing" -type ObjectSuite struct{} + "github.com/stretchr/testify/suite" +) -var _ = Suite(&ObjectSuite{}) +type ObjectSuite struct { + suite.Suite +} + +func TestObjectSuite(t *testing.T) { + suite.Run(t, new(ObjectSuite)) +} -func (s *ObjectSuite) TestObjectTypeString(c *C) { - c.Assert(CommitObject.String(), Equals, "commit") - c.Assert(TreeObject.String(), Equals, "tree") - c.Assert(BlobObject.String(), Equals, "blob") - c.Assert(TagObject.String(), Equals, "tag") - c.Assert(REFDeltaObject.String(), Equals, "ref-delta") - c.Assert(OFSDeltaObject.String(), Equals, "ofs-delta") - c.Assert(AnyObject.String(), Equals, "any") - c.Assert(ObjectType(42).String(), Equals, "unknown") +func (s *ObjectSuite) TestObjectTypeString() { + s.Equal("commit", CommitObject.String()) + s.Equal("tree", TreeObject.String()) + s.Equal("blob", BlobObject.String()) + s.Equal("tag", TagObject.String()) + s.Equal("ref-delta", REFDeltaObject.String()) + s.Equal("ofs-delta", OFSDeltaObject.String()) + s.Equal("any", AnyObject.String()) + s.Equal("unknown", ObjectType(42).String()) } -func (s *ObjectSuite) TestObjectTypeBytes(c *C) { - c.Assert(CommitObject.Bytes(), DeepEquals, []byte("commit")) +func (s *ObjectSuite) TestObjectTypeBytes() { + s.Equal([]byte("commit"), CommitObject.Bytes()) } -func (s *ObjectSuite) TestObjectTypeValid(c *C) { - c.Assert(CommitObject.Valid(), Equals, true) - c.Assert(ObjectType(42).Valid(), Equals, false) +func (s *ObjectSuite) TestObjectTypeValid() { + s.True(CommitObject.Valid()) + s.False(ObjectType(42).Valid()) } -func (s *ObjectSuite) TestParseObjectType(c *C) { - for s, e := range map[string]ObjectType{ +func (s *ObjectSuite) TestParseObjectType() { + for st, e := range map[string]ObjectType{ "commit": CommitObject, "tree": TreeObject, "blob": BlobObject, @@ -35,12 +43,12 @@ func (s *ObjectSuite) TestParseObjectType(c *C) { "ref-delta": REFDeltaObject, "ofs-delta": OFSDeltaObject, } { - t, err := ParseObjectType(s) - c.Assert(err, IsNil) - c.Assert(e, Equals, t) + t, err := ParseObjectType(st) + s.NoError(err) + s.Equal(t, e) } t, err := ParseObjectType("foo") - c.Assert(err, Equals, ErrInvalidType) - c.Assert(t, Equals, InvalidObject) + s.ErrorIs(err, ErrInvalidType) + s.Equal(InvalidObject, t) } diff --git a/plumbing/protocol/packp/advrefs.go b/plumbing/protocol/packp/advrefs.go index f93ad3047..7bc053dc5 100644 --- a/plumbing/protocol/packp/advrefs.go +++ b/plumbing/protocol/packp/advrefs.go @@ -5,10 +5,10 @@ import ( "sort" "strings" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage/memory" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage/memory" ) // AdvRefs values represent the information transmitted on an diff --git a/plumbing/protocol/packp/advrefs_decode.go b/plumbing/protocol/packp/advrefs_decode.go index f8d26a28e..4da9f8a76 100644 --- a/plumbing/protocol/packp/advrefs_decode.go +++ b/plumbing/protocol/packp/advrefs_decode.go @@ -7,8 +7,8 @@ import ( "fmt" "io" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" ) // Decode reads the next advertised-refs message form its input and @@ -19,12 +19,12 @@ func (a *AdvRefs) Decode(r io.Reader) error { } type advRefsDecoder struct { - s *pktline.Scanner // a pkt-line scanner from the input stream - line []byte // current pkt-line contents, use parser.nextLine() to make it advance - nLine int // current pkt-line number for debugging, begins at 1 - hash plumbing.Hash // last hash read - err error // sticky error, use the parser.error() method to fill this out - data *AdvRefs // parsed data is stored here + s io.Reader // a pkt-line reader from the input stream + line []byte // current pkt-line contents, use parser.nextLine() to make it advance + nLine int // current pkt-line number for debugging, begins at 1 + hash plumbing.Hash // last hash read + err error // sticky error, use the parser.error() method to fill this out + data *AdvRefs // parsed data is stored here } var ( @@ -37,7 +37,7 @@ var ( func newAdvRefsDecoder(r io.Reader) *advRefsDecoder { return &advRefsDecoder{ - s: pktline.NewScanner(r), + s: r, } } @@ -70,8 +70,10 @@ func (d *advRefsDecoder) error(format string, a ...interface{}) { func (d *advRefsDecoder) nextLine() bool { d.nLine++ - if !d.s.Scan() { - if d.err = d.s.Err(); d.err != nil { + _, p, err := pktline.ReadLine(d.s) + if err != nil { + if !errors.Is(err, io.EOF) { + d.err = err return false } @@ -84,7 +86,7 @@ func (d *advRefsDecoder) nextLine() bool { return false } - d.line = d.s.Bytes() + d.line = p d.line = bytes.TrimSuffix(d.line, eol) return true @@ -111,7 +113,7 @@ func decodePrefix(d *advRefsDecoder) decoderStateFn { return decodeFirstHash } - d.data.Prefix = append(d.data.Prefix, pktline.Flush) + d.data.Prefix = append(d.data.Prefix, []byte{}) // empty slice for flush-pkt if ok := d.nextLine(); !ok { return nil } diff --git a/plumbing/protocol/packp/advrefs_decode_test.go b/plumbing/protocol/packp/advrefs_decode_test.go index d1271450e..585591b52 100644 --- a/plumbing/protocol/packp/advrefs_decode_test.go +++ b/plumbing/protocol/packp/advrefs_decode_test.go @@ -2,164 +2,177 @@ package packp import ( "bytes" + "fmt" "io" + "regexp" "strings" + "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/stretchr/testify/suite" ) -type AdvRefsDecodeSuite struct{} +type AdvRefsDecodeSuite struct { + suite.Suite +} -var _ = Suite(&AdvRefsDecodeSuite{}) +func TestAdvRefsDecodeSuite(t *testing.T) { + suite.Run(t, new(AdvRefsDecodeSuite)) +} -func (s *AdvRefsDecodeSuite) TestEmpty(c *C) { +func (s *AdvRefsDecodeSuite) TestEmpty() { var buf bytes.Buffer ar := NewAdvRefs() - c.Assert(ar.Decode(&buf), Equals, ErrEmptyInput) + s.Equal(ErrEmptyInput, ar.Decode(&buf)) } -func (s *AdvRefsDecodeSuite) TestEmptyFlush(c *C) { +func (s *AdvRefsDecodeSuite) TestEmptyFlush() { var buf bytes.Buffer - e := pktline.NewEncoder(&buf) - e.Flush() + pktline.WriteFlush(&buf) ar := NewAdvRefs() - c.Assert(ar.Decode(&buf), Equals, ErrEmptyAdvRefs) + s.Equal(ErrEmptyAdvRefs, ar.Decode(&buf)) } -func (s *AdvRefsDecodeSuite) TestEmptyPrefixFlush(c *C) { +func (s *AdvRefsDecodeSuite) TestEmptyPrefixFlush() { var buf bytes.Buffer - e := pktline.NewEncoder(&buf) - e.EncodeString("# service=git-upload-pack") - e.Flush() - e.Flush() + pktline.WriteString(&buf, "# service=git-upload-pack") + pktline.WriteFlush(&buf) + pktline.WriteFlush(&buf) ar := NewAdvRefs() - c.Assert(ar.Decode(&buf), Equals, ErrEmptyAdvRefs) + s.Equal(ErrEmptyAdvRefs, ar.Decode(&buf)) } -func (s *AdvRefsDecodeSuite) TestShortForHash(c *C) { +func (s *AdvRefsDecodeSuite) TestShortForHash() { payloads := []string{ "6ecf0ef2c2dffb796", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*too short.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*too short.*") } -func (s *AdvRefsDecodeSuite) testDecoderErrorMatches(c *C, input io.Reader, pattern string) { +func (s *AdvRefsDecodeSuite) testDecoderErrorMatches(input io.Reader, pattern string) { ar := NewAdvRefs() - c.Assert(ar.Decode(input), ErrorMatches, pattern) + err := ar.Decode(input) + s.Error(err) + if err != nil { + s.Regexp(regexp.MustCompile(pattern), err.Error()) + } } -func (s *AdvRefsDecodeSuite) TestInvalidFirstHash(c *C) { +func (s *AdvRefsDecodeSuite) TestInvalidFirstHash() { payloads := []string{ "6ecf0ef2c2dffb796alberto2219af86ec6584e5 HEAD\x00multi_ack thin-pack\n", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*invalid hash.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*invalid hash.*") } -func (s *AdvRefsDecodeSuite) TestZeroId(c *C) { +func (s *AdvRefsDecodeSuite) TestZeroId() { payloads := []string{ "0000000000000000000000000000000000000000 capabilities^{}\x00multi_ack thin-pack\n", - pktline.FlushString, + "", } - ar := s.testDecodeOK(c, payloads) - c.Assert(ar.Head, IsNil) + ar := s.testDecodeOK(payloads) + s.Nil(ar.Head) } -func (s *AdvRefsDecodeSuite) testDecodeOK(c *C, payloads []string) *AdvRefs { +func (s *AdvRefsDecodeSuite) testDecodeOK(payloads []string) *AdvRefs { var buf bytes.Buffer - e := pktline.NewEncoder(&buf) - err := e.EncodeString(payloads...) - c.Assert(err, IsNil) + for _, p := range payloads { + if p == "" { + s.Nil(pktline.WriteFlush(&buf)) + } else { + _, err := pktline.WriteString(&buf, p) + s.NoError(err) + } + } ar := NewAdvRefs() - c.Assert(ar.Decode(&buf), IsNil) + s.Nil(ar.Decode(&buf)) return ar } -func (s *AdvRefsDecodeSuite) TestMalformedZeroId(c *C) { +func (s *AdvRefsDecodeSuite) TestMalformedZeroId() { payloads := []string{ "0000000000000000000000000000000000000000 wrong\x00multi_ack thin-pack\n", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*malformed zero-id.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*malformed zero-id.*") } -func (s *AdvRefsDecodeSuite) TestShortZeroId(c *C) { +func (s *AdvRefsDecodeSuite) TestShortZeroId() { payloads := []string{ "0000000000000000000000000000000000000000 capabi", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*too short zero-id.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*too short zero-id.*") } -func (s *AdvRefsDecodeSuite) TestHead(c *C) { +func (s *AdvRefsDecodeSuite) TestHead() { payloads := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00", - pktline.FlushString, + "", } - ar := s.testDecodeOK(c, payloads) - c.Assert(*ar.Head, Equals, - plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) + ar := s.testDecodeOK(payloads) + s.Equal(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"), + *ar.Head) } -func (s *AdvRefsDecodeSuite) TestFirstIsNotHead(c *C) { +func (s *AdvRefsDecodeSuite) TestFirstIsNotHead() { payloads := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 refs/heads/master\x00", - pktline.FlushString, + "", } - ar := s.testDecodeOK(c, payloads) - c.Assert(ar.Head, IsNil) - c.Assert(ar.References["refs/heads/master"], Equals, - plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) + ar := s.testDecodeOK(payloads) + s.Nil(ar.Head) + s.Equal(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"), + ar.References["refs/heads/master"]) } -func (s *AdvRefsDecodeSuite) TestShortRef(c *C) { +func (s *AdvRefsDecodeSuite) TestShortRef() { payloads := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 H", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*too short.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*too short.*") } -func (s *AdvRefsDecodeSuite) TestNoNULL(c *C) { +func (s *AdvRefsDecodeSuite) TestNoNULL() { payloads := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEADofs-delta multi_ack", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*NULL not found.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*NULL not found.*") } -func (s *AdvRefsDecodeSuite) TestNoSpaceAfterHash(c *C) { +func (s *AdvRefsDecodeSuite) TestNoSpaceAfterHash() { payloads := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5-HEAD\x00", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*no space after hash.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*no space after hash.*") } -func (s *AdvRefsDecodeSuite) TestNoCaps(c *C) { +func (s *AdvRefsDecodeSuite) TestNoCaps() { payloads := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00", - pktline.FlushString, + "", } - ar := s.testDecodeOK(c, payloads) - c.Assert(ar.Capabilities.IsEmpty(), Equals, true) + ar := s.testDecodeOK(payloads) + s.True(ar.Capabilities.IsEmpty()) } -func (s *AdvRefsDecodeSuite) TestCaps(c *C) { +func (s *AdvRefsDecodeSuite) TestCaps() { type entry struct { Name capability.Capability Values []string @@ -171,19 +184,19 @@ func (s *AdvRefsDecodeSuite) TestCaps(c *C) { }{{ input: []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00", - pktline.FlushString, + "", }, capabilities: []entry{}, }, { input: []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00\n", - pktline.FlushString, + "", }, capabilities: []entry{}, }, { input: []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta", - pktline.FlushString, + "", }, capabilities: []entry{ { @@ -194,7 +207,7 @@ func (s *AdvRefsDecodeSuite) TestCaps(c *C) { }, { input: []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta multi_ack", - pktline.FlushString, + "", }, capabilities: []entry{ {Name: capability.OFSDelta, Values: []string(nil)}, @@ -203,7 +216,7 @@ func (s *AdvRefsDecodeSuite) TestCaps(c *C) { }, { input: []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta multi_ack\n", - pktline.FlushString, + "", }, capabilities: []entry{ {Name: capability.OFSDelta, Values: []string(nil)}, @@ -212,7 +225,7 @@ func (s *AdvRefsDecodeSuite) TestCaps(c *C) { }, { input: []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:refs/heads/master agent=foo=bar\n", - pktline.FlushString, + "", }, capabilities: []entry{ {Name: capability.SymRef, Values: []string{"HEAD:refs/heads/master"}}, @@ -221,7 +234,7 @@ func (s *AdvRefsDecodeSuite) TestCaps(c *C) { }, { input: []string{ "0000000000000000000000000000000000000000 capabilities^{}\x00report-status report-status-v2 delete-refs side-band-64k quiet atomic ofs-delta object-format=sha1 agent=git/2.41.0\n", - pktline.FlushString, + "", }, capabilities: []entry{ {Name: capability.ReportStatus, Values: []string(nil)}, @@ -229,41 +242,41 @@ func (s *AdvRefsDecodeSuite) TestCaps(c *C) { {Name: capability.Agent, Values: []string{"git/2.41.0"}}, }, }} { - ar := s.testDecodeOK(c, test.input) + ar := s.testDecodeOK(test.input) for _, fixCap := range test.capabilities { - c.Assert(ar.Capabilities.Supports(fixCap.Name), Equals, true, - Commentf("input = %q, capability = %q", test.input, fixCap.Name)) - c.Assert(ar.Capabilities.Get(fixCap.Name), DeepEquals, fixCap.Values, - Commentf("input = %q, capability = %q", test.input, fixCap.Name)) + s.True(ar.Capabilities.Supports(fixCap.Name), + fmt.Sprintf("input = %q, capability = %q", test.input, fixCap.Name)) + s.Equal(fixCap.Values, ar.Capabilities.Get(fixCap.Name), + fmt.Sprintf("input = %q, capability = %q", test.input, fixCap.Name)) } } } -func (s *AdvRefsDecodeSuite) TestWithPrefix(c *C) { +func (s *AdvRefsDecodeSuite) TestWithPrefix() { payloads := []string{ "# this is a prefix\n", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta\n", - pktline.FlushString, + "", } - ar := s.testDecodeOK(c, payloads) - c.Assert(len(ar.Prefix), Equals, 1) - c.Assert(ar.Prefix[0], DeepEquals, []byte("# this is a prefix")) + ar := s.testDecodeOK(payloads) + s.Len(ar.Prefix, 1) + s.Equal([]byte("# this is a prefix"), ar.Prefix[0]) } -func (s *AdvRefsDecodeSuite) TestWithPrefixAndFlush(c *C) { +func (s *AdvRefsDecodeSuite) TestWithPrefixAndFlush() { payloads := []string{ "# this is a prefix\n", - pktline.FlushString, + "", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta\n", - pktline.FlushString, + "", } - ar := s.testDecodeOK(c, payloads) - c.Assert(len(ar.Prefix), Equals, 2) - c.Assert(ar.Prefix[0], DeepEquals, []byte("# this is a prefix")) - c.Assert(ar.Prefix[1], DeepEquals, []byte(pktline.FlushString)) + ar := s.testDecodeOK(payloads) + s.Len(ar.Prefix, 2) + s.Equal([]byte("# this is a prefix"), ar.Prefix[0]) + s.Equal([]byte(""), ar.Prefix[1]) } -func (s *AdvRefsDecodeSuite) TestOtherRefs(c *C) { +func (s *AdvRefsDecodeSuite) TestOtherRefs() { for _, test := range [...]struct { input []string references map[string]plumbing.Hash @@ -271,7 +284,7 @@ func (s *AdvRefsDecodeSuite) TestOtherRefs(c *C) { }{{ input: []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n", - pktline.FlushString, + "", }, references: make(map[string]plumbing.Hash), peeled: make(map[string]plumbing.Hash), @@ -279,7 +292,7 @@ func (s *AdvRefsDecodeSuite) TestOtherRefs(c *C) { input: []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n", "1111111111111111111111111111111111111111 ref/foo", - pktline.FlushString, + "", }, references: map[string]plumbing.Hash{ "ref/foo": plumbing.NewHash("1111111111111111111111111111111111111111"), @@ -289,7 +302,7 @@ func (s *AdvRefsDecodeSuite) TestOtherRefs(c *C) { input: []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n", "1111111111111111111111111111111111111111 ref/foo\n", - pktline.FlushString, + "", }, references: map[string]plumbing.Hash{ "ref/foo": plumbing.NewHash("1111111111111111111111111111111111111111"), @@ -300,7 +313,7 @@ func (s *AdvRefsDecodeSuite) TestOtherRefs(c *C) { "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n", "1111111111111111111111111111111111111111 ref/foo\n", "2222222222222222222222222222222222222222 ref/bar", - pktline.FlushString, + "", }, references: map[string]plumbing.Hash{ "ref/foo": plumbing.NewHash("1111111111111111111111111111111111111111"), @@ -311,7 +324,7 @@ func (s *AdvRefsDecodeSuite) TestOtherRefs(c *C) { input: []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n", "1111111111111111111111111111111111111111 ref/foo^{}\n", - pktline.FlushString, + "", }, references: make(map[string]plumbing.Hash), peeled: map[string]plumbing.Hash{ @@ -322,7 +335,7 @@ func (s *AdvRefsDecodeSuite) TestOtherRefs(c *C) { "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n", "1111111111111111111111111111111111111111 ref/foo\n", "2222222222222222222222222222222222222222 ref/bar^{}", - pktline.FlushString, + "", }, references: map[string]plumbing.Hash{ "ref/foo": plumbing.NewHash("1111111111111111111111111111111111111111"), @@ -342,7 +355,7 @@ func (s *AdvRefsDecodeSuite) TestOtherRefs(c *C) { "c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11^{}\n", "5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n", "c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n", - pktline.FlushString, + "", }, references: map[string]plumbing.Hash{ "refs/heads/master": plumbing.NewHash("a6930aaee06755d1bdcfd943fbf614e4d92bb0c7"), @@ -358,34 +371,34 @@ func (s *AdvRefsDecodeSuite) TestOtherRefs(c *C) { "refs/tags/v2.6.11-tree": plumbing.NewHash("c39ae07f393806ccf406ef966e9a15afc43cc36a"), }, }} { - ar := s.testDecodeOK(c, test.input) - comment := Commentf("input = %v\n", test.input) - c.Assert(ar.References, DeepEquals, test.references, comment) - c.Assert(ar.Peeled, DeepEquals, test.peeled, comment) + ar := s.testDecodeOK(test.input) + comment := fmt.Sprintf("input = %v\n", test.input) + s.Equal(test.references, ar.References, comment) + s.Equal(test.peeled, ar.Peeled, comment) } } -func (s *AdvRefsDecodeSuite) TestMalformedOtherRefsNoSpace(c *C) { +func (s *AdvRefsDecodeSuite) TestMalformedOtherRefsNoSpace() { payloads := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00multi_ack thin-pack\n", "5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8crefs/tags/v2.6.11\n", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*malformed ref data.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*malformed ref data.*") } -func (s *AdvRefsDecodeSuite) TestMalformedOtherRefsMultipleSpaces(c *C) { +func (s *AdvRefsDecodeSuite) TestMalformedOtherRefsMultipleSpaces() { payloads := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00multi_ack thin-pack\n", "5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags v2.6.11\n", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*malformed ref data.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*malformed ref data.*") } -func (s *AdvRefsDecodeSuite) TestShallow(c *C) { +func (s *AdvRefsDecodeSuite) TestShallow() { for _, test := range [...]struct { input []string shallows []plumbing.Hash @@ -395,7 +408,7 @@ func (s *AdvRefsDecodeSuite) TestShallow(c *C) { "a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n", "5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n", "c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n", - pktline.FlushString, + "", }, shallows: []plumbing.Hash{}, }, { @@ -405,7 +418,7 @@ func (s *AdvRefsDecodeSuite) TestShallow(c *C) { "5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n", "c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n", "shallow 1111111111111111111111111111111111111111\n", - pktline.FlushString, + "", }, shallows: []plumbing.Hash{plumbing.NewHash("1111111111111111111111111111111111111111")}, }, { @@ -416,20 +429,20 @@ func (s *AdvRefsDecodeSuite) TestShallow(c *C) { "c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n", "shallow 1111111111111111111111111111111111111111\n", "shallow 2222222222222222222222222222222222222222\n", - pktline.FlushString, + "", }, shallows: []plumbing.Hash{ plumbing.NewHash("1111111111111111111111111111111111111111"), plumbing.NewHash("2222222222222222222222222222222222222222"), }, }} { - ar := s.testDecodeOK(c, test.input) - comment := Commentf("input = %v\n", test.input) - c.Assert(ar.Shallows, DeepEquals, test.shallows, comment) + ar := s.testDecodeOK(test.input) + comment := fmt.Sprintf("input = %v\n", test.input) + s.Equal(test.shallows, ar.Shallows, comment) } } -func (s *AdvRefsDecodeSuite) TestInvalidShallowHash(c *C) { +func (s *AdvRefsDecodeSuite) TestInvalidShallowHash() { payloads := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n", "a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n", @@ -437,13 +450,13 @@ func (s *AdvRefsDecodeSuite) TestInvalidShallowHash(c *C) { "c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n", "shallow 11111111alcortes111111111111111111111111\n", "shallow 2222222222222222222222222222222222222222\n", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*invalid hash text.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*invalid hash text.*") } -func (s *AdvRefsDecodeSuite) TestGarbageAfterShallow(c *C) { +func (s *AdvRefsDecodeSuite) TestGarbageAfterShallow() { payloads := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n", "a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n", @@ -452,13 +465,13 @@ func (s *AdvRefsDecodeSuite) TestGarbageAfterShallow(c *C) { "shallow 1111111111111111111111111111111111111111\n", "shallow 2222222222222222222222222222222222222222\n", "b5be40b90dbaa6bd337f3b77de361bfc0723468b refs/tags/v4.4", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*malformed shallow prefix.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*malformed shallow prefix.*") } -func (s *AdvRefsDecodeSuite) TestMalformedShallowHash(c *C) { +func (s *AdvRefsDecodeSuite) TestMalformedShallowHash() { payloads := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n", "a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n", @@ -466,22 +479,22 @@ func (s *AdvRefsDecodeSuite) TestMalformedShallowHash(c *C) { "c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n", "shallow 1111111111111111111111111111111111111111\n", "shallow 2222222222222222222222222222222222222222 malformed\n", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*malformed shallow hash.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*malformed shallow hash.*") } -func (s *AdvRefsDecodeSuite) TestEOFRefs(c *C) { +func (s *AdvRefsDecodeSuite) TestEOFRefs() { input := strings.NewReader("" + "005b6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n" + "003fa6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n" + "00355dc01c595e6c6ec9ccda4f6ffbf614e4d92bb0c7 refs/foo\n", ) - s.testDecoderErrorMatches(c, input, ".*invalid pkt-len.*") + s.testDecoderErrorMatches(input, ".*invalid pkt-len.*") } -func (s *AdvRefsDecodeSuite) TestEOFShallows(c *C) { +func (s *AdvRefsDecodeSuite) TestEOFShallows() { input := strings.NewReader("" + "005b6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n" + "003fa6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n" + @@ -489,5 +502,5 @@ func (s *AdvRefsDecodeSuite) TestEOFShallows(c *C) { "0047c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n" + "0035shallow 1111111111111111111111111111111111111111\n" + "0034shallow 222222222222222222222222") - s.testDecoderErrorMatches(c, input, ".*unexpected EOF.*") + s.testDecoderErrorMatches(input, ".*unexpected EOF.*") } diff --git a/plumbing/protocol/packp/advrefs_encode.go b/plumbing/protocol/packp/advrefs_encode.go index fb9bd883f..d561289f9 100644 --- a/plumbing/protocol/packp/advrefs_encode.go +++ b/plumbing/protocol/packp/advrefs_encode.go @@ -1,14 +1,13 @@ package packp import ( - "bytes" "fmt" "io" "sort" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" ) // Encode writes the AdvRefs encoding to a writer. @@ -22,18 +21,17 @@ func (a *AdvRefs) Encode(w io.Writer) error { } type advRefsEncoder struct { - data *AdvRefs // data to encode - pe *pktline.Encoder // where to write the encoded data - firstRefName string // reference name to encode in the first pkt-line (HEAD if present) - firstRefHash plumbing.Hash // hash referenced to encode in the first pkt-line (HEAD if present) - sortedRefs []string // hash references to encode ordered by increasing order - err error // sticky error - + data *AdvRefs // data to encode + w io.Writer // where to write the encoded data + firstRefName string // reference name to encode in the first pkt-line (HEAD if present) + firstRefHash plumbing.Hash // hash referenced to encode in the first pkt-line (HEAD if present) + sortedRefs []string // hash references to encode ordered by increasing order + err error // sticky error } func newAdvRefsEncoder(w io.Writer) *advRefsEncoder { return &advRefsEncoder{ - pe: pktline.NewEncoder(w), + w: w, } } @@ -79,13 +77,13 @@ type encoderStateFn func(*advRefsEncoder) encoderStateFn func encodePrefix(e *advRefsEncoder) encoderStateFn { for _, p := range e.data.Prefix { - if bytes.Equal(p, pktline.Flush) { - if e.err = e.pe.Flush(); e.err != nil { + if len(p) == 0 { + if e.err = pktline.WriteFlush(e.w); e.err != nil { return nil } continue } - if e.err = e.pe.Encodef("%s\n", string(p)); e.err != nil { + if _, e.err = pktline.WriteString(e.w, string(p)+"\n"); e.err != nil { return nil } } @@ -107,10 +105,9 @@ func encodeFirstLine(e *advRefsEncoder) encoderStateFn { firstLine = fmt.Sprintf(formatFirstLine, plumbing.ZeroHash.String(), "capabilities^{}", capabilities) } else { firstLine = fmt.Sprintf(formatFirstLine, e.firstRefHash.String(), e.firstRefName, capabilities) - } - if e.err = e.pe.EncodeString(firstLine); e.err != nil { + if _, e.err = pktline.WriteString(e.w, firstLine); e.err != nil { return nil } @@ -134,12 +131,12 @@ func encodeRefs(e *advRefsEncoder) encoderStateFn { } hash := e.data.References[r] - if e.err = e.pe.Encodef("%s %s\n", hash.String(), r); e.err != nil { + if _, e.err = pktline.Writef(e.w, "%s %s\n", hash.String(), r); e.err != nil { return nil } if hash, ok := e.data.Peeled[r]; ok { - if e.err = e.pe.Encodef("%s %s^{}\n", hash.String(), r); e.err != nil { + if _, e.err = pktline.Writef(e.w, "%s %s^{}\n", hash.String(), r); e.err != nil { return nil } } @@ -152,7 +149,7 @@ func encodeRefs(e *advRefsEncoder) encoderStateFn { func encodeShallow(e *advRefsEncoder) encoderStateFn { sorted := sortShallows(e.data.Shallows) for _, hash := range sorted { - if e.err = e.pe.Encodef("shallow %s\n", hash); e.err != nil { + if _, e.err = pktline.Writef(e.w, "shallow %s\n", hash); e.err != nil { return nil } } @@ -171,6 +168,6 @@ func sortShallows(c []plumbing.Hash) []string { } func encodeFlush(e *advRefsEncoder) encoderStateFn { - e.err = e.pe.Flush() + e.err = pktline.WriteFlush(e.w) return nil } diff --git a/plumbing/protocol/packp/advrefs_encode_test.go b/plumbing/protocol/packp/advrefs_encode_test.go index a01e83341..ff8a084dd 100644 --- a/plumbing/protocol/packp/advrefs_encode_test.go +++ b/plumbing/protocol/packp/advrefs_encode_test.go @@ -2,55 +2,61 @@ package packp import ( "bytes" + "fmt" + "regexp" "strings" + "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/stretchr/testify/suite" ) -type AdvRefsEncodeSuite struct{} +type AdvRefsEncodeSuite struct { + suite.Suite +} -var _ = Suite(&AdvRefsEncodeSuite{}) +func TestAdvRefsEncodeSuite(t *testing.T) { + suite.Run(t, new(AdvRefsEncodeSuite)) +} -func testEncode(c *C, input *AdvRefs, expected []byte) { +func testEncode(s *AdvRefsEncodeSuite, input *AdvRefs, expected []byte) { var buf bytes.Buffer - c.Assert(input.Encode(&buf), IsNil) + s.Nil(input.Encode(&buf)) obtained := buf.Bytes() - comment := Commentf("\nobtained = %s\nexpected = %s\n", string(obtained), string(expected)) + comment := fmt.Sprintf("\nobtained = %s\nexpected = %s\n", string(obtained), string(expected)) - c.Assert(obtained, DeepEquals, expected, comment) + s.Equal(expected, obtained, comment) } -func (s *AdvRefsEncodeSuite) TestZeroValue(c *C) { +func (s *AdvRefsEncodeSuite) TestZeroValue() { ar := &AdvRefs{} - expected := pktlines(c, + expected := pktlines(s.T(), "0000000000000000000000000000000000000000 capabilities^{}\x00\n", - pktline.FlushString, + "", ) - testEncode(c, ar, expected) + testEncode(s, ar, expected) } -func (s *AdvRefsEncodeSuite) TestHead(c *C) { +func (s *AdvRefsEncodeSuite) TestHead() { hash := plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5") ar := &AdvRefs{ Head: &hash, } - expected := pktlines(c, + expected := pktlines(s.T(), "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00\n", - pktline.FlushString, + "", ) - testEncode(c, ar, expected) + testEncode(s, ar, expected) } -func (s *AdvRefsEncodeSuite) TestCapsNoHead(c *C) { +func (s *AdvRefsEncodeSuite) TestCapsNoHead() { capabilities := capability.NewList() capabilities.Add(capability.MultiACK) capabilities.Add(capability.OFSDelta) @@ -59,15 +65,15 @@ func (s *AdvRefsEncodeSuite) TestCapsNoHead(c *C) { Capabilities: capabilities, } - expected := pktlines(c, + expected := pktlines(s.T(), "0000000000000000000000000000000000000000 capabilities^{}\x00multi_ack ofs-delta symref=HEAD:/refs/heads/master\n", - pktline.FlushString, + "", ) - testEncode(c, ar, expected) + testEncode(s, ar, expected) } -func (s *AdvRefsEncodeSuite) TestCapsWithHead(c *C) { +func (s *AdvRefsEncodeSuite) TestCapsWithHead() { hash := plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5") capabilities := capability.NewList() capabilities.Add(capability.MultiACK) @@ -78,15 +84,15 @@ func (s *AdvRefsEncodeSuite) TestCapsWithHead(c *C) { Capabilities: capabilities, } - expected := pktlines(c, + expected := pktlines(s.T(), "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00multi_ack ofs-delta symref=HEAD:/refs/heads/master\n", - pktline.FlushString, + "", ) - testEncode(c, ar, expected) + testEncode(s, ar, expected) } -func (s *AdvRefsEncodeSuite) TestRefs(c *C) { +func (s *AdvRefsEncodeSuite) TestRefs() { references := map[string]plumbing.Hash{ "refs/heads/master": plumbing.NewHash("a6930aaee06755d1bdcfd943fbf614e4d92bb0c7"), "refs/tags/v2.6.12-tree": plumbing.NewHash("1111111111111111111111111111111111111111"), @@ -98,19 +104,19 @@ func (s *AdvRefsEncodeSuite) TestRefs(c *C) { References: references, } - expected := pktlines(c, + expected := pktlines(s.T(), "a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\x00\n", "5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n", "1111111111111111111111111111111111111111 refs/tags/v2.6.12-tree\n", "2222222222222222222222222222222222222222 refs/tags/v2.6.13-tree\n", "3333333333333333333333333333333333333333 refs/tags/v2.7.13-tree\n", - pktline.FlushString, + "", ) - testEncode(c, ar, expected) + testEncode(s, ar, expected) } -func (s *AdvRefsEncodeSuite) TestPeeled(c *C) { +func (s *AdvRefsEncodeSuite) TestPeeled() { references := map[string]plumbing.Hash{ "refs/heads/master": plumbing.NewHash("a6930aaee06755d1bdcfd943fbf614e4d92bb0c7"), "refs/tags/v2.6.12-tree": plumbing.NewHash("1111111111111111111111111111111111111111"), @@ -127,7 +133,7 @@ func (s *AdvRefsEncodeSuite) TestPeeled(c *C) { Peeled: peeled, } - expected := pktlines(c, + expected := pktlines(s.T(), "a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\x00\n", "5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n", "1111111111111111111111111111111111111111 refs/tags/v2.6.12-tree\n", @@ -135,13 +141,13 @@ func (s *AdvRefsEncodeSuite) TestPeeled(c *C) { "2222222222222222222222222222222222222222 refs/tags/v2.6.13-tree\n", "3333333333333333333333333333333333333333 refs/tags/v2.7.13-tree\n", "4444444444444444444444444444444444444444 refs/tags/v2.7.13-tree^{}\n", - pktline.FlushString, + "", ) - testEncode(c, ar, expected) + testEncode(s, ar, expected) } -func (s *AdvRefsEncodeSuite) TestShallow(c *C) { +func (s *AdvRefsEncodeSuite) TestShallow() { shallows := []plumbing.Hash{ plumbing.NewHash("1111111111111111111111111111111111111111"), plumbing.NewHash("4444444444444444444444444444444444444444"), @@ -152,19 +158,19 @@ func (s *AdvRefsEncodeSuite) TestShallow(c *C) { Shallows: shallows, } - expected := pktlines(c, + expected := pktlines(s.T(), "0000000000000000000000000000000000000000 capabilities^{}\x00\n", "shallow 1111111111111111111111111111111111111111\n", "shallow 2222222222222222222222222222222222222222\n", "shallow 3333333333333333333333333333333333333333\n", "shallow 4444444444444444444444444444444444444444\n", - pktline.FlushString, + "", ) - testEncode(c, ar, expected) + testEncode(s, ar, expected) } -func (s *AdvRefsEncodeSuite) TestAll(c *C) { +func (s *AdvRefsEncodeSuite) TestAll() { hash := plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5") capabilities := capability.NewList() @@ -200,7 +206,7 @@ func (s *AdvRefsEncodeSuite) TestAll(c *C) { Shallows: shallows, } - expected := pktlines(c, + expected := pktlines(s.T(), "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00multi_ack ofs-delta symref=HEAD:/refs/heads/master\n", "a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n", "5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n", @@ -213,13 +219,13 @@ func (s *AdvRefsEncodeSuite) TestAll(c *C) { "shallow 2222222222222222222222222222222222222222\n", "shallow 3333333333333333333333333333333333333333\n", "shallow 4444444444444444444444444444444444444444\n", - pktline.FlushString, + "", ) - testEncode(c, ar, expected) + testEncode(s, ar, expected) } -func (s *AdvRefsEncodeSuite) TestErrorTooLong(c *C) { +func (s *AdvRefsEncodeSuite) TestErrorTooLong() { references := map[string]plumbing.Hash{ strings.Repeat("a", pktline.MaxPayloadSize): plumbing.NewHash("a6930aaee06755d1bdcfd943fbf614e4d92bb0c7"), } @@ -229,5 +235,5 @@ func (s *AdvRefsEncodeSuite) TestErrorTooLong(c *C) { var buf bytes.Buffer err := ar.Encode(&buf) - c.Assert(err, ErrorMatches, ".*payload is too long.*") + s.Regexp(regexp.MustCompile(".*payload is too long.*"), err) } diff --git a/plumbing/protocol/packp/advrefs_test.go b/plumbing/protocol/packp/advrefs_test.go index 1b8db981c..b0ffdc8aa 100644 --- a/plumbing/protocol/packp/advrefs_test.go +++ b/plumbing/protocol/packp/advrefs_test.go @@ -3,103 +3,107 @@ package packp import ( "bytes" "io" + "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/stretchr/testify/suite" ) -type AdvRefSuite struct{} +type AdvRefSuite struct { + suite.Suite +} -var _ = Suite(&AdvRefSuite{}) +func TestAdvRefSuite(t *testing.T) { + suite.Run(t, new(AdvRefSuite)) +} -func (s *AdvRefSuite) TestAddReferenceSymbolic(c *C) { +func (s *AdvRefSuite) TestAddReferenceSymbolic() { ref := plumbing.NewSymbolicReference("foo", "bar") a := NewAdvRefs() err := a.AddReference(ref) - c.Assert(err, IsNil) + s.NoError(err) values := a.Capabilities.Get(capability.SymRef) - c.Assert(values, HasLen, 1) - c.Assert(values[0], Equals, "foo:bar") + s.Len(values, 1) + s.Equal("foo:bar", values[0]) } -func (s *AdvRefSuite) TestAddReferenceHash(c *C) { +func (s *AdvRefSuite) TestAddReferenceHash() { ref := plumbing.NewHashReference("foo", plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c")) a := NewAdvRefs() err := a.AddReference(ref) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(a.References, HasLen, 1) - c.Assert(a.References["foo"].String(), Equals, "5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c") + s.Len(a.References, 1) + s.Equal("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c", a.References["foo"].String()) } -func (s *AdvRefSuite) TestAllReferences(c *C) { +func (s *AdvRefSuite) TestAllReferences() { hash := plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c") a := NewAdvRefs() err := a.AddReference(plumbing.NewSymbolicReference("foo", "bar")) - c.Assert(err, IsNil) + s.NoError(err) err = a.AddReference(plumbing.NewHashReference("bar", hash)) - c.Assert(err, IsNil) + s.NoError(err) refs, err := a.AllReferences() - c.Assert(err, IsNil) + s.NoError(err) iter, err := refs.IterReferences() - c.Assert(err, IsNil) + s.NoError(err) var count int iter.ForEach(func(ref *plumbing.Reference) error { count++ switch ref.Name() { case "bar": - c.Assert(ref.Hash(), Equals, hash) + s.Equal(hash, ref.Hash()) case "foo": - c.Assert(ref.Target().String(), Equals, "bar") + s.Equal("bar", ref.Target().String()) } return nil }) - c.Assert(count, Equals, 2) + s.Equal(2, count) } -func (s *AdvRefSuite) TestAllReferencesBadSymref(c *C) { +func (s *AdvRefSuite) TestAllReferencesBadSymref() { a := NewAdvRefs() err := a.Capabilities.Set(capability.SymRef, "foo") - c.Assert(err, IsNil) + s.NoError(err) _, err = a.AllReferences() - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *AdvRefSuite) TestIsEmpty(c *C) { +func (s *AdvRefSuite) TestIsEmpty() { a := NewAdvRefs() - c.Assert(a.IsEmpty(), Equals, true) + s.True(a.IsEmpty()) } -func (s *AdvRefSuite) TestNoSymRefCapabilityHeadToMaster(c *C) { +func (s *AdvRefSuite) TestNoSymRefCapabilityHeadToMaster() { a := NewAdvRefs() headHash := plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c") a.Head = &headHash ref := plumbing.NewHashReference(plumbing.Master, plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c")) err := a.AddReference(ref) - c.Assert(err, IsNil) + s.NoError(err) storage, err := a.AllReferences() - c.Assert(err, IsNil) + s.NoError(err) head, err := storage.Reference(plumbing.HEAD) - c.Assert(err, IsNil) - c.Assert(head.Target(), Equals, ref.Name()) + s.NoError(err) + s.Equal(ref.Name(), head.Target()) } -func (s *AdvRefSuite) TestNoSymRefCapabilityHeadToOtherThanMaster(c *C) { +func (s *AdvRefSuite) TestNoSymRefCapabilityHeadToOtherThanMaster() { a := NewAdvRefs() headHash := plumbing.NewHash("0000000000000000000000000000000000000000") a.Head = &headHash @@ -107,32 +111,32 @@ func (s *AdvRefSuite) TestNoSymRefCapabilityHeadToOtherThanMaster(c *C) { ref2 := plumbing.NewHashReference("other/ref", plumbing.NewHash("0000000000000000000000000000000000000000")) err := a.AddReference(ref1) - c.Assert(err, IsNil) + s.NoError(err) err = a.AddReference(ref2) - c.Assert(err, IsNil) + s.NoError(err) storage, err := a.AllReferences() - c.Assert(err, IsNil) + s.NoError(err) head, err := storage.Reference(plumbing.HEAD) - c.Assert(err, IsNil) - c.Assert(head.Hash(), Equals, ref2.Hash()) + s.NoError(err) + s.Equal(ref2.Hash(), head.Hash()) } -func (s *AdvRefSuite) TestNoSymRefCapabilityHeadToNoRef(c *C) { +func (s *AdvRefSuite) TestNoSymRefCapabilityHeadToNoRef() { a := NewAdvRefs() headHash := plumbing.NewHash("0000000000000000000000000000000000000000") a.Head = &headHash ref := plumbing.NewHashReference(plumbing.Master, plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c")) err := a.AddReference(ref) - c.Assert(err, IsNil) + s.NoError(err) _, err = a.AllReferences() - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *AdvRefSuite) TestNoSymRefCapabilityHeadToNoMasterAlphabeticallyOrdered(c *C) { +func (s *AdvRefSuite) TestNoSymRefCapabilityHeadToNoMasterAlphabeticallyOrdered() { a := NewAdvRefs() headHash := plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c") a.Head = &headHash @@ -141,41 +145,54 @@ func (s *AdvRefSuite) TestNoSymRefCapabilityHeadToNoMasterAlphabeticallyOrdered( ref3 := plumbing.NewHashReference("bbbbbbbbbbbbbbb", plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c")) err := a.AddReference(ref1) - c.Assert(err, IsNil) + s.NoError(err) err = a.AddReference(ref3) - c.Assert(err, IsNil) + s.NoError(err) err = a.AddReference(ref2) - c.Assert(err, IsNil) + s.NoError(err) storage, err := a.AllReferences() - c.Assert(err, IsNil) + s.NoError(err) head, err := storage.Reference(plumbing.HEAD) - c.Assert(err, IsNil) - c.Assert(head.Target(), Equals, ref2.Name()) + s.NoError(err) + s.Equal(ref2.Name(), head.Target()) } -type AdvRefsDecodeEncodeSuite struct{} +type AdvRefsDecodeEncodeSuite struct { + suite.Suite +} -var _ = Suite(&AdvRefsDecodeEncodeSuite{}) +func TestAdvRefsDecodeEncodeSuite(t *testing.T) { + suite.Run(t, new(AdvRefsDecodeEncodeSuite)) +} -func (s *AdvRefsDecodeEncodeSuite) test(c *C, in []string, exp []string, isEmpty bool) { - var err error +func (s *AdvRefsDecodeEncodeSuite) test(in []string, exp []string, isEmpty bool) { var input io.Reader { var buf bytes.Buffer - p := pktline.NewEncoder(&buf) - err = p.EncodeString(in...) - c.Assert(err, IsNil) + for _, l := range in { + if l == "" { + s.NoError(pktline.WriteFlush(&buf)) + } else { + _, err := pktline.WriteString(&buf, l) + s.NoError(err) + } + } input = &buf } var expected []byte { var buf bytes.Buffer - p := pktline.NewEncoder(&buf) - err = p.EncodeString(exp...) - c.Assert(err, IsNil) + for _, l := range exp { + if l == "" { + s.Nil(pktline.WriteFlush(&buf)) + } else { + _, err := pktline.WriteString(&buf, l) + s.NoError(err) + } + } expected = buf.Bytes() } @@ -183,73 +200,73 @@ func (s *AdvRefsDecodeEncodeSuite) test(c *C, in []string, exp []string, isEmpty var obtained []byte { ar := NewAdvRefs() - c.Assert(ar.Decode(input), IsNil) - c.Assert(ar.IsEmpty(), Equals, isEmpty) + s.Nil(ar.Decode(input)) + s.Equal(isEmpty, ar.IsEmpty()) var buf bytes.Buffer - c.Assert(ar.Encode(&buf), IsNil) + s.Nil(ar.Encode(&buf)) obtained = buf.Bytes() } - c.Assert(string(obtained), DeepEquals, string(expected)) + s.Equal(string(expected), string(obtained)) } -func (s *AdvRefsDecodeEncodeSuite) TestNoHead(c *C) { +func (s *AdvRefsDecodeEncodeSuite) TestNoHead() { input := []string{ "0000000000000000000000000000000000000000 capabilities^{}\x00", - pktline.FlushString, + "", } expected := []string{ "0000000000000000000000000000000000000000 capabilities^{}\x00\n", - pktline.FlushString, + "", } - s.test(c, input, expected, true) + s.test(input, expected, true) } -func (s *AdvRefsDecodeEncodeSuite) TestNoHeadSmart(c *C) { +func (s *AdvRefsDecodeEncodeSuite) TestNoHeadSmart() { input := []string{ "# service=git-upload-pack\n", "0000000000000000000000000000000000000000 capabilities^{}\x00", - pktline.FlushString, + "", } expected := []string{ "# service=git-upload-pack\n", "0000000000000000000000000000000000000000 capabilities^{}\x00\n", - pktline.FlushString, + "", } - s.test(c, input, expected, true) + s.test(input, expected, true) } -func (s *AdvRefsDecodeEncodeSuite) TestNoHeadSmartBug(c *C) { +func (s *AdvRefsDecodeEncodeSuite) TestNoHeadSmartBug() { input := []string{ "# service=git-upload-pack\n", - pktline.FlushString, + "", "0000000000000000000000000000000000000000 capabilities^{}\x00\n", - pktline.FlushString, + "", } expected := []string{ "# service=git-upload-pack\n", - pktline.FlushString, + "", "0000000000000000000000000000000000000000 capabilities^{}\x00\n", - pktline.FlushString, + "", } - s.test(c, input, expected, true) + s.test(input, expected, true) } -func (s *AdvRefsDecodeEncodeSuite) TestRefs(c *C) { +func (s *AdvRefsDecodeEncodeSuite) TestRefs() { input := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:/refs/heads/master ofs-delta multi_ack", "a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master", "5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n", "7777777777777777777777777777777777777777 refs/tags/v2.6.12-tree", - pktline.FlushString, + "", } expected := []string{ @@ -257,13 +274,13 @@ func (s *AdvRefsDecodeEncodeSuite) TestRefs(c *C) { "a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n", "5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n", "7777777777777777777777777777777777777777 refs/tags/v2.6.12-tree\n", - pktline.FlushString, + "", } - s.test(c, input, expected, false) + s.test(input, expected, false) } -func (s *AdvRefsDecodeEncodeSuite) TestPeeled(c *C) { +func (s *AdvRefsDecodeEncodeSuite) TestPeeled() { input := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:/refs/heads/master ofs-delta multi_ack", "7777777777777777777777777777777777777777 refs/tags/v2.6.12-tree\n", @@ -271,7 +288,7 @@ func (s *AdvRefsDecodeEncodeSuite) TestPeeled(c *C) { "a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n", "5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree", "c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n", - pktline.FlushString, + "", } expected := []string{ @@ -281,13 +298,13 @@ func (s *AdvRefsDecodeEncodeSuite) TestPeeled(c *C) { "c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n", "7777777777777777777777777777777777777777 refs/tags/v2.6.12-tree\n", "8888888888888888888888888888888888888888 refs/tags/v2.6.12-tree^{}\n", - pktline.FlushString, + "", } - s.test(c, input, expected, false) + s.test(input, expected, false) } -func (s *AdvRefsDecodeEncodeSuite) TestAll(c *C) { +func (s *AdvRefsDecodeEncodeSuite) TestAll() { input := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:/refs/heads/master ofs-delta multi_ack\n", "a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n", @@ -297,7 +314,7 @@ func (s *AdvRefsDecodeEncodeSuite) TestAll(c *C) { "8888888888888888888888888888888888888888 refs/tags/v2.6.12-tree^{}", "shallow 1111111111111111111111111111111111111111", "shallow 2222222222222222222222222222222222222222\n", - pktline.FlushString, + "", } expected := []string{ @@ -309,16 +326,16 @@ func (s *AdvRefsDecodeEncodeSuite) TestAll(c *C) { "8888888888888888888888888888888888888888 refs/tags/v2.6.12-tree^{}\n", "shallow 1111111111111111111111111111111111111111\n", "shallow 2222222222222222222222222222222222222222\n", - pktline.FlushString, + "", } - s.test(c, input, expected, false) + s.test(input, expected, false) } -func (s *AdvRefsDecodeEncodeSuite) TestAllSmart(c *C) { +func (s *AdvRefsDecodeEncodeSuite) TestAllSmart() { input := []string{ "# service=git-upload-pack\n", - pktline.FlushString, + "", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:/refs/heads/master ofs-delta multi_ack\n", "a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n", "5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n", @@ -327,12 +344,12 @@ func (s *AdvRefsDecodeEncodeSuite) TestAllSmart(c *C) { "8888888888888888888888888888888888888888 refs/tags/v2.6.12-tree^{}\n", "shallow 1111111111111111111111111111111111111111\n", "shallow 2222222222222222222222222222222222222222\n", - pktline.FlushString, + "", } expected := []string{ "# service=git-upload-pack\n", - pktline.FlushString, + "", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:/refs/heads/master ofs-delta multi_ack\n", "a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n", "5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n", @@ -341,16 +358,16 @@ func (s *AdvRefsDecodeEncodeSuite) TestAllSmart(c *C) { "8888888888888888888888888888888888888888 refs/tags/v2.6.12-tree^{}\n", "shallow 1111111111111111111111111111111111111111\n", "shallow 2222222222222222222222222222222222222222\n", - pktline.FlushString, + "", } - s.test(c, input, expected, false) + s.test(input, expected, false) } -func (s *AdvRefsDecodeEncodeSuite) TestAllSmartBug(c *C) { +func (s *AdvRefsDecodeEncodeSuite) TestAllSmartBug() { input := []string{ "# service=git-upload-pack\n", - pktline.FlushString, + "", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:/refs/heads/master ofs-delta multi_ack\n", "a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n", "5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n", @@ -359,12 +376,12 @@ func (s *AdvRefsDecodeEncodeSuite) TestAllSmartBug(c *C) { "8888888888888888888888888888888888888888 refs/tags/v2.6.12-tree^{}\n", "shallow 1111111111111111111111111111111111111111\n", "shallow 2222222222222222222222222222222222222222\n", - pktline.FlushString, + "", } expected := []string{ "# service=git-upload-pack\n", - pktline.FlushString, + "", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:/refs/heads/master ofs-delta multi_ack\n", "a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n", "5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n", @@ -373,8 +390,8 @@ func (s *AdvRefsDecodeEncodeSuite) TestAllSmartBug(c *C) { "8888888888888888888888888888888888888888 refs/tags/v2.6.12-tree^{}\n", "shallow 1111111111111111111111111111111111111111\n", "shallow 2222222222222222222222222222222222222222\n", - pktline.FlushString, + "", } - s.test(c, input, expected, false) + s.test(input, expected, false) } diff --git a/plumbing/protocol/packp/capability/capability_test.go b/plumbing/protocol/packp/capability/capability_test.go index f1fd0282a..f259a13b8 100644 --- a/plumbing/protocol/packp/capability/capability_test.go +++ b/plumbing/protocol/packp/capability/capability_test.go @@ -3,20 +3,16 @@ package capability import ( "fmt" "os" - - check "gopkg.in/check.v1" ) -var _ = check.Suite(&SuiteCapabilities{}) - -func (s *SuiteCapabilities) TestDefaultAgent(c *check.C) { +func (s *SuiteCapabilities) TestDefaultAgent() { os.Unsetenv("GO_GIT_USER_AGENT_EXTRA") ua := DefaultAgent() - c.Assert(ua, check.Equals, userAgent) + s.Equal(userAgent, ua) } -func (s *SuiteCapabilities) TestEnvAgent(c *check.C) { +func (s *SuiteCapabilities) TestEnvAgent() { os.Setenv("GO_GIT_USER_AGENT_EXTRA", "abc xyz") ua := DefaultAgent() - c.Assert(ua, check.Equals, fmt.Sprintf("%s %s", userAgent, "abc xyz")) + s.Equal(fmt.Sprintf("%s %s", userAgent, "abc xyz"), ua) } diff --git a/plumbing/protocol/packp/capability/list_test.go b/plumbing/protocol/packp/capability/list_test.go index 71181cbc9..6c6b2a420 100644 --- a/plumbing/protocol/packp/capability/list_test.go +++ b/plumbing/protocol/packp/capability/list_test.go @@ -3,215 +3,217 @@ package capability import ( "testing" - check "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { check.TestingT(t) } - -type SuiteCapabilities struct{} +type SuiteCapabilities struct { + suite.Suite +} -var _ = check.Suite(&SuiteCapabilities{}) +func TestSuiteCapabilities(t *testing.T) { + suite.Run(t, new(SuiteCapabilities)) +} -func (s *SuiteCapabilities) TestIsEmpty(c *check.C) { +func (s *SuiteCapabilities) TestIsEmpty() { cap := NewList() - c.Assert(cap.IsEmpty(), check.Equals, true) + s.True(cap.IsEmpty()) } -func (s *SuiteCapabilities) TestDecode(c *check.C) { +func (s *SuiteCapabilities) TestDecode() { cap := NewList() err := cap.Decode([]byte("symref=foo symref=qux thin-pack")) - c.Assert(err, check.IsNil) + s.NoError(err) - c.Assert(cap.m, check.HasLen, 2) - c.Assert(cap.Get(SymRef), check.DeepEquals, []string{"foo", "qux"}) - c.Assert(cap.Get(ThinPack), check.IsNil) + s.Len(cap.m, 2) + s.Equal([]string{"foo", "qux"}, cap.Get(SymRef)) + s.Nil(cap.Get(ThinPack)) } -func (s *SuiteCapabilities) TestDecodeWithLeadingSpace(c *check.C) { +func (s *SuiteCapabilities) TestDecodeWithLeadingSpace() { cap := NewList() err := cap.Decode([]byte(" report-status")) - c.Assert(err, check.IsNil) + s.NoError(err) - c.Assert(cap.m, check.HasLen, 1) - c.Assert(cap.Supports(ReportStatus), check.Equals, true) + s.Len(cap.m, 1) + s.True(cap.Supports(ReportStatus)) } -func (s *SuiteCapabilities) TestDecodeEmpty(c *check.C) { +func (s *SuiteCapabilities) TestDecodeEmpty() { cap := NewList() err := cap.Decode(nil) - c.Assert(err, check.IsNil) - c.Assert(cap, check.DeepEquals, NewList()) + s.NoError(err) + s.Equal(NewList(), cap) } -func (s *SuiteCapabilities) TestDecodeWithErrArguments(c *check.C) { +func (s *SuiteCapabilities) TestDecodeWithErrArguments() { cap := NewList() err := cap.Decode([]byte("thin-pack=foo")) - c.Assert(err, check.Equals, ErrArguments) + s.ErrorIs(err, ErrArguments) } -func (s *SuiteCapabilities) TestDecodeWithEqual(c *check.C) { +func (s *SuiteCapabilities) TestDecodeWithEqual() { cap := NewList() err := cap.Decode([]byte("agent=foo=bar")) - c.Assert(err, check.IsNil) + s.NoError(err) - c.Assert(cap.m, check.HasLen, 1) - c.Assert(cap.Get(Agent), check.DeepEquals, []string{"foo=bar"}) + s.Len(cap.m, 1) + s.Equal([]string{"foo=bar"}, cap.Get(Agent)) } -func (s *SuiteCapabilities) TestDecodeWithUnknownCapability(c *check.C) { +func (s *SuiteCapabilities) TestDecodeWithUnknownCapability() { cap := NewList() err := cap.Decode([]byte("foo")) - c.Assert(err, check.IsNil) - c.Assert(cap.Supports(Capability("foo")), check.Equals, true) + s.NoError(err) + s.True(cap.Supports(Capability("foo"))) } -func (s *SuiteCapabilities) TestDecodeWithUnknownCapabilityWithArgument(c *check.C) { +func (s *SuiteCapabilities) TestDecodeWithUnknownCapabilityWithArgument() { cap := NewList() err := cap.Decode([]byte("oldref=HEAD:refs/heads/v2 thin-pack")) - c.Assert(err, check.IsNil) + s.NoError(err) - c.Assert(cap.m, check.HasLen, 2) - c.Assert(cap.Get("oldref"), check.DeepEquals, []string{"HEAD:refs/heads/v2"}) - c.Assert(cap.Get(ThinPack), check.IsNil) + s.Len(cap.m, 2) + s.Equal([]string{"HEAD:refs/heads/v2"}, cap.Get("oldref")) + s.Nil(cap.Get(ThinPack)) } -func (s *SuiteCapabilities) TestDecodeWithUnknownCapabilityWithMultipleArgument(c *check.C) { +func (s *SuiteCapabilities) TestDecodeWithUnknownCapabilityWithMultipleArgument() { cap := NewList() err := cap.Decode([]byte("foo=HEAD:refs/heads/v2 foo=HEAD:refs/heads/v1 thin-pack")) - c.Assert(err, check.IsNil) + s.NoError(err) - c.Assert(cap.m, check.HasLen, 2) - c.Assert(cap.Get("foo"), check.DeepEquals, []string{"HEAD:refs/heads/v2", "HEAD:refs/heads/v1"}) - c.Assert(cap.Get(ThinPack), check.IsNil) + s.Len(cap.m, 2) + s.Equal([]string{"HEAD:refs/heads/v2", "HEAD:refs/heads/v1"}, cap.Get("foo")) + s.Nil(cap.Get(ThinPack)) } -func (s *SuiteCapabilities) TestString(c *check.C) { +func (s *SuiteCapabilities) TestString() { cap := NewList() cap.Set(Agent, "bar") cap.Set(SymRef, "foo:qux") cap.Set(ThinPack) - c.Assert(cap.String(), check.Equals, "agent=bar symref=foo:qux thin-pack") + s.Equal("agent=bar symref=foo:qux thin-pack", cap.String()) } -func (s *SuiteCapabilities) TestStringSort(c *check.C) { +func (s *SuiteCapabilities) TestStringSort() { cap := NewList() cap.Set(Agent, "bar") cap.Set(SymRef, "foo:qux") cap.Set(ThinPack) - c.Assert(cap.String(), check.Equals, "agent=bar symref=foo:qux thin-pack") + s.Equal("agent=bar symref=foo:qux thin-pack", cap.String()) } -func (s *SuiteCapabilities) TestSet(c *check.C) { +func (s *SuiteCapabilities) TestSet() { cap := NewList() err := cap.Add(SymRef, "foo", "qux") - c.Assert(err, check.IsNil) + s.NoError(err) err = cap.Set(SymRef, "bar") - c.Assert(err, check.IsNil) + s.NoError(err) - c.Assert(cap.m, check.HasLen, 1) - c.Assert(cap.Get(SymRef), check.DeepEquals, []string{"bar"}) + s.Len(cap.m, 1) + s.Equal([]string{"bar"}, cap.Get(SymRef)) } -func (s *SuiteCapabilities) TestSetEmpty(c *check.C) { +func (s *SuiteCapabilities) TestSetEmpty() { cap := NewList() err := cap.Set(Agent, "bar") - c.Assert(err, check.IsNil) + s.NoError(err) - c.Assert(cap.Get(Agent), check.HasLen, 1) + s.Len(cap.Get(Agent), 1) } -func (s *SuiteCapabilities) TestSetDuplicate(c *check.C) { +func (s *SuiteCapabilities) TestSetDuplicate() { cap := NewList() err := cap.Set(Agent, "baz") - c.Assert(err, check.IsNil) + s.NoError(err) err = cap.Set(Agent, "bar") - c.Assert(err, check.IsNil) + s.NoError(err) - c.Assert(cap.String(), check.Equals, "agent=bar") + s.Equal("agent=bar", cap.String()) } -func (s *SuiteCapabilities) TestGetEmpty(c *check.C) { +func (s *SuiteCapabilities) TestGetEmpty() { cap := NewList() - c.Assert(cap.Get(Agent), check.HasLen, 0) + s.Len(cap.Get(Agent), 0) } -func (s *SuiteCapabilities) TestDelete(c *check.C) { +func (s *SuiteCapabilities) TestDelete() { cap := NewList() cap.Delete(SymRef) err := cap.Add(Sideband) - c.Assert(err, check.IsNil) + s.NoError(err) err = cap.Set(SymRef, "bar") - c.Assert(err, check.IsNil) + s.NoError(err) err = cap.Set(Sideband64k) - c.Assert(err, check.IsNil) + s.NoError(err) cap.Delete(SymRef) - c.Assert(cap.String(), check.Equals, "side-band side-band-64k") + s.Equal("side-band side-band-64k", cap.String()) } -func (s *SuiteCapabilities) TestAdd(c *check.C) { +func (s *SuiteCapabilities) TestAdd() { cap := NewList() err := cap.Add(SymRef, "foo", "qux") - c.Assert(err, check.IsNil) + s.NoError(err) err = cap.Add(ThinPack) - c.Assert(err, check.IsNil) + s.NoError(err) - c.Assert(cap.String(), check.Equals, "symref=foo symref=qux thin-pack") + s.Equal("symref=foo symref=qux thin-pack", cap.String()) } -func (s *SuiteCapabilities) TestAddUnknownCapability(c *check.C) { +func (s *SuiteCapabilities) TestAddUnknownCapability() { cap := NewList() err := cap.Add(Capability("foo")) - c.Assert(err, check.IsNil) - c.Assert(cap.Supports(Capability("foo")), check.Equals, true) + s.NoError(err) + s.True(cap.Supports(Capability("foo"))) } -func (s *SuiteCapabilities) TestAddErrArgumentsRequired(c *check.C) { +func (s *SuiteCapabilities) TestAddErrArgumentsRequired() { cap := NewList() err := cap.Add(SymRef) - c.Assert(err, check.Equals, ErrArgumentsRequired) + s.ErrorIs(err, ErrArgumentsRequired) } -func (s *SuiteCapabilities) TestAddErrArgumentsNotAllowed(c *check.C) { +func (s *SuiteCapabilities) TestAddErrArgumentsNotAllowed() { cap := NewList() err := cap.Add(OFSDelta, "foo") - c.Assert(err, check.Equals, ErrArguments) + s.ErrorIs(err, ErrArguments) } -func (s *SuiteCapabilities) TestAddErrArguments(c *check.C) { +func (s *SuiteCapabilities) TestAddErrArguments() { cap := NewList() err := cap.Add(SymRef, "") - c.Assert(err, check.Equals, ErrEmptyArgument) + s.ErrorIs(err, ErrEmptyArgument) } -func (s *SuiteCapabilities) TestAddErrMultipleArguments(c *check.C) { +func (s *SuiteCapabilities) TestAddErrMultipleArguments() { cap := NewList() err := cap.Add(Agent, "foo") - c.Assert(err, check.IsNil) + s.NoError(err) err = cap.Add(Agent, "bar") - c.Assert(err, check.Equals, ErrMultipleArguments) + s.ErrorIs(err, ErrMultipleArguments) } -func (s *SuiteCapabilities) TestAddErrMultipleArgumentsAtTheSameTime(c *check.C) { +func (s *SuiteCapabilities) TestAddErrMultipleArgumentsAtTheSameTime() { cap := NewList() err := cap.Add(Agent, "foo", "bar") - c.Assert(err, check.Equals, ErrMultipleArguments) + s.ErrorIs(err, ErrMultipleArguments) } -func (s *SuiteCapabilities) TestAll(c *check.C) { +func (s *SuiteCapabilities) TestAll() { cap := NewList() - c.Assert(NewList().All(), check.IsNil) + s.Nil(NewList().All()) cap.Add(Agent, "foo") - c.Assert(cap.All(), check.DeepEquals, []Capability{Agent}) + s.Equal([]Capability{Agent}, cap.All()) cap.Add(OFSDelta) - c.Assert(cap.All(), check.DeepEquals, []Capability{Agent, OFSDelta}) + s.Equal([]Capability{Agent, OFSDelta}, cap.All()) } diff --git a/plumbing/protocol/packp/common.go b/plumbing/protocol/packp/common.go index a858323e7..1dc97f625 100644 --- a/plumbing/protocol/packp/common.go +++ b/plumbing/protocol/packp/common.go @@ -32,6 +32,8 @@ var ( deepenCommits = []byte("deepen ") deepenSince = []byte("deepen-since ") deepenReference = []byte("deepen-not ") + have = []byte("have ") + done = []byte("done") // shallow-update unshallow = []byte("unshallow ") diff --git a/plumbing/protocol/packp/common_test.go b/plumbing/protocol/packp/common_test.go index 7989388c8..8efc67809 100644 --- a/plumbing/protocol/packp/common_test.go +++ b/plumbing/protocol/packp/common_test.go @@ -2,32 +2,41 @@ package packp import ( "bytes" + "fmt" "io" "testing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" + "github.com/stretchr/testify/assert" ) -func Test(t *testing.T) { TestingT(t) } - // returns a byte slice with the pkt-lines for the given payloads. -func pktlines(c *C, payloads ...string) []byte { +func pktlines(t *testing.T, payloads ...string) []byte { var buf bytes.Buffer - e := pktline.NewEncoder(&buf) - err := e.EncodeString(payloads...) - c.Assert(err, IsNil, Commentf("building pktlines for %v\n", payloads)) + comment := fmt.Sprintf("building pktlines for %v\n", payloads) + for _, p := range payloads { + if p == "" { + assert.NoError(t, pktline.WriteFlush(&buf), comment) + } else { + _, err := pktline.WriteString(&buf, p) + assert.NoError(t, err, comment) + } + } return buf.Bytes() } -func toPktLines(c *C, payloads []string) io.Reader { +func toPktLines(t *testing.T, payloads []string) io.Reader { var buf bytes.Buffer - e := pktline.NewEncoder(&buf) - err := e.EncodeString(payloads...) - c.Assert(err, IsNil) + for _, p := range payloads { + if p == "" { + assert.Nil(t, pktline.WriteFlush(&buf)) + } else { + _, err := pktline.WriteString(&buf, p) + assert.NoError(t, err) + } + } return &buf } diff --git a/plumbing/protocol/packp/filter.go b/plumbing/protocol/packp/filter.go index 145fc711c..08932af11 100644 --- a/plumbing/protocol/packp/filter.go +++ b/plumbing/protocol/packp/filter.go @@ -3,7 +3,7 @@ package packp import ( "errors" "fmt" - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" "net/url" "strings" ) diff --git a/plumbing/protocol/packp/filter_test.go b/plumbing/protocol/packp/filter_test.go index 266670fae..74553926c 100644 --- a/plumbing/protocol/packp/filter_test.go +++ b/plumbing/protocol/packp/filter_test.go @@ -1,7 +1,7 @@ package packp import ( - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" "github.com/stretchr/testify/require" "testing" ) diff --git a/plumbing/protocol/packp/gitproto.go b/plumbing/protocol/packp/gitproto.go index 0b7ff8f82..ee52a3ccc 100644 --- a/plumbing/protocol/packp/gitproto.go +++ b/plumbing/protocol/packp/gitproto.go @@ -1,18 +1,17 @@ package packp import ( + "errors" "fmt" "io" "strings" - "github.com/go-git/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" ) -var ( - // ErrInvalidGitProtoRequest is returned by Decode if the input is not a - // valid git protocol request. - ErrInvalidGitProtoRequest = fmt.Errorf("invalid git protocol request") -) +// ErrInvalidGitProtoRequest is returned by Decode if the input is not a +// valid git protocol request. +var ErrInvalidGitProtoRequest = fmt.Errorf("invalid git protocol request") // GitProtoRequest is a command request for the git protocol. // It is used to send the command, endpoint, and extra parameters to the @@ -52,7 +51,6 @@ func (g *GitProtoRequest) Encode(w io.Writer) error { return err } - p := pktline.NewEncoder(w) req := fmt.Sprintf("%s %s\x00", g.RequestCommand, g.Pathname) if host := g.Host; host != "" { req += fmt.Sprintf("host=%s\x00", host) @@ -65,7 +63,7 @@ func (g *GitProtoRequest) Encode(w io.Writer) error { } } - if err := p.Encode([]byte(req)); err != nil { + if _, err := pktline.Writef(w, req); err != nil { return err } @@ -74,16 +72,15 @@ func (g *GitProtoRequest) Encode(w io.Writer) error { // Decode decodes the request from the reader. func (g *GitProtoRequest) Decode(r io.Reader) error { - s := pktline.NewScanner(r) - if !s.Scan() { - err := s.Err() - if err == nil { - return ErrInvalidGitProtoRequest - } + _, p, err := pktline.ReadLine(r) + if errors.Is(err, io.EOF) { + return ErrInvalidGitProtoRequest + } + if err != nil { return err } - line := string(s.Bytes()) + line := string(p) if len(line) == 0 { return io.EOF } diff --git a/plumbing/protocol/packp/report_status.go b/plumbing/protocol/packp/report_status.go index e2a0a108b..38c9ff2e2 100644 --- a/plumbing/protocol/packp/report_status.go +++ b/plumbing/protocol/packp/report_status.go @@ -2,12 +2,13 @@ package packp import ( "bytes" + "errors" "fmt" "io" "strings" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" ) const ( @@ -43,8 +44,7 @@ func (s *ReportStatus) Error() error { // Encode writes the report status to a writer. func (s *ReportStatus) Encode(w io.Writer) error { - e := pktline.NewEncoder(w) - if err := e.Encodef("unpack %s\n", s.UnpackStatus); err != nil { + if _, err := pktline.Writef(w, "unpack %s\n", s.UnpackStatus); err != nil { return err } @@ -54,25 +54,30 @@ func (s *ReportStatus) Encode(w io.Writer) error { } } - return e.Flush() + return pktline.WriteFlush(w) } // Decode reads from the given reader and decodes a report-status message. It // does not read more input than what is needed to fill the report status. func (s *ReportStatus) Decode(r io.Reader) error { - scan := pktline.NewScanner(r) - if err := s.scanFirstLine(scan); err != nil { + b, err := s.scanFirstLine(r) + if err != nil { return err } - if err := s.decodeReportStatus(scan.Bytes()); err != nil { + if err := s.decodeReportStatus(b); err != nil { return err } + var l int flushed := false - for scan.Scan() { - b := scan.Bytes() - if isFlush(b) { + for { + l, b, err = pktline.ReadLine(r) + if err != nil { + break + } + + if l == pktline.Flush { flushed = true break } @@ -86,19 +91,23 @@ func (s *ReportStatus) Decode(r io.Reader) error { return fmt.Errorf("missing flush") } - return scan.Err() + if err != nil && !errors.Is(err, io.EOF) { + return err + } + + return nil } -func (s *ReportStatus) scanFirstLine(scan *pktline.Scanner) error { - if scan.Scan() { - return nil +func (s *ReportStatus) scanFirstLine(r io.Reader) ([]byte, error) { + _, p, err := pktline.ReadLine(r) + if errors.Is(err, io.EOF) { + return p, io.ErrUnexpectedEOF } - - if scan.Err() != nil { - return scan.Err() + if err != nil { + return nil, err } - return io.ErrUnexpectedEOF + return p, nil } func (s *ReportStatus) decodeReportStatus(b []byte) error { @@ -156,10 +165,11 @@ func (s *CommandStatus) Error() error { } func (s *CommandStatus) encode(w io.Writer) error { - e := pktline.NewEncoder(w) if s.Error() == nil { - return e.Encodef("ok %s\n", s.ReferenceName.String()) + _, err := pktline.Writef(w, "ok %s\n", s.ReferenceName.String()) + return err } - return e.Encodef("ng %s %s\n", s.ReferenceName.String(), s.Status) + _, err := pktline.Writef(w, "ng %s %s\n", s.ReferenceName.String(), s.Status) + return err } diff --git a/plumbing/protocol/packp/report_status_test.go b/plumbing/protocol/packp/report_status_test.go index 32b9e5b80..191aea82d 100644 --- a/plumbing/protocol/packp/report_status_test.go +++ b/plumbing/protocol/packp/report_status_test.go @@ -2,68 +2,73 @@ package packp import ( "bytes" + "fmt" + "regexp" + "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/stretchr/testify/suite" ) -type ReportStatusSuite struct{} +type ReportStatusSuite struct { + suite.Suite +} -var _ = Suite(&ReportStatusSuite{}) +func TestReportStatusSuite(t *testing.T) { + suite.Run(t, new(ReportStatusSuite)) +} -func (s *ReportStatusSuite) TestError(c *C) { +func (s *ReportStatusSuite) TestError() { rs := NewReportStatus() rs.UnpackStatus = "ok" - c.Assert(rs.Error(), IsNil) + s.Nil(rs.Error()) rs.UnpackStatus = "OK" - c.Assert(rs.Error(), ErrorMatches, "unpack error: OK") + s.Regexp(regexp.MustCompile("unpack error: OK"), rs.Error()) rs.UnpackStatus = "" - c.Assert(rs.Error(), ErrorMatches, "unpack error: ") + s.Regexp(regexp.MustCompile("unpack error: "), rs.Error()) cs := &CommandStatus{ReferenceName: plumbing.ReferenceName("ref")} rs.UnpackStatus = "ok" rs.CommandStatuses = append(rs.CommandStatuses, cs) cs.Status = "ok" - c.Assert(rs.Error(), IsNil) + s.NoError(rs.Error()) cs.Status = "OK" - c.Assert(rs.Error(), ErrorMatches, "command error on ref: OK") + s.Regexp(regexp.MustCompile("command error on ref: OK"), rs.Error()) cs.Status = "" - c.Assert(rs.Error(), ErrorMatches, "command error on ref: ") + s.Regexp(regexp.MustCompile("command error on ref: "), rs.Error()) } -func (s *ReportStatusSuite) testEncodeDecodeOk(c *C, rs *ReportStatus, lines ...string) { - s.testDecodeOk(c, rs, lines...) - s.testEncodeOk(c, rs, lines...) +func (s *ReportStatusSuite) testEncodeDecodeOk(rs *ReportStatus, lines ...string) { + s.testDecodeOk(rs, lines...) + s.testEncodeOk(rs, lines...) } -func (s *ReportStatusSuite) testDecodeOk(c *C, expected *ReportStatus, lines ...string) { - r := toPktLines(c, lines) +func (s *ReportStatusSuite) testDecodeOk(expected *ReportStatus, lines ...string) { + r := toPktLines(s.T(), lines) rs := NewReportStatus() - c.Assert(rs.Decode(r), IsNil) - c.Assert(rs, DeepEquals, expected) + s.Nil(rs.Decode(r)) + s.Equal(expected, rs) } -func (s *ReportStatusSuite) testDecodeError(c *C, errorMatch string, lines ...string) { - r := toPktLines(c, lines) +func (s *ReportStatusSuite) testDecodeError(errorMatch string, lines ...string) { + r := toPktLines(s.T(), lines) rs := NewReportStatus() - c.Assert(rs.Decode(r), ErrorMatches, errorMatch) + s.Regexp(regexp.MustCompile(errorMatch), rs.Decode(r)) } -func (s *ReportStatusSuite) testEncodeOk(c *C, input *ReportStatus, lines ...string) { - expected := pktlines(c, lines...) +func (s *ReportStatusSuite) testEncodeOk(input *ReportStatus, lines ...string) { + expected := pktlines(s.T(), lines...) var buf bytes.Buffer - c.Assert(input.Encode(&buf), IsNil) + s.Nil(input.Encode(&buf)) obtained := buf.Bytes() - comment := Commentf("\nobtained = %s\nexpected = %s\n", string(obtained), string(expected)) + comment := fmt.Sprintf("\nobtained = %s\nexpected = %s\n", string(obtained), string(expected)) - c.Assert(obtained, DeepEquals, expected, comment) + s.Equal(expected, obtained, comment) } -func (s *ReportStatusSuite) TestEncodeDecodeOkOneReference(c *C) { +func (s *ReportStatusSuite) TestEncodeDecodeOkOneReference() { rs := NewReportStatus() rs.UnpackStatus = "ok" rs.CommandStatuses = []*CommandStatus{{ @@ -71,14 +76,14 @@ func (s *ReportStatusSuite) TestEncodeDecodeOkOneReference(c *C) { Status: "ok", }} - s.testEncodeDecodeOk(c, rs, + s.testEncodeDecodeOk(rs, "unpack ok\n", "ok refs/heads/master\n", - pktline.FlushString, + "", ) } -func (s *ReportStatusSuite) TestEncodeDecodeOkOneReferenceFailed(c *C) { +func (s *ReportStatusSuite) TestEncodeDecodeOkOneReferenceFailed() { rs := NewReportStatus() rs.UnpackStatus = "my error" rs.CommandStatuses = []*CommandStatus{{ @@ -86,14 +91,14 @@ func (s *ReportStatusSuite) TestEncodeDecodeOkOneReferenceFailed(c *C) { Status: "command error", }} - s.testEncodeDecodeOk(c, rs, + s.testEncodeDecodeOk(rs, "unpack my error\n", "ng refs/heads/master command error\n", - pktline.FlushString, + "", ) } -func (s *ReportStatusSuite) TestEncodeDecodeOkMoreReferences(c *C) { +func (s *ReportStatusSuite) TestEncodeDecodeOkMoreReferences() { rs := NewReportStatus() rs.UnpackStatus = "ok" rs.CommandStatuses = []*CommandStatus{{ @@ -107,16 +112,16 @@ func (s *ReportStatusSuite) TestEncodeDecodeOkMoreReferences(c *C) { Status: "ok", }} - s.testEncodeDecodeOk(c, rs, + s.testEncodeDecodeOk(rs, "unpack ok\n", "ok refs/heads/master\n", "ok refs/heads/a\n", "ok refs/heads/b\n", - pktline.FlushString, + "", ) } -func (s *ReportStatusSuite) TestEncodeDecodeOkMoreReferencesFailed(c *C) { +func (s *ReportStatusSuite) TestEncodeDecodeOkMoreReferencesFailed() { rs := NewReportStatus() rs.UnpackStatus = "my error" rs.CommandStatuses = []*CommandStatus{{ @@ -130,36 +135,36 @@ func (s *ReportStatusSuite) TestEncodeDecodeOkMoreReferencesFailed(c *C) { Status: "ok", }} - s.testEncodeDecodeOk(c, rs, + s.testEncodeDecodeOk(rs, "unpack my error\n", "ok refs/heads/master\n", "ng refs/heads/a command error\n", "ok refs/heads/b\n", - pktline.FlushString, + "", ) } -func (s *ReportStatusSuite) TestEncodeDecodeOkNoReferences(c *C) { +func (s *ReportStatusSuite) TestEncodeDecodeOkNoReferences() { expected := NewReportStatus() expected.UnpackStatus = "ok" - s.testEncodeDecodeOk(c, expected, + s.testEncodeDecodeOk(expected, "unpack ok\n", - pktline.FlushString, + "", ) } -func (s *ReportStatusSuite) TestEncodeDecodeOkNoReferencesFailed(c *C) { +func (s *ReportStatusSuite) TestEncodeDecodeOkNoReferencesFailed() { rs := NewReportStatus() rs.UnpackStatus = "my error" - s.testEncodeDecodeOk(c, rs, + s.testEncodeDecodeOk(rs, "unpack my error\n", - pktline.FlushString, + "", ) } -func (s *ReportStatusSuite) TestDecodeErrorOneReferenceNoFlush(c *C) { +func (s *ReportStatusSuite) TestDecodeErrorOneReferenceNoFlush() { expected := NewReportStatus() expected.UnpackStatus = "ok" expected.CommandStatuses = []*CommandStatus{{ @@ -167,13 +172,13 @@ func (s *ReportStatusSuite) TestDecodeErrorOneReferenceNoFlush(c *C) { Status: "ok", }} - s.testDecodeError(c, "missing flush", + s.testDecodeError("missing flush", "unpack ok\n", "ok refs/heads/master\n", ) } -func (s *ReportStatusSuite) TestDecodeErrorEmpty(c *C) { +func (s *ReportStatusSuite) TestDecodeErrorEmpty() { expected := NewReportStatus() expected.UnpackStatus = "ok" expected.CommandStatuses = []*CommandStatus{{ @@ -181,10 +186,10 @@ func (s *ReportStatusSuite) TestDecodeErrorEmpty(c *C) { Status: "ok", }} - s.testDecodeError(c, "unexpected EOF") + s.testDecodeError("unexpected EOF") } -func (s *ReportStatusSuite) TestDecodeErrorMalformed(c *C) { +func (s *ReportStatusSuite) TestDecodeErrorMalformed() { expected := NewReportStatus() expected.UnpackStatus = "ok" expected.CommandStatuses = []*CommandStatus{{ @@ -192,13 +197,13 @@ func (s *ReportStatusSuite) TestDecodeErrorMalformed(c *C) { Status: "ok", }} - s.testDecodeError(c, "malformed unpack status: unpackok", + s.testDecodeError("malformed unpack status: unpackok", "unpackok\n", - pktline.FlushString, + "", ) } -func (s *ReportStatusSuite) TestDecodeErrorMalformed2(c *C) { +func (s *ReportStatusSuite) TestDecodeErrorMalformed2() { expected := NewReportStatus() expected.UnpackStatus = "ok" expected.CommandStatuses = []*CommandStatus{{ @@ -206,13 +211,13 @@ func (s *ReportStatusSuite) TestDecodeErrorMalformed2(c *C) { Status: "ok", }} - s.testDecodeError(c, "malformed unpack status: UNPACK OK", + s.testDecodeError("malformed unpack status: UNPACK OK", "UNPACK OK\n", - pktline.FlushString, + "", ) } -func (s *ReportStatusSuite) TestDecodeErrorMalformedCommandStatus(c *C) { +func (s *ReportStatusSuite) TestDecodeErrorMalformedCommandStatus() { expected := NewReportStatus() expected.UnpackStatus = "ok" expected.CommandStatuses = []*CommandStatus{{ @@ -220,14 +225,14 @@ func (s *ReportStatusSuite) TestDecodeErrorMalformedCommandStatus(c *C) { Status: "ok", }} - s.testDecodeError(c, "malformed command status: ko refs/heads/master", + s.testDecodeError("malformed command status: ko refs/heads/master", "unpack ok\n", "ko refs/heads/master\n", - pktline.FlushString, + "", ) } -func (s *ReportStatusSuite) TestDecodeErrorMalformedCommandStatus2(c *C) { +func (s *ReportStatusSuite) TestDecodeErrorMalformedCommandStatus2() { expected := NewReportStatus() expected.UnpackStatus = "ok" expected.CommandStatuses = []*CommandStatus{{ @@ -235,14 +240,14 @@ func (s *ReportStatusSuite) TestDecodeErrorMalformedCommandStatus2(c *C) { Status: "ok", }} - s.testDecodeError(c, "malformed command status: ng refs/heads/master", + s.testDecodeError("malformed command status: ng refs/heads/master", "unpack ok\n", "ng refs/heads/master\n", - pktline.FlushString, + "", ) } -func (s *ReportStatusSuite) TestDecodeErrorPrematureFlush(c *C) { +func (s *ReportStatusSuite) TestDecodeErrorPrematureFlush() { expected := NewReportStatus() expected.UnpackStatus = "ok" expected.CommandStatuses = []*CommandStatus{{ @@ -250,7 +255,7 @@ func (s *ReportStatusSuite) TestDecodeErrorPrematureFlush(c *C) { Status: "ok", }} - s.testDecodeError(c, "premature flush", - pktline.FlushString, + s.testDecodeError("premature flush", + "", ) } diff --git a/plumbing/protocol/packp/shallowupd.go b/plumbing/protocol/packp/shallowupd.go index fe4fe6887..dd2fc298e 100644 --- a/plumbing/protocol/packp/shallowupd.go +++ b/plumbing/protocol/packp/shallowupd.go @@ -5,8 +5,8 @@ import ( "fmt" "io" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" ) const ( @@ -20,19 +20,23 @@ type ShallowUpdate struct { } func (r *ShallowUpdate) Decode(reader io.Reader) error { - s := pktline.NewScanner(reader) - - for s.Scan() { - line := s.Bytes() - line = bytes.TrimSpace(line) + var ( + p []byte + err error + ) + for { + _, p, err = pktline.ReadLine(reader) + if err != nil { + break + } - var err error + line := bytes.TrimSpace(p) switch { case bytes.HasPrefix(line, shallow): err = r.decodeShallowLine(line) case bytes.HasPrefix(line, unshallow): err = r.decodeUnshallowLine(line) - case bytes.Equal(line, pktline.Flush): + case len(line) == 0: return nil } @@ -41,7 +45,11 @@ func (r *ShallowUpdate) Decode(reader io.Reader) error { } } - return s.Err() + if err != nil && err != io.EOF { + return err + } + + return nil } func (r *ShallowUpdate) decodeShallowLine(line []byte) error { @@ -74,19 +82,17 @@ func (r *ShallowUpdate) decodeLine(line, prefix []byte, expLen int) (plumbing.Ha } func (r *ShallowUpdate) Encode(w io.Writer) error { - e := pktline.NewEncoder(w) - for _, h := range r.Shallows { - if err := e.Encodef("%s%s\n", shallow, h.String()); err != nil { + if _, err := pktline.Writef(w, "%s%s\n", shallow, h.String()); err != nil { return err } } for _, h := range r.Unshallows { - if err := e.Encodef("%s%s\n", unshallow, h.String()); err != nil { + if _, err := pktline.Writef(w, "%s%s\n", unshallow, h.String()); err != nil { return err } } - return e.Flush() + return pktline.WriteFlush(w) } diff --git a/plumbing/protocol/packp/shallowupd_test.go b/plumbing/protocol/packp/shallowupd_test.go index a78ba9049..9426e3cea 100644 --- a/plumbing/protocol/packp/shallowupd_test.go +++ b/plumbing/protocol/packp/shallowupd_test.go @@ -2,17 +2,21 @@ package packp import ( "bytes" + "testing" - "github.com/go-git/go-git/v5/plumbing" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/stretchr/testify/suite" ) -type ShallowUpdateSuite struct{} +type ShallowUpdateSuite struct { + suite.Suite +} -var _ = Suite(&ShallowUpdateSuite{}) +func TestShallowUpdateSuite(t *testing.T) { + suite.Run(t, new(ShallowUpdateSuite)) +} -func (s *ShallowUpdateSuite) TestDecodeWithLF(c *C) { +func (s *ShallowUpdateSuite) TestDecodeWithLF() { raw := "" + "0035shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + "0035shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" + @@ -20,19 +24,19 @@ func (s *ShallowUpdateSuite) TestDecodeWithLF(c *C) { su := &ShallowUpdate{} err := su.Decode(bytes.NewBufferString(raw)) - c.Assert(err, IsNil) + s.NoError(err) plumbing.HashesSort(su.Shallows) - c.Assert(su.Unshallows, HasLen, 0) - c.Assert(su.Shallows, HasLen, 2) - c.Assert(su.Shallows, DeepEquals, []plumbing.Hash{ + s.Len(su.Unshallows, 0) + s.Len(su.Shallows, 2) + s.Equal([]plumbing.Hash{ plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"), - }) + }, su.Shallows) } -func (s *ShallowUpdateSuite) TestDecode(c *C) { +func (s *ShallowUpdateSuite) TestDecode() { raw := "" + "0034shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + "0034shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" + @@ -40,19 +44,19 @@ func (s *ShallowUpdateSuite) TestDecode(c *C) { su := &ShallowUpdate{} err := su.Decode(bytes.NewBufferString(raw)) - c.Assert(err, IsNil) + s.NoError(err) plumbing.HashesSort(su.Shallows) - c.Assert(su.Unshallows, HasLen, 0) - c.Assert(su.Shallows, HasLen, 2) - c.Assert(su.Shallows, DeepEquals, []plumbing.Hash{ + s.Len(su.Unshallows, 0) + s.Len(su.Shallows, 2) + s.Equal([]plumbing.Hash{ plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"), - }) + }, su.Shallows) } -func (s *ShallowUpdateSuite) TestDecodeUnshallow(c *C) { +func (s *ShallowUpdateSuite) TestDecodeUnshallow() { raw := "" + "0036unshallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + "0036unshallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" + @@ -60,36 +64,36 @@ func (s *ShallowUpdateSuite) TestDecodeUnshallow(c *C) { su := &ShallowUpdate{} err := su.Decode(bytes.NewBufferString(raw)) - c.Assert(err, IsNil) + s.NoError(err) plumbing.HashesSort(su.Unshallows) - c.Assert(su.Shallows, HasLen, 0) - c.Assert(su.Unshallows, HasLen, 2) - c.Assert(su.Unshallows, DeepEquals, []plumbing.Hash{ + s.Len(su.Shallows, 0) + s.Len(su.Unshallows, 2) + s.Equal([]plumbing.Hash{ plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"), - }) + }, su.Unshallows) } -func (s *ShallowUpdateSuite) TestDecodeMalformed(c *C) { +func (s *ShallowUpdateSuite) TestDecodeMalformed() { raw := "" + "0035unshallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + "0000" su := &ShallowUpdate{} err := su.Decode(bytes.NewBufferString(raw)) - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *ShallowUpdateSuite) TestEncodeEmpty(c *C) { +func (s *ShallowUpdateSuite) TestEncodeEmpty() { su := &ShallowUpdate{} buf := bytes.NewBuffer(nil) - c.Assert(su.Encode(buf), IsNil) - c.Assert(buf.String(), Equals, "0000") + s.Nil(su.Encode(buf)) + s.Equal("0000", buf.String()) } -func (s *ShallowUpdateSuite) TestEncode(c *C) { +func (s *ShallowUpdateSuite) TestEncode() { su := &ShallowUpdate{ Shallows: []plumbing.Hash{ plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), @@ -101,7 +105,7 @@ func (s *ShallowUpdateSuite) TestEncode(c *C) { }, } buf := bytes.NewBuffer(nil) - c.Assert(su.Encode(buf), IsNil) + s.Nil(su.Encode(buf)) expected := "" + "0035shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + @@ -110,10 +114,10 @@ func (s *ShallowUpdateSuite) TestEncode(c *C) { "0037unshallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" + "0000" - c.Assert(buf.String(), Equals, expected) + s.Equal(expected, buf.String()) } -func (s *ShallowUpdateSuite) TestEncodeShallow(c *C) { +func (s *ShallowUpdateSuite) TestEncodeShallow() { su := &ShallowUpdate{ Shallows: []plumbing.Hash{ plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), @@ -121,17 +125,17 @@ func (s *ShallowUpdateSuite) TestEncodeShallow(c *C) { }, } buf := bytes.NewBuffer(nil) - c.Assert(su.Encode(buf), IsNil) + s.Nil(su.Encode(buf)) expected := "" + "0035shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + "0035shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" + "0000" - c.Assert(buf.String(), Equals, expected) + s.Equal(expected, buf.String()) } -func (s *ShallowUpdateSuite) TestEncodeUnshallow(c *C) { +func (s *ShallowUpdateSuite) TestEncodeUnshallow() { su := &ShallowUpdate{ Unshallows: []plumbing.Hash{ plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), @@ -139,12 +143,12 @@ func (s *ShallowUpdateSuite) TestEncodeUnshallow(c *C) { }, } buf := bytes.NewBuffer(nil) - c.Assert(su.Encode(buf), IsNil) + s.Nil(su.Encode(buf)) expected := "" + "0037unshallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + "0037unshallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" + "0000" - c.Assert(buf.String(), Equals, expected) + s.Equal(expected, buf.String()) } diff --git a/plumbing/protocol/packp/sideband/demux.go b/plumbing/protocol/packp/sideband/demux.go index 01d95a3ab..27adba8c6 100644 --- a/plumbing/protocol/packp/sideband/demux.go +++ b/plumbing/protocol/packp/sideband/demux.go @@ -5,7 +5,7 @@ import ( "fmt" "io" - "github.com/go-git/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" ) // ErrMaxPackedExceeded returned by Read, if the maximum packed size is exceeded @@ -33,7 +33,6 @@ type Progress interface { type Demuxer struct { t Type r io.Reader - s *pktline.Scanner max int pending []byte @@ -53,7 +52,6 @@ func NewDemuxer(t Type, r io.Reader) *Demuxer { t: t, r: r, max: max, - s: pktline.NewScanner(r), } } @@ -102,15 +100,12 @@ func (d *Demuxer) nextPackData() ([]byte, error) { return content, nil } - if !d.s.Scan() { - if err := d.s.Err(); err != nil { - return nil, err - } - - return nil, io.EOF + _, p, err := pktline.ReadLine(d.r) + if err != nil { + return nil, err } - content = d.s.Bytes() + content = p size := len(content) if size == 0 { diff --git a/plumbing/protocol/packp/sideband/demux_test.go b/plumbing/protocol/packp/sideband/demux_test.go index 1ba3ad9a1..a37eb69d5 100644 --- a/plumbing/protocol/packp/sideband/demux_test.go +++ b/plumbing/protocol/packp/sideband/demux_test.go @@ -6,89 +6,86 @@ import ( "io" "testing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } - -type SidebandSuite struct{} +type SidebandSuite struct { + suite.Suite +} -var _ = Suite(&SidebandSuite{}) +func TestSidebandSuite(t *testing.T) { + suite.Run(t, new(SidebandSuite)) +} -func (s *SidebandSuite) TestDecode(c *C) { +func (s *SidebandSuite) TestDecode() { expected := []byte("abcdefghijklmnopqrstuvwxyz") buf := bytes.NewBuffer(nil) - e := pktline.NewEncoder(buf) - e.Encode(PackData.WithPayload(expected[0:8])) - e.Encode(ProgressMessage.WithPayload([]byte{'F', 'O', 'O', '\n'})) - e.Encode(PackData.WithPayload(expected[8:16])) - e.Encode(PackData.WithPayload(expected[16:26])) + pktline.Write(buf, PackData.WithPayload(expected[0:8])) + pktline.Write(buf, ProgressMessage.WithPayload([]byte{'F', 'O', 'O', '\n'})) + pktline.Write(buf, PackData.WithPayload(expected[8:16])) + pktline.Write(buf, PackData.WithPayload(expected[16:26])) content := make([]byte, 26) d := NewDemuxer(Sideband64k, buf) n, err := io.ReadFull(d, content) - c.Assert(err, IsNil) - c.Assert(n, Equals, 26) - c.Assert(content, DeepEquals, expected) + s.NoError(err) + s.Equal(26, n) + s.Equal(expected, content) } -func (s *SidebandSuite) TestDecodeMoreThanContain(c *C) { +func (s *SidebandSuite) TestDecodeMoreThanContain() { expected := []byte("abcdefghijklmnopqrstuvwxyz") buf := bytes.NewBuffer(nil) - e := pktline.NewEncoder(buf) - e.Encode(PackData.WithPayload(expected)) + pktline.Write(buf, PackData.WithPayload(expected)) content := make([]byte, 42) d := NewDemuxer(Sideband64k, buf) n, err := io.ReadFull(d, content) - c.Assert(err, Equals, io.ErrUnexpectedEOF) - c.Assert(n, Equals, 26) - c.Assert(content[0:26], DeepEquals, expected) + s.ErrorIs(err, io.ErrUnexpectedEOF) + s.Equal(26, n) + s.Equal(expected, content[0:26]) } -func (s *SidebandSuite) TestDecodeWithError(c *C) { +func (s *SidebandSuite) TestDecodeWithError() { expected := []byte("abcdefghijklmnopqrstuvwxyz") buf := bytes.NewBuffer(nil) - e := pktline.NewEncoder(buf) - e.Encode(PackData.WithPayload(expected[0:8])) - e.Encode(ErrorMessage.WithPayload([]byte{'F', 'O', 'O', '\n'})) - e.Encode(PackData.WithPayload(expected[8:16])) - e.Encode(PackData.WithPayload(expected[16:26])) + pktline.Write(buf, PackData.WithPayload(expected[0:8])) + pktline.Write(buf, ErrorMessage.WithPayload([]byte{'F', 'O', 'O', '\n'})) + pktline.Write(buf, PackData.WithPayload(expected[8:16])) + pktline.Write(buf, PackData.WithPayload(expected[16:26])) content := make([]byte, 26) d := NewDemuxer(Sideband64k, buf) n, err := io.ReadFull(d, content) - c.Assert(err, ErrorMatches, "unexpected error: FOO\n") - c.Assert(n, Equals, 8) - c.Assert(content[0:8], DeepEquals, expected[0:8]) + s.ErrorContains(err, "unexpected error: FOO\n") + s.Equal(8, n) + s.Equal(expected[0:8], content[0:8]) } type mockReader struct{} func (r *mockReader) Read([]byte) (int, error) { return 0, errors.New("foo") } -func (s *SidebandSuite) TestDecodeFromFailingReader(c *C) { +func (s *SidebandSuite) TestDecodeFromFailingReader() { content := make([]byte, 26) d := NewDemuxer(Sideband64k, &mockReader{}) n, err := io.ReadFull(d, content) - c.Assert(err, ErrorMatches, "foo") - c.Assert(n, Equals, 0) + s.ErrorContains(err, "foo") + s.Equal(0, n) } -func (s *SidebandSuite) TestDecodeWithProgress(c *C) { +func (s *SidebandSuite) TestDecodeWithProgress() { expected := []byte("abcdefghijklmnopqrstuvwxyz") input := bytes.NewBuffer(nil) - e := pktline.NewEncoder(input) - e.Encode(PackData.WithPayload(expected[0:8])) - e.Encode(ProgressMessage.WithPayload([]byte{'F', 'O', 'O', '\n'})) - e.Encode(PackData.WithPayload(expected[8:16])) - e.Encode(PackData.WithPayload(expected[16:26])) + pktline.Write(input, PackData.WithPayload(expected[0:8])) + pktline.Write(input, ProgressMessage.WithPayload([]byte{'F', 'O', 'O', '\n'})) + pktline.Write(input, PackData.WithPayload(expected[8:16])) + pktline.Write(input, PackData.WithPayload(expected[16:26])) output := bytes.NewBuffer(nil) content := make([]byte, 26) @@ -96,26 +93,25 @@ func (s *SidebandSuite) TestDecodeWithProgress(c *C) { d.Progress = output n, err := io.ReadFull(d, content) - c.Assert(err, IsNil) - c.Assert(n, Equals, 26) - c.Assert(content, DeepEquals, expected) + s.NoError(err) + s.Equal(26, n) + s.Equal(expected, content) progress, err := io.ReadAll(output) - c.Assert(err, IsNil) - c.Assert(progress, DeepEquals, []byte{'F', 'O', 'O', '\n'}) + s.NoError(err) + s.Equal([]byte{'F', 'O', 'O', '\n'}, progress) } -func (s *SidebandSuite) TestDecodeFlushEOF(c *C) { +func (s *SidebandSuite) TestDecodeFlushEOF() { expected := []byte("abcdefghijklmnopqrstuvwxyz") input := bytes.NewBuffer(nil) - e := pktline.NewEncoder(input) - e.Encode(PackData.WithPayload(expected[0:8])) - e.Encode(ProgressMessage.WithPayload([]byte{'F', 'O', 'O', '\n'})) - e.Encode(PackData.WithPayload(expected[8:16])) - e.Encode(PackData.WithPayload(expected[16:26])) - e.Flush() - e.Encode(PackData.WithPayload([]byte("bar\n"))) + pktline.Write(input, PackData.WithPayload(expected[0:8])) + pktline.Write(input, ProgressMessage.WithPayload([]byte{'F', 'O', 'O', '\n'})) + pktline.Write(input, PackData.WithPayload(expected[8:16])) + pktline.Write(input, PackData.WithPayload(expected[16:26])) + pktline.WriteFlush(input) + pktline.Write(input, PackData.WithPayload([]byte("bar\n"))) output := bytes.NewBuffer(nil) content := bytes.NewBuffer(nil) @@ -123,57 +119,54 @@ func (s *SidebandSuite) TestDecodeFlushEOF(c *C) { d.Progress = output n, err := content.ReadFrom(d) - c.Assert(err, IsNil) - c.Assert(n, Equals, int64(26)) - c.Assert(content.Bytes(), DeepEquals, expected) + s.NoError(err) + s.Equal(int64(26), n) + s.Equal(expected, content.Bytes()) progress, err := io.ReadAll(output) - c.Assert(err, IsNil) - c.Assert(progress, DeepEquals, []byte{'F', 'O', 'O', '\n'}) + s.NoError(err) + s.Equal([]byte{'F', 'O', 'O', '\n'}, progress) } -func (s *SidebandSuite) TestDecodeWithUnknownChannel(c *C) { +func (s *SidebandSuite) TestDecodeWithUnknownChannel() { buf := bytes.NewBuffer(nil) - e := pktline.NewEncoder(buf) - e.Encode([]byte{'4', 'F', 'O', 'O', '\n'}) + pktline.Write(buf, []byte{'4', 'F', 'O', 'O', '\n'}) content := make([]byte, 26) d := NewDemuxer(Sideband64k, buf) n, err := io.ReadFull(d, content) - c.Assert(err, ErrorMatches, "unknown channel 4FOO\n") - c.Assert(n, Equals, 0) + s.ErrorContains(err, "unknown channel 4FOO\n") + s.Equal(0, n) } -func (s *SidebandSuite) TestDecodeWithPending(c *C) { +func (s *SidebandSuite) TestDecodeWithPending() { expected := []byte("abcdefghijklmnopqrstuvwxyz") buf := bytes.NewBuffer(nil) - e := pktline.NewEncoder(buf) - e.Encode(PackData.WithPayload(expected[0:8])) - e.Encode(PackData.WithPayload(expected[8:16])) - e.Encode(PackData.WithPayload(expected[16:26])) + pktline.Write(buf, PackData.WithPayload(expected[0:8])) + pktline.Write(buf, PackData.WithPayload(expected[8:16])) + pktline.Write(buf, PackData.WithPayload(expected[16:26])) content := make([]byte, 13) d := NewDemuxer(Sideband64k, buf) n, err := io.ReadFull(d, content) - c.Assert(err, IsNil) - c.Assert(n, Equals, 13) - c.Assert(content, DeepEquals, expected[0:13]) + s.NoError(err) + s.Equal(13, n) + s.Equal(expected[0:13], content) n, err = d.Read(content) - c.Assert(err, IsNil) - c.Assert(n, Equals, 13) - c.Assert(content, DeepEquals, expected[13:26]) + s.NoError(err) + s.Equal(13, n) + s.Equal(expected[13:26], content) } -func (s *SidebandSuite) TestDecodeErrMaxPacked(c *C) { +func (s *SidebandSuite) TestDecodeErrMaxPacked() { buf := bytes.NewBuffer(nil) - e := pktline.NewEncoder(buf) - e.Encode(PackData.WithPayload(bytes.Repeat([]byte{'0'}, MaxPackedSize+1))) + pktline.Write(buf, PackData.WithPayload(bytes.Repeat([]byte{'0'}, MaxPackedSize+1))) content := make([]byte, 13) d := NewDemuxer(Sideband, buf) n, err := io.ReadFull(d, content) - c.Assert(err, Equals, ErrMaxPackedExceeded) - c.Assert(n, Equals, 0) + s.ErrorIs(err, ErrMaxPackedExceeded) + s.Equal(0, n) } diff --git a/plumbing/protocol/packp/sideband/muxer.go b/plumbing/protocol/packp/sideband/muxer.go index d51ac8269..e84cccf25 100644 --- a/plumbing/protocol/packp/sideband/muxer.go +++ b/plumbing/protocol/packp/sideband/muxer.go @@ -3,14 +3,14 @@ package sideband import ( "io" - "github.com/go-git/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" ) // Muxer multiplex the packfile along with the progress messages and the error // information. The multiplex is perform using pktline format. type Muxer struct { max int - e *pktline.Encoder + w io.Writer } const chLen = 1 @@ -28,7 +28,7 @@ func NewMuxer(t Type, w io.Writer) *Muxer { return &Muxer{ max: max - chLen, - e: pktline.NewEncoder(w), + w: w, } } @@ -61,5 +61,6 @@ func (m *Muxer) doWrite(ch Channel, p []byte) (int, error) { sz = m.max } - return sz, m.e.Encode(ch.WithPayload(p[:sz])) + _, err := pktline.Write(m.w, ch.WithPayload(p[:sz])) + return sz, err } diff --git a/plumbing/protocol/packp/sideband/muxer_test.go b/plumbing/protocol/packp/sideband/muxer_test.go index 38fc4bdd1..40bd50447 100644 --- a/plumbing/protocol/packp/sideband/muxer_test.go +++ b/plumbing/protocol/packp/sideband/muxer_test.go @@ -2,38 +2,36 @@ package sideband import ( "bytes" - - . "gopkg.in/check.v1" ) -func (s *SidebandSuite) TestMuxerWrite(c *C) { +func (s *SidebandSuite) TestMuxerWrite() { buf := bytes.NewBuffer(nil) m := NewMuxer(Sideband, buf) n, err := m.Write(bytes.Repeat([]byte{'F'}, (MaxPackedSize-1)*2)) - c.Assert(err, IsNil) - c.Assert(n, Equals, 1998) - c.Assert(buf.Len(), Equals, 2008) + s.NoError(err) + s.Equal(1998, n) + s.Equal(2008, buf.Len()) } -func (s *SidebandSuite) TestMuxerWriteChannelMultipleChannels(c *C) { +func (s *SidebandSuite) TestMuxerWriteChannelMultipleChannels() { buf := bytes.NewBuffer(nil) m := NewMuxer(Sideband, buf) n, err := m.WriteChannel(PackData, bytes.Repeat([]byte{'D'}, 4)) - c.Assert(err, IsNil) - c.Assert(n, Equals, 4) + s.NoError(err) + s.Equal(4, n) n, err = m.WriteChannel(ProgressMessage, bytes.Repeat([]byte{'P'}, 4)) - c.Assert(err, IsNil) - c.Assert(n, Equals, 4) + s.NoError(err) + s.Equal(4, n) n, err = m.WriteChannel(PackData, bytes.Repeat([]byte{'D'}, 4)) - c.Assert(err, IsNil) - c.Assert(n, Equals, 4) + s.NoError(err) + s.Equal(4, n) - c.Assert(buf.Len(), Equals, 27) - c.Assert(buf.String(), Equals, "0009\x01DDDD0009\x02PPPP0009\x01DDDD") + s.Equal(27, buf.Len()) + s.Equal("0009\x01DDDD0009\x02PPPP0009\x01DDDD", buf.String()) } diff --git a/plumbing/protocol/packp/srvresp.go b/plumbing/protocol/packp/srvresp.go index a9ddb538b..81c359dc0 100644 --- a/plumbing/protocol/packp/srvresp.go +++ b/plumbing/protocol/packp/srvresp.go @@ -7,8 +7,10 @@ import ( "fmt" "io" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/jesseduffield/go-git/v5/utils/ioutil" ) const ackLineLen = 44 @@ -16,24 +18,30 @@ const ackLineLen = 44 // ServerResponse object acknowledgement from upload-pack service type ServerResponse struct { ACKs []plumbing.Hash + req *UploadPackRequest } // Decode decodes the response into the struct, isMultiACK should be true, if // the request was done with multi_ack or multi_ack_detailed capabilities. -func (r *ServerResponse) Decode(reader *bufio.Reader, isMultiACK bool) error { - s := pktline.NewScanner(reader) +func (r *ServerResponse) Decode(reader io.Reader, isMultiACK bool) error { + s := bufio.NewReader(reader) - for s.Scan() { - line := s.Bytes() + var err error + for { + var p []byte + _, p, err = pktline.ReadLine(s) + if err != nil { + break + } - if err := r.decodeLine(line); err != nil { + if err := r.decodeLine(p); err != nil { return err } // we need to detect when the end of a response header and the beginning // of a packfile header happened, some requests to the git daemon // produces a duplicate ACK header even when multi_ack is not supported. - stop, err := r.stopReading(reader) + stop, err := r.stopReading(s) if err != nil { return err } @@ -43,20 +51,8 @@ func (r *ServerResponse) Decode(reader *bufio.Reader, isMultiACK bool) error { } } - // isMultiACK is true when the remote server advertises the related - // capabilities when they are not in transport.UnsupportedCapabilities. - // - // Users may decide to remove multi_ack and multi_ack_detailed from the - // unsupported capabilities list, which allows them to do initial clones - // from Azure DevOps. - // - // Follow-up fetches may error, therefore errors are wrapped with additional - // information highlighting that this capabilities are not supported by go-git. - // - // TODO: Implement support for multi_ack or multi_ack_detailed responses. - err := s.Err() - if err != nil && isMultiACK { - return fmt.Errorf("multi_ack and multi_ack_detailed are not supported: %w", err) + if errors.Is(err, io.EOF) { + return nil } return err @@ -64,9 +60,9 @@ func (r *ServerResponse) Decode(reader *bufio.Reader, isMultiACK bool) error { // stopReading detects when a valid command such as ACK or NAK is found to be // read in the buffer without moving the read pointer. -func (r *ServerResponse) stopReading(reader *bufio.Reader) (bool, error) { +func (r *ServerResponse) stopReading(reader ioutil.ReadPeeker) (bool, error) { ahead, err := reader.Peek(7) - if err == io.EOF { + if errors.Is(err, io.EOF) { return true, nil } @@ -120,22 +116,83 @@ func (r *ServerResponse) decodeACKLine(line []byte) error { } sp := bytes.Index(line, []byte(" ")) + if sp+41 > len(line) { + return fmt.Errorf("malformed ACK %q", line) + } h := plumbing.NewHash(string(line[sp+1 : sp+41])) r.ACKs = append(r.ACKs, h) return nil } // Encode encodes the ServerResponse into a writer. -func (r *ServerResponse) Encode(w io.Writer, isMultiACK bool) error { - if len(r.ACKs) > 1 && !isMultiACK { - // For further information, refer to comments in the Decode func above. - return errors.New("multi_ack and multi_ack_detailed are not supported") +func (r *ServerResponse) Encode(w io.Writer) error { + multiAck := r.req.Capabilities.Supports(capability.MultiACK) + multiAckDetailed := r.req.Capabilities.Supports(capability.MultiACKDetailed) + readyHash := plumbing.ZeroHash + finalHash := plumbing.ZeroHash + for cmd := range r.req.UploadPackCommands { + if multiAck { //multi_ack + for _, h := range cmd.Acks { + if h.IsReady && readyHash.IsZero() { + readyHash = h.Hash + } + if h.IsCommon || !readyHash.IsZero() { + finalHash = h.Hash + if _, err := pktline.Writef(w, "%s %s continue\n", ack, h.Hash.String()); err != nil { + return err + } + } + } + if !cmd.Done { + if _, err := pktline.WriteString(w, string(nak)+"\n"); err != nil { + return err + } + } + } else if multiAckDetailed { //multi_ack_detailed + for _, h := range cmd.Acks { + if h.IsReady { + readyHash = h.Hash + finalHash = h.Hash + if _, err := pktline.Writef(w, "%s %s ready\n", ack, h.Hash.String()); err != nil { + return err + } + } else if h.IsCommon { + finalHash = h.Hash + if _, err := pktline.Writef(w, "%s %s common\n", ack, h.Hash.String()); err != nil { + return err + } + } + } + if !cmd.Done { + if _, err := pktline.WriteString(w, string(nak)+"\n"); err != nil { + return err + } + } + } else { // single ack + for _, h := range cmd.Acks { + if h.IsCommon && finalHash.IsZero() { + finalHash = h.Hash + if _, err := pktline.Writef(w, "%s %s\n", ack, finalHash.String()); err != nil { + return err + } + break + } + } + if !cmd.Done && finalHash.IsZero() { + if _, err := pktline.WriteString(w, string(nak)+"\n"); err != nil { + return err + } + } + } } - - e := pktline.NewEncoder(w) - if len(r.ACKs) == 0 { - return e.Encodef("%s\n", nak) + if !finalHash.IsZero() && (multiAck || multiAckDetailed) { + if _, err := pktline.Writef(w, "%s %s\n", ack, finalHash.String()); err != nil { + return err + } + } else if finalHash.IsZero() { + if _, err := pktline.WriteString(w, string(nak)+"\n"); err != nil { + return err + } } - - return e.Encodef("%s %s\n", ack, r.ACKs[0].String()) + return nil } diff --git a/plumbing/protocol/packp/srvresp_test.go b/plumbing/protocol/packp/srvresp_test.go index b7270e79e..5f7d5069c 100644 --- a/plumbing/protocol/packp/srvresp_test.go +++ b/plumbing/protocol/packp/srvresp_test.go @@ -1,119 +1,264 @@ package packp import ( - "bufio" "bytes" "fmt" + "regexp" + "strings" + "testing" - "github.com/go-git/go-git/v5/plumbing" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/stretchr/testify/suite" ) -type ServerResponseSuite struct{} +type ServerResponseSuite struct { + suite.Suite +} -var _ = Suite(&ServerResponseSuite{}) +func TestServerResponseSuite(t *testing.T) { + suite.Run(t, new(ServerResponseSuite)) +} -func (s *ServerResponseSuite) TestDecodeNAK(c *C) { +func (s *ServerResponseSuite) TestDecodeNAK() { raw := "0008NAK\n" sr := &ServerResponse{} - err := sr.Decode(bufio.NewReader(bytes.NewBufferString(raw)), false) - c.Assert(err, IsNil) + err := sr.Decode((bytes.NewBufferString(raw)), false) + s.NoError(err) - c.Assert(sr.ACKs, HasLen, 0) + s.Len(sr.ACKs, 0) } -func (s *ServerResponseSuite) TestDecodeNewLine(c *C) { +func (s *ServerResponseSuite) TestDecodeNewLine() { raw := "\n" sr := &ServerResponse{} - err := sr.Decode(bufio.NewReader(bytes.NewBufferString(raw)), false) - c.Assert(err, NotNil) - c.Assert(err.Error(), Equals, "invalid pkt-len found") + err := sr.Decode(bytes.NewBufferString(raw), false) + s.NotNil(err) + s.Regexp(regexp.MustCompile("invalid pkt-len found.*"), err.Error()) } -func (s *ServerResponseSuite) TestDecodeEmpty(c *C) { +func (s *ServerResponseSuite) TestDecodeEmpty() { raw := "" sr := &ServerResponse{} - err := sr.Decode(bufio.NewReader(bytes.NewBufferString(raw)), false) - c.Assert(err, IsNil) + err := sr.Decode(bytes.NewBufferString(raw), false) + s.NoError(err) } -func (s *ServerResponseSuite) TestDecodePartial(c *C) { +func (s *ServerResponseSuite) TestDecodePartial() { raw := "000600\n" sr := &ServerResponse{} - err := sr.Decode(bufio.NewReader(bytes.NewBufferString(raw)), false) - c.Assert(err, NotNil) - c.Assert(err.Error(), Equals, fmt.Sprintf("unexpected content %q", "00")) + err := sr.Decode(bytes.NewBufferString(raw), false) + s.NotNil(err) + s.Equal(fmt.Sprintf("unexpected content %q", "00"), err.Error()) } -func (s *ServerResponseSuite) TestDecodeACK(c *C) { +func (s *ServerResponseSuite) TestDecodeACK() { raw := "0031ACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e5\n" sr := &ServerResponse{} - err := sr.Decode(bufio.NewReader(bytes.NewBufferString(raw)), false) - c.Assert(err, IsNil) + err := sr.Decode(bytes.NewBufferString(raw), false) + s.NoError(err) - c.Assert(sr.ACKs, HasLen, 1) - c.Assert(sr.ACKs[0], Equals, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) + s.Len(sr.ACKs, 1) + s.Equal(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"), sr.ACKs[0]) } -func (s *ServerResponseSuite) TestDecodeMultipleACK(c *C) { +func (s *ServerResponseSuite) TestDecodeMultipleACK() { raw := "" + "0031ACK 1111111111111111111111111111111111111111\n" + "0031ACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e5\n" + "00080PACK\n" sr := &ServerResponse{} - err := sr.Decode(bufio.NewReader(bytes.NewBufferString(raw)), false) - c.Assert(err, IsNil) + err := sr.Decode(bytes.NewBufferString(raw), false) + s.NoError(err) - c.Assert(sr.ACKs, HasLen, 2) - c.Assert(sr.ACKs[0], Equals, plumbing.NewHash("1111111111111111111111111111111111111111")) - c.Assert(sr.ACKs[1], Equals, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) + s.Len(sr.ACKs, 2) + s.Equal(plumbing.NewHash("1111111111111111111111111111111111111111"), sr.ACKs[0]) + s.Equal(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"), sr.ACKs[1]) } -func (s *ServerResponseSuite) TestDecodeMultipleACKWithSideband(c *C) { +func (s *ServerResponseSuite) TestDecodeMultipleACKWithSideband() { raw := "" + "0031ACK 1111111111111111111111111111111111111111\n" + "0031ACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e5\n" + "00080aaaa\n" sr := &ServerResponse{} - err := sr.Decode(bufio.NewReader(bytes.NewBufferString(raw)), false) - c.Assert(err, IsNil) + err := sr.Decode(bytes.NewBufferString(raw), false) + s.NoError(err) - c.Assert(sr.ACKs, HasLen, 2) - c.Assert(sr.ACKs[0], Equals, plumbing.NewHash("1111111111111111111111111111111111111111")) - c.Assert(sr.ACKs[1], Equals, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) + s.Len(sr.ACKs, 2) + s.Equal(plumbing.NewHash("1111111111111111111111111111111111111111"), sr.ACKs[0]) + s.Equal(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"), sr.ACKs[1]) } -func (s *ServerResponseSuite) TestDecodeMalformed(c *C) { +func (s *ServerResponseSuite) TestDecodeMalformed() { raw := "0029ACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e\n" sr := &ServerResponse{} - err := sr.Decode(bufio.NewReader(bytes.NewBufferString(raw)), false) - c.Assert(err, NotNil) + err := sr.Decode(bytes.NewBufferString(raw), false) + s.NotNil(err) } -// multi_ack isn't fully implemented, this ensures that Decode ignores that fact, -// as in some circumstances that's OK to assume so. -// -// TODO: Review as part of multi_ack implementation. -func (s *ServerResponseSuite) TestDecodeMultiACK(c *C) { +func (s *ServerResponseSuite) TestDecodeMultiACK() { raw := "" + "0031ACK 1111111111111111111111111111111111111111\n" + "0031ACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e5\n" + "00080PACK\n" sr := &ServerResponse{} - err := sr.Decode(bufio.NewReader(bytes.NewBufferString(raw)), true) - c.Assert(err, IsNil) + err := sr.Decode(strings.NewReader(raw), true) + s.NoError(err) + + s.Len(sr.ACKs, 2) + s.Equal(plumbing.NewHash("1111111111111111111111111111111111111111"), sr.ACKs[0]) + s.Equal(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"), sr.ACKs[1]) +} + +func (s *ServerResponseSuite) TestEncodeEmpty() { + haves := make(chan UploadPackCommand) + go func() { + haves <- UploadPackCommand{ + Acks: []UploadPackRequestAck{}, + Done: true, + } + close(haves) + }() + sr := &ServerResponse{req: &UploadPackRequest{UploadPackCommands: haves, UploadRequest: UploadRequest{Capabilities: capability.NewList()}}} + b := bytes.NewBuffer(nil) + err := sr.Encode(b) + s.NoError(err) + + s.Equal("0008NAK\n", b.String()) +} + +func (s *ServerResponseSuite) TestEncodeSingleAck() { + haves := make(chan UploadPackCommand) + go func() { + haves <- UploadPackCommand{ + Acks: []UploadPackRequestAck{ + {Hash: plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e1")}, + {Hash: plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e2")}, + {Hash: plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e3"), IsCommon: true}, + }} + close(haves) + }() + sr := &ServerResponse{req: &UploadPackRequest{UploadPackCommands: haves, UploadRequest: UploadRequest{Capabilities: capability.NewList()}}} + b := bytes.NewBuffer(nil) + err := sr.Encode(b) + s.NoError(err) + + s.Equal("0031ACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e3\n", b.String()) +} + +func (s *ServerResponseSuite) TestEncodeSingleAckDone() { + haves := make(chan UploadPackCommand) + go func() { + haves <- UploadPackCommand{ + Acks: []UploadPackRequestAck{ + {Hash: plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e1")}, + {Hash: plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e2")}, + {Hash: plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e3"), IsCommon: true}, + }, + Done: true, + } + close(haves) + }() + sr := &ServerResponse{req: &UploadPackRequest{UploadPackCommands: haves, UploadRequest: UploadRequest{Capabilities: capability.NewList()}}} + b := bytes.NewBuffer(nil) + err := sr.Encode(b) + s.NoError(err) + + s.Equal("0031ACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e3\n", b.String()) +} + +func (s *ServerResponseSuite) TestEncodeMutiAck() { + haves := make(chan UploadPackCommand) + go func() { + haves <- UploadPackCommand{ + Acks: []UploadPackRequestAck{ + {Hash: plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e1")}, + {Hash: plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e2"), IsCommon: true, IsReady: true}, + {Hash: plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e3")}, + }, + } + haves <- UploadPackCommand{ + Acks: []UploadPackRequestAck{}, + Done: true, + } + close(haves) + }() + capabilities := capability.NewList() + capabilities.Add(capability.MultiACK) + sr := &ServerResponse{req: &UploadPackRequest{UploadPackCommands: haves, UploadRequest: UploadRequest{Capabilities: capabilities}}} + b := bytes.NewBuffer(nil) + err := sr.Encode(b) + s.NoError(err) + + lines := strings.Split(b.String(), "\n") + s.Len(lines, 5) + s.Equal("003aACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e2 continue", lines[0]) + s.Equal("003aACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e3 continue", lines[1]) + s.Equal("0008NAK", lines[2]) + s.Equal("0031ACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e3", lines[3]) + s.Equal("", lines[4]) +} + +func (s *ServerResponseSuite) TestEncodeMutiAckOnlyOneNak() { + haves := make(chan UploadPackCommand) + go func() { + haves <- UploadPackCommand{ + Acks: []UploadPackRequestAck{}, //no common hash + Done: true, + } + close(haves) + }() + capabilities := capability.NewList() + capabilities.Add(capability.MultiACK) + sr := &ServerResponse{req: &UploadPackRequest{UploadPackCommands: haves, UploadRequest: UploadRequest{Capabilities: capabilities}}} + b := bytes.NewBuffer(nil) + err := sr.Encode(b) + s.NoError(err) + + lines := strings.Split(b.String(), "\n") + s.Len(lines, 2) + s.Equal("0008NAK", lines[0]) + s.Equal("", lines[1]) +} + +func (s *ServerResponseSuite) TestEncodeMutiAckDetailed() { + haves := make(chan UploadPackCommand) + go func() { + haves <- UploadPackCommand{ + Acks: []UploadPackRequestAck{ + {Hash: plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e1")}, + {Hash: plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e2"), IsCommon: true, IsReady: true}, + {Hash: plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e3"), IsCommon: true}, + }, + } + haves <- UploadPackCommand{ + Acks: []UploadPackRequestAck{}, + Done: true, + } + close(haves) + }() + capabilities := capability.NewList() + capabilities.Add(capability.MultiACKDetailed) + sr := &ServerResponse{req: &UploadPackRequest{UploadPackCommands: haves, UploadRequest: UploadRequest{Capabilities: capabilities}}} + b := bytes.NewBuffer(nil) + err := sr.Encode(b) + s.NoError(err) - c.Assert(sr.ACKs, HasLen, 2) - c.Assert(sr.ACKs[0], Equals, plumbing.NewHash("1111111111111111111111111111111111111111")) - c.Assert(sr.ACKs[1], Equals, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) + lines := strings.Split(b.String(), "\n") + s.Len(lines, 5) + s.Equal("0037ACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e2 ready", lines[0]) + s.Equal("0038ACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e3 common", lines[1]) + s.Equal("0008NAK", lines[2]) + s.Equal("0031ACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e3", lines[3]) + s.Equal("", lines[4]) } diff --git a/plumbing/protocol/packp/ulreq.go b/plumbing/protocol/packp/ulreq.go index ef4e08a10..6d3e8d21a 100644 --- a/plumbing/protocol/packp/ulreq.go +++ b/plumbing/protocol/packp/ulreq.go @@ -4,8 +4,8 @@ import ( "fmt" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" ) // UploadRequest values represent the information transmitted on a @@ -18,6 +18,12 @@ type UploadRequest struct { Shallows []plumbing.Hash Depth Depth Filter Filter + HavesUR chan UploadRequestHave +} + +type UploadRequestHave struct { + Done bool + Haves []plumbing.Hash } // Depth values stores the desired depth of the requested packfile: see @@ -65,6 +71,7 @@ func NewUploadRequest() *UploadRequest { Wants: []plumbing.Hash{}, Shallows: []plumbing.Hash{}, Depth: DepthCommits(0), + HavesUR: make(chan UploadRequestHave, 1), } } diff --git a/plumbing/protocol/packp/ulreq_decode.go b/plumbing/protocol/packp/ulreq_decode.go index 3da29985e..4180dc775 100644 --- a/plumbing/protocol/packp/ulreq_decode.go +++ b/plumbing/protocol/packp/ulreq_decode.go @@ -8,28 +8,31 @@ import ( "strconv" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" ) // Decode reads the next upload-request form its input and // stores it in the UploadRequest. -func (req *UploadRequest) Decode(r io.Reader) error { +func (req *UploadPackRequest) Decode(r io.Reader) error { d := newUlReqDecoder(r) - return d.Decode(req) + if err := d.Decode(&req.UploadRequest); err != nil { + return err + } + return nil } type ulReqDecoder struct { - s *pktline.Scanner // a pkt-line scanner from the input stream - line []byte // current pkt-line contents, use parser.nextLine() to make it advance - nLine int // current pkt-line number for debugging, begins at 1 - err error // sticky error, use the parser.error() method to fill this out - data *UploadRequest // parsed data is stored here + r io.Reader // a pkt-line scanner from the input stream + line []byte // current pkt-line contents, use parser.nextLine() to make it advance + nLine int // current pkt-line number for debugging, begins at 1 + err error // sticky error, use the parser.error() method to fill this out + data *UploadRequest // parsed data is stored here } func newUlReqDecoder(r io.Reader) *ulReqDecoder { return &ulReqDecoder{ - s: pktline.NewScanner(r), + r: r, } } @@ -49,7 +52,6 @@ func (d *ulReqDecoder) error(format string, a ...interface{}) { "pkt-line %d: %s", d.nLine, fmt.Sprintf(format, a...), ) - d.err = NewErrUnexpectedData(msg, d.line) } @@ -57,19 +59,24 @@ func (d *ulReqDecoder) error(format string, a ...interface{}) { // p.line and increments p.nLine. A successful invocation returns true, // otherwise, false is returned and the sticky error is filled out // accordingly. Trims eols at the end of the payloads. -func (d *ulReqDecoder) nextLine() bool { +func (d *ulReqDecoder) nextLine(reportError bool) bool { d.nLine++ - if !d.s.Scan() { - if d.err = d.s.Err(); d.err != nil { - return false + _, p, err := pktline.ReadLine(d.r) + if err == io.EOF { + if reportError { + d.error("EOF") + } + return false + } + if err != nil { + if reportError { + d.err = err } - - d.error("EOF") return false } - d.line = d.s.Bytes() + d.line = p d.line = bytes.TrimSuffix(d.line, eol) return true @@ -77,7 +84,13 @@ func (d *ulReqDecoder) nextLine() bool { // Expected format: want [ capabilities] func (d *ulReqDecoder) decodeFirstWant() stateFn { - if ok := d.nextLine(); !ok { + if ok := d.nextLine(true); !ok { + return nil + } + + // if client send 0000 it don't want anything (already up to date after + // AdvertisedReferences) or ls-remote scenario + if len(d.line) == 0 { return nil } @@ -124,7 +137,7 @@ func (d *ulReqDecoder) decodeCaps() stateFn { // Expected format: want func (d *ulReqDecoder) decodeOtherWants() stateFn { - if ok := d.nextLine(); !ok { + if ok := d.nextLine(true); !ok { return nil } @@ -137,7 +150,7 @@ func (d *ulReqDecoder) decodeOtherWants() stateFn { } if len(d.line) == 0 { - return nil + return d.decodeHaves } if !bytes.HasPrefix(d.line, want) { @@ -162,7 +175,7 @@ func (d *ulReqDecoder) decodeShallow() stateFn { } if len(d.line) == 0 { - return nil + return d.decodeHaves } if !bytes.HasPrefix(d.line, shallow) { @@ -177,7 +190,7 @@ func (d *ulReqDecoder) decodeShallow() stateFn { } d.data.Shallows = append(d.data.Shallows, hash) - if ok := d.nextLine(); !ok { + if ok := d.nextLine(true); !ok { return nil } @@ -198,10 +211,6 @@ func (d *ulReqDecoder) decodeDeepen() stateFn { return d.decodeDeepenReference } - if len(d.line) == 0 { - return nil - } - d.error("unexpected deepen specification: %q", d.line) return nil } @@ -219,7 +228,7 @@ func (d *ulReqDecoder) decodeDeepenCommits() stateFn { } d.data.Depth = DepthCommits(n) - return d.decodeFlush + return d.decodeOtherWants } func (d *ulReqDecoder) decodeDeepenSince() stateFn { @@ -233,7 +242,7 @@ func (d *ulReqDecoder) decodeDeepenSince() stateFn { t := time.Unix(secs, 0).UTC() d.data.Depth = DepthSince(t) - return d.decodeFlush + return d.decodeOtherWants } func (d *ulReqDecoder) decodeDeepenReference() stateFn { @@ -241,17 +250,44 @@ func (d *ulReqDecoder) decodeDeepenReference() stateFn { d.data.Depth = DepthReference(string(d.line)) - return d.decodeFlush + return d.decodeOtherWants } -func (d *ulReqDecoder) decodeFlush() stateFn { - if ok := d.nextLine(); !ok { - return nil - } +func (d *ulReqDecoder) decodeHaves() stateFn { + go func() { + inBetweenHave := []plumbing.Hash{} + + for { + if ok := d.nextLine(false); !ok { + break + } + + if len(d.line) == 0 { + d.data.HavesUR <- UploadRequestHave{Haves: inBetweenHave, Done: false} + inBetweenHave = []plumbing.Hash{} + continue + } + + if bytes.Equal(d.line, done) { + d.data.HavesUR <- UploadRequestHave{Haves: inBetweenHave, Done: true} + break + } + + if !bytes.HasPrefix(d.line, have) { + d.error("unexpected payload while expecting a have: %q", d.line) + break + } + d.line = bytes.TrimPrefix(d.line, have) + + hash, ok := d.readHash() + if !ok { + break + } + inBetweenHave = append(inBetweenHave, hash) + } - if len(d.line) != 0 { - d.err = fmt.Errorf("unexpected payload while expecting a flush-pkt: %q", d.line) - } + close(d.data.HavesUR) + }() return nil } diff --git a/plumbing/protocol/packp/ulreq_decode_test.go b/plumbing/protocol/packp/ulreq_decode_test.go index 7658922de..fa3432f8e 100644 --- a/plumbing/protocol/packp/ulreq_decode_test.go +++ b/plumbing/protocol/packp/ulreq_decode_test.go @@ -2,106 +2,126 @@ package packp import ( "bytes" + "fmt" "io" + "regexp" "sort" + "testing" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" - "github.com/go-git/go-git/v5/plumbing/hash" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing/hash" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/stretchr/testify/suite" ) -type UlReqDecodeSuite struct{} +type UlReqDecodeSuite struct { + suite.Suite +} -var _ = Suite(&UlReqDecodeSuite{}) +func TestUlReqDecodeSuite(t *testing.T) { + suite.Run(t, new(UlReqDecodeSuite)) +} -func (s *UlReqDecodeSuite) TestEmpty(c *C) { +func (s *UlReqDecodeSuite) TestEmpty() { ur := NewUploadRequest() var buf bytes.Buffer d := newUlReqDecoder(&buf) err := d.Decode(ur) - c.Assert(err, ErrorMatches, "pkt-line 1: EOF") + s.ErrorContains(err, "pkt-line 1: EOF") } -func (s *UlReqDecodeSuite) TestNoWant(c *C) { +func (s *UlReqDecodeSuite) TestNoWant() { payloads := []string{ "foobar", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*missing 'want '.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*missing 'want '.*") } -func (s *UlReqDecodeSuite) testDecoderErrorMatches(c *C, input io.Reader, pattern string) { +func (s *UlReqDecodeSuite) testDecoderErrorMatches(input io.Reader, pattern string) { ur := NewUploadRequest() d := newUlReqDecoder(input) err := d.Decode(ur) - c.Assert(err, ErrorMatches, pattern) + s.Regexp(regexp.MustCompile(pattern), err) } -func (s *UlReqDecodeSuite) TestInvalidFirstHash(c *C) { +func (s *UlReqDecodeSuite) TestInvalidFirstHash() { payloads := []string{ "want 6ecf0ef2c2dffb796alberto2219af86ec6584e5\n", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*invalid hash.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*invalid hash.*") } -func (s *UlReqDecodeSuite) TestWantOK(c *C) { +func (s *UlReqDecodeSuite) TestWantOK() { payloads := []string{ "want 1111111111111111111111111111111111111111", - pktline.FlushString, + "", } - ur := s.testDecodeOK(c, payloads) + ur, _ := s.testDecodeOK(payloads, 0) - c.Assert(ur.Wants, DeepEquals, []plumbing.Hash{ + s.Equal([]plumbing.Hash{ plumbing.NewHash("1111111111111111111111111111111111111111"), - }) + }, ur.Wants) } -func (s *UlReqDecodeSuite) testDecodeOK(c *C, payloads []string) *UploadRequest { +func (s *UlReqDecodeSuite) testDecodeOK(payloads []string, expectedHaveCalls int) (*UploadRequest, []plumbing.Hash) { var buf bytes.Buffer - e := pktline.NewEncoder(&buf) - err := e.EncodeString(payloads...) - c.Assert(err, IsNil) + for _, p := range payloads { + if p == "" { + s.NoError(pktline.WriteFlush(&buf)) + } else { + _, err := pktline.WriteString(&buf, p) + s.NoError(err) + } + } ur := NewUploadRequest() d := newUlReqDecoder(&buf) - err = d.Decode(ur) - c.Assert(err, IsNil) + s.Nil(d.Decode(ur)) - return ur + haves := []plumbing.Hash{} + nbCall := 0 + for h := range ur.HavesUR { + nbCall++ + haves = append(haves, h.Haves...) + } + + s.Equal(expectedHaveCalls, nbCall) + + return ur, haves } -func (s *UlReqDecodeSuite) TestWantWithCapabilities(c *C) { +func (s *UlReqDecodeSuite) TestWantWithCapabilities() { payloads := []string{ "want 1111111111111111111111111111111111111111 ofs-delta multi_ack", - pktline.FlushString, + "", } - ur := s.testDecodeOK(c, payloads) - c.Assert(ur.Wants, DeepEquals, []plumbing.Hash{ - plumbing.NewHash("1111111111111111111111111111111111111111")}) + ur, _ := s.testDecodeOK(payloads, 0) + s.Equal([]plumbing.Hash{ + plumbing.NewHash("1111111111111111111111111111111111111111"), + }, ur.Wants) - c.Assert(ur.Capabilities.Supports(capability.OFSDelta), Equals, true) - c.Assert(ur.Capabilities.Supports(capability.MultiACK), Equals, true) + s.True(ur.Capabilities.Supports(capability.OFSDelta)) + s.True(ur.Capabilities.Supports(capability.MultiACK)) } -func (s *UlReqDecodeSuite) TestManyWantsNoCapabilities(c *C) { +func (s *UlReqDecodeSuite) TestManyWantsNoCapabilities() { payloads := []string{ "want 3333333333333333333333333333333333333333", "want 4444444444444444444444444444444444444444", "want 1111111111111111111111111111111111111111", "want 2222222222222222222222222222222222222222", - pktline.FlushString, + "", } - ur := s.testDecodeOK(c, payloads) + ur, _ := s.testDecodeOK(payloads, 0) expected := []plumbing.Hash{ plumbing.NewHash("1111111111111111111111111111111111111111"), @@ -112,7 +132,7 @@ func (s *UlReqDecodeSuite) TestManyWantsNoCapabilities(c *C) { sort.Sort(byHash(ur.Wants)) sort.Sort(byHash(expected)) - c.Assert(ur.Wants, DeepEquals, expected) + s.Equal(expected, ur.Wants) } type byHash []plumbing.Hash @@ -125,39 +145,39 @@ func (a byHash) Less(i, j int) bool { return bytes.Compare(ii[:], jj[:]) < 0 } -func (s *UlReqDecodeSuite) TestManyWantsBadWant(c *C) { +func (s *UlReqDecodeSuite) TestManyWantsBadWant() { payloads := []string{ "want 3333333333333333333333333333333333333333", "want 4444444444444444444444444444444444444444", "foo", "want 2222222222222222222222222222222222222222", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*unexpected payload.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*unexpected payload.*") } -func (s *UlReqDecodeSuite) TestManyWantsInvalidHash(c *C) { +func (s *UlReqDecodeSuite) TestManyWantsInvalidHash() { payloads := []string{ "want 3333333333333333333333333333333333333333", "want 4444444444444444444444444444444444444444", "want 1234567890abcdef", "want 2222222222222222222222222222222222222222", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*malformed hash.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*malformed hash.*") } -func (s *UlReqDecodeSuite) TestManyWantsWithCapabilities(c *C) { +func (s *UlReqDecodeSuite) TestManyWantsWithCapabilities() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "want 4444444444444444444444444444444444444444", "want 1111111111111111111111111111111111111111", "want 2222222222222222222222222222222222222222", - pktline.FlushString, + "", } - ur := s.testDecodeOK(c, payloads) + ur, _ := s.testDecodeOK(payloads, 0) expected := []plumbing.Hash{ plumbing.NewHash("1111111111111111111111111111111111111111"), @@ -168,19 +188,19 @@ func (s *UlReqDecodeSuite) TestManyWantsWithCapabilities(c *C) { sort.Sort(byHash(ur.Wants)) sort.Sort(byHash(expected)) - c.Assert(ur.Wants, DeepEquals, expected) + s.Equal(expected, ur.Wants) - c.Assert(ur.Capabilities.Supports(capability.OFSDelta), Equals, true) - c.Assert(ur.Capabilities.Supports(capability.MultiACK), Equals, true) + s.True(ur.Capabilities.Supports(capability.OFSDelta)) + s.True(ur.Capabilities.Supports(capability.MultiACK)) } -func (s *UlReqDecodeSuite) TestSingleShallowSingleWant(c *C) { +func (s *UlReqDecodeSuite) TestSingleShallowSingleWant() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", - pktline.FlushString, + "", } - ur := s.testDecodeOK(c, payloads) + ur, _ := s.testDecodeOK(payloads, 0) expectedWants := []plumbing.Hash{ plumbing.NewHash("3333333333333333333333333333333333333333"), @@ -190,23 +210,23 @@ func (s *UlReqDecodeSuite) TestSingleShallowSingleWant(c *C) { plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), } - c.Assert(ur.Wants, DeepEquals, expectedWants) - c.Assert(ur.Capabilities.Supports(capability.OFSDelta), Equals, true) - c.Assert(ur.Capabilities.Supports(capability.MultiACK), Equals, true) + s.Equal(expectedWants, ur.Wants) + s.True(ur.Capabilities.Supports(capability.OFSDelta)) + s.True(ur.Capabilities.Supports(capability.MultiACK)) - c.Assert(ur.Shallows, DeepEquals, expectedShallows) + s.Equal(expectedShallows, ur.Shallows) } -func (s *UlReqDecodeSuite) TestSingleShallowManyWants(c *C) { +func (s *UlReqDecodeSuite) TestSingleShallowManyWants() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "want 4444444444444444444444444444444444444444", "want 1111111111111111111111111111111111111111", "want 2222222222222222222222222222222222222222", "shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", - pktline.FlushString, + "", } - ur := s.testDecodeOK(c, payloads) + ur, _ := s.testDecodeOK(payloads, 0) expectedWants := []plumbing.Hash{ plumbing.NewHash("1111111111111111111111111111111111111111"), @@ -221,23 +241,23 @@ func (s *UlReqDecodeSuite) TestSingleShallowManyWants(c *C) { } sort.Sort(byHash(ur.Wants)) - c.Assert(ur.Wants, DeepEquals, expectedWants) - c.Assert(ur.Capabilities.Supports(capability.OFSDelta), Equals, true) - c.Assert(ur.Capabilities.Supports(capability.MultiACK), Equals, true) + s.Equal(expectedWants, ur.Wants) + s.True(ur.Capabilities.Supports(capability.OFSDelta)) + s.True(ur.Capabilities.Supports(capability.MultiACK)) - c.Assert(ur.Shallows, DeepEquals, expectedShallows) + s.Equal(expectedShallows, ur.Shallows) } -func (s *UlReqDecodeSuite) TestManyShallowSingleWant(c *C) { +func (s *UlReqDecodeSuite) TestManyShallowSingleWant() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "shallow cccccccccccccccccccccccccccccccccccccccc", "shallow dddddddddddddddddddddddddddddddddddddddd", - pktline.FlushString, + "", } - ur := s.testDecodeOK(c, payloads) + ur, _ := s.testDecodeOK(payloads, 0) expectedWants := []plumbing.Hash{ plumbing.NewHash("3333333333333333333333333333333333333333"), @@ -251,15 +271,15 @@ func (s *UlReqDecodeSuite) TestManyShallowSingleWant(c *C) { } sort.Sort(byHash(expectedShallows)) - c.Assert(ur.Wants, DeepEquals, expectedWants) - c.Assert(ur.Capabilities.Supports(capability.OFSDelta), Equals, true) - c.Assert(ur.Capabilities.Supports(capability.MultiACK), Equals, true) + s.Equal(expectedWants, ur.Wants) + s.True(ur.Capabilities.Supports(capability.OFSDelta)) + s.True(ur.Capabilities.Supports(capability.MultiACK)) sort.Sort(byHash(ur.Shallows)) - c.Assert(ur.Shallows, DeepEquals, expectedShallows) + s.Equal(expectedShallows, ur.Shallows) } -func (s *UlReqDecodeSuite) TestManyShallowManyWants(c *C) { +func (s *UlReqDecodeSuite) TestManyShallowManyWants() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "want 4444444444444444444444444444444444444444", @@ -269,9 +289,9 @@ func (s *UlReqDecodeSuite) TestManyShallowManyWants(c *C) { "shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "shallow cccccccccccccccccccccccccccccccccccccccc", "shallow dddddddddddddddddddddddddddddddddddddddd", - pktline.FlushString, + "", } - ur := s.testDecodeOK(c, payloads) + ur, _ := s.testDecodeOK(payloads, 0) expectedWants := []plumbing.Hash{ plumbing.NewHash("1111111111111111111111111111111111111111"), @@ -290,195 +310,195 @@ func (s *UlReqDecodeSuite) TestManyShallowManyWants(c *C) { sort.Sort(byHash(expectedShallows)) sort.Sort(byHash(ur.Wants)) - c.Assert(ur.Wants, DeepEquals, expectedWants) - c.Assert(ur.Capabilities.Supports(capability.OFSDelta), Equals, true) - c.Assert(ur.Capabilities.Supports(capability.MultiACK), Equals, true) + s.Equal(expectedWants, ur.Wants) + s.True(ur.Capabilities.Supports(capability.OFSDelta)) + s.True(ur.Capabilities.Supports(capability.MultiACK)) sort.Sort(byHash(ur.Shallows)) - c.Assert(ur.Shallows, DeepEquals, expectedShallows) + s.Equal(expectedShallows, ur.Shallows) } -func (s *UlReqDecodeSuite) TestMalformedShallow(c *C) { +func (s *UlReqDecodeSuite) TestMalformedShallow() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "shalow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*unexpected payload.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*unexpected payload.*") } -func (s *UlReqDecodeSuite) TestMalformedShallowHash(c *C) { +func (s *UlReqDecodeSuite) TestMalformedShallowHash() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*malformed hash.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*malformed hash.*") } -func (s *UlReqDecodeSuite) TestMalformedShallowManyShallows(c *C) { +func (s *UlReqDecodeSuite) TestMalformedShallowManyShallows() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "shalow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "shallow cccccccccccccccccccccccccccccccccccccccc", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*unexpected payload.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*unexpected payload.*") } -func (s *UlReqDecodeSuite) TestMalformedDeepenSpec(c *C) { +func (s *UlReqDecodeSuite) TestMalformedDeepenSpec() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "deepen-foo 34", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*unexpected deepen.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*unexpected deepen.*") } -func (s *UlReqDecodeSuite) TestMalformedDeepenSingleWant(c *C) { +func (s *UlReqDecodeSuite) TestMalformedDeepenSingleWant() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "depth 32", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*unexpected payload.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*unexpected payload.*") } -func (s *UlReqDecodeSuite) TestMalformedDeepenMultiWant(c *C) { +func (s *UlReqDecodeSuite) TestMalformedDeepenMultiWant() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "want 2222222222222222222222222222222222222222", "depth 32", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*unexpected payload.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*unexpected payload.*") } -func (s *UlReqDecodeSuite) TestMalformedDeepenWithSingleShallow(c *C) { +func (s *UlReqDecodeSuite) TestMalformedDeepenWithSingleShallow() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "shallow 2222222222222222222222222222222222222222", "depth 32", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*unexpected payload.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*unexpected payload.*") } -func (s *UlReqDecodeSuite) TestMalformedDeepenWithMultiShallow(c *C) { +func (s *UlReqDecodeSuite) TestMalformedDeepenWithMultiShallow() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "shallow 2222222222222222222222222222222222222222", "shallow 5555555555555555555555555555555555555555", "depth 32", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*unexpected payload.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*unexpected payload.*") } -func (s *UlReqDecodeSuite) TestDeepenCommits(c *C) { +func (s *UlReqDecodeSuite) TestDeepenCommits() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "deepen 1234", - pktline.FlushString, + "", } - ur := s.testDecodeOK(c, payloads) + ur, _ := s.testDecodeOK(payloads, 0) - c.Assert(ur.Depth, FitsTypeOf, DepthCommits(0)) + s.IsType(DepthCommits(0), ur.Depth) commits, ok := ur.Depth.(DepthCommits) - c.Assert(ok, Equals, true) - c.Assert(int(commits), Equals, 1234) + s.True(ok) + s.Equal(1234, int(commits)) } -func (s *UlReqDecodeSuite) TestDeepenCommitsInfiniteImplicit(c *C) { +func (s *UlReqDecodeSuite) TestDeepenCommitsInfiniteImplicit() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "deepen 0", - pktline.FlushString, + "", } - ur := s.testDecodeOK(c, payloads) + ur, _ := s.testDecodeOK(payloads, 0) - c.Assert(ur.Depth, FitsTypeOf, DepthCommits(0)) + s.IsType(DepthCommits(0), ur.Depth) commits, ok := ur.Depth.(DepthCommits) - c.Assert(ok, Equals, true) - c.Assert(int(commits), Equals, 0) + s.True(ok) + s.Equal(0, int(commits)) } -func (s *UlReqDecodeSuite) TestDeepenCommitsInfiniteExplicit(c *C) { +func (s *UlReqDecodeSuite) TestDeepenCommitsInfiniteExplicit() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", - pktline.FlushString, + "", } - ur := s.testDecodeOK(c, payloads) + ur, _ := s.testDecodeOK(payloads, 0) - c.Assert(ur.Depth, FitsTypeOf, DepthCommits(0)) + s.IsType(DepthCommits(0), ur.Depth) commits, ok := ur.Depth.(DepthCommits) - c.Assert(ok, Equals, true) - c.Assert(int(commits), Equals, 0) + s.True(ok) + s.Equal(0, int(commits)) } -func (s *UlReqDecodeSuite) TestMalformedDeepenCommits(c *C) { +func (s *UlReqDecodeSuite) TestMalformedDeepenCommits() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "deepen -32", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*negative depth.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*negative depth.*") } -func (s *UlReqDecodeSuite) TestDeepenCommitsEmpty(c *C) { +func (s *UlReqDecodeSuite) TestDeepenCommitsEmpty() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "deepen ", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*invalid syntax.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*invalid syntax.*") } -func (s *UlReqDecodeSuite) TestDeepenSince(c *C) { +func (s *UlReqDecodeSuite) TestDeepenSince() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "deepen-since 1420167845", // 2015-01-02T03:04:05+00:00 - pktline.FlushString, + "", } - ur := s.testDecodeOK(c, payloads) + ur, _ := s.testDecodeOK(payloads, 0) expected := time.Date(2015, time.January, 2, 3, 4, 5, 0, time.UTC) - c.Assert(ur.Depth, FitsTypeOf, DepthSince(time.Now())) + s.IsType(DepthSince(time.Now()), ur.Depth) since, ok := ur.Depth.(DepthSince) - c.Assert(ok, Equals, true) - c.Assert(time.Time(since).Equal(expected), Equals, true, - Commentf("obtained=%s\nexpected=%s", time.Time(since), expected)) + s.True(ok) + s.True(time.Time(since).Equal(expected), + fmt.Sprintf("obtained=%s\nexpected=%s", time.Time(since), expected)) } -func (s *UlReqDecodeSuite) TestDeepenReference(c *C) { +func (s *UlReqDecodeSuite) TestDeepenReference() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "deepen-not refs/heads/master", - pktline.FlushString, + "", } - ur := s.testDecodeOK(c, payloads) + ur, _ := s.testDecodeOK(payloads, 0) expected := "refs/heads/master" - c.Assert(ur.Depth, FitsTypeOf, DepthReference("")) + s.IsType(DepthReference(""), ur.Depth) reference, ok := ur.Depth.(DepthReference) - c.Assert(ok, Equals, true) - c.Assert(string(reference), Equals, expected) + s.True(ok) + s.Equal(expected, string(reference)) } -func (s *UlReqDecodeSuite) TestAll(c *C) { +func (s *UlReqDecodeSuite) TestAll() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "want 4444444444444444444444444444444444444444", @@ -489,9 +509,13 @@ func (s *UlReqDecodeSuite) TestAll(c *C) { "shallow cccccccccccccccccccccccccccccccccccccccc", "shallow dddddddddddddddddddddddddddddddddddddddd", "deepen 1234", - pktline.FlushString, + "", + "have 5555555555555555555555555555555555555555", + "", + "have 6666666666666666666666666666666666666666", + "done", } - ur := s.testDecodeOK(c, payloads) + ur, haves := s.testDecodeOK(payloads, 2) expectedWants := []plumbing.Hash{ plumbing.NewHash("1111111111111111111111111111111111111111"), @@ -499,11 +523,18 @@ func (s *UlReqDecodeSuite) TestAll(c *C) { plumbing.NewHash("3333333333333333333333333333333333333333"), plumbing.NewHash("4444444444444444444444444444444444444444"), } + expectedHave := []plumbing.Hash{ + plumbing.NewHash("5555555555555555555555555555555555555555"), + plumbing.NewHash("6666666666666666666666666666666666666666"), + } + sort.Sort(byHash(expectedHave)) + sort.Sort(byHash(haves)) + s.Equal(expectedHave, haves) + s.True(ur.Capabilities.Supports(capability.OFSDelta)) + s.True(ur.Capabilities.Supports(capability.MultiACK)) sort.Sort(byHash(expectedWants)) sort.Sort(byHash(ur.Wants)) - c.Assert(ur.Wants, DeepEquals, expectedWants) - c.Assert(ur.Capabilities.Supports(capability.OFSDelta), Equals, true) - c.Assert(ur.Capabilities.Supports(capability.MultiACK), Equals, true) + s.Equal(expectedWants, ur.Wants) expectedShallows := []plumbing.Hash{ plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), @@ -513,21 +544,21 @@ func (s *UlReqDecodeSuite) TestAll(c *C) { } sort.Sort(byHash(expectedShallows)) sort.Sort(byHash(ur.Shallows)) - c.Assert(ur.Shallows, DeepEquals, expectedShallows) + s.Equal(expectedShallows, ur.Shallows) - c.Assert(ur.Depth, FitsTypeOf, DepthCommits(0)) + s.IsType(DepthCommits(0), ur.Depth) commits, ok := ur.Depth.(DepthCommits) - c.Assert(ok, Equals, true) - c.Assert(int(commits), Equals, 1234) + s.True(ok) + s.Equal(1234, int(commits)) } -func (s *UlReqDecodeSuite) TestExtraData(c *C) { +func (s *UlReqDecodeSuite) TestExtraData() { payloads := []string{ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack", "deepen 32", "foo", - pktline.FlushString, + "", } - r := toPktLines(c, payloads) - s.testDecoderErrorMatches(c, r, ".*unexpected payload.*") + r := toPktLines(s.T(), payloads) + s.testDecoderErrorMatches(r, ".*unexpected payload.*") } diff --git a/plumbing/protocol/packp/ulreq_encode.go b/plumbing/protocol/packp/ulreq_encode.go index 8b19c0f67..ef95d39a4 100644 --- a/plumbing/protocol/packp/ulreq_encode.go +++ b/plumbing/protocol/packp/ulreq_encode.go @@ -6,8 +6,8 @@ import ( "io" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" ) // Encode writes the UlReq encoding of u to the stream. @@ -21,14 +21,14 @@ func (req *UploadRequest) Encode(w io.Writer) error { } type ulReqEncoder struct { - pe *pktline.Encoder // where to write the encoded data - data *UploadRequest // the data to encode - err error // sticky error + w io.Writer // where to write the encoded data + data *UploadRequest // the data to encode + err error // sticky error } func newUlReqEncoder(w io.Writer) *ulReqEncoder { return &ulReqEncoder{ - pe: pktline.NewEncoder(w), + w: w, } } @@ -50,10 +50,9 @@ func (e *ulReqEncoder) Encode(v *UploadRequest) error { func (e *ulReqEncoder) encodeFirstWant() stateFn { var err error if e.data.Capabilities.IsEmpty() { - err = e.pe.Encodef("want %s\n", e.data.Wants[0]) + _, err = pktline.Writef(e.w, "want %s\n", e.data.Wants[0]) } else { - err = e.pe.Encodef( - "want %s %s\n", + _, err = pktline.Writef(e.w, "want %s %s\n", e.data.Wants[0], e.data.Capabilities.String(), ) @@ -74,7 +73,7 @@ func (e *ulReqEncoder) encodeAdditionalWants() stateFn { continue } - if err := e.pe.Encodef("want %s\n", w); err != nil { + if _, err := pktline.Writef(e.w, "want %s\n", w); err != nil { e.err = fmt.Errorf("encoding want %q: %s", w, err) return nil } @@ -94,7 +93,7 @@ func (e *ulReqEncoder) encodeShallows() stateFn { continue } - if err := e.pe.Encodef("shallow %s\n", s); err != nil { + if _, err := pktline.Writef(e.w, "shallow %s\n", s); err != nil { e.err = fmt.Errorf("encoding shallow %q: %s", s, err) return nil } @@ -110,20 +109,20 @@ func (e *ulReqEncoder) encodeDepth() stateFn { case DepthCommits: if depth != 0 { commits := int(depth) - if err := e.pe.Encodef("deepen %d\n", commits); err != nil { + if _, err := pktline.Writef(e.w, "deepen %d\n", commits); err != nil { e.err = fmt.Errorf("encoding depth %d: %s", depth, err) return nil } } case DepthSince: when := time.Time(depth).UTC() - if err := e.pe.Encodef("deepen-since %d\n", when.Unix()); err != nil { + if _, err := pktline.Writef(e.w, "deepen-since %d\n", when.Unix()); err != nil { e.err = fmt.Errorf("encoding depth %s: %s", when, err) return nil } case DepthReference: reference := string(depth) - if err := e.pe.Encodef("deepen-not %s\n", reference); err != nil { + if _, err := pktline.Writef(e.w, "deepen-not %s\n", reference); err != nil { e.err = fmt.Errorf("encoding depth %s: %s", reference, err) return nil } @@ -137,7 +136,7 @@ func (e *ulReqEncoder) encodeDepth() stateFn { func (e *ulReqEncoder) encodeFilter() stateFn { if filter := e.data.Filter; filter != "" { - if err := e.pe.Encodef("filter %s\n", filter); err != nil { + if _, err := pktline.Writef(e.w, "filter %s\n", filter); err != nil { e.err = fmt.Errorf("encoding filter %s: %s", filter, err) return nil } @@ -147,7 +146,7 @@ func (e *ulReqEncoder) encodeFilter() stateFn { } func (e *ulReqEncoder) encodeFlush() stateFn { - if err := e.pe.Flush(); err != nil { + if err := pktline.WriteFlush(e.w); err != nil { e.err = fmt.Errorf("encoding flush-pkt: %s", err) return nil } diff --git a/plumbing/protocol/packp/ulreq_encode_test.go b/plumbing/protocol/packp/ulreq_encode_test.go index 247de2767..90baa86e1 100644 --- a/plumbing/protocol/packp/ulreq_encode_test.go +++ b/plumbing/protocol/packp/ulreq_encode_test.go @@ -2,63 +2,68 @@ package packp import ( "bytes" + "fmt" + "regexp" "runtime" + "testing" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/stretchr/testify/suite" ) -type UlReqEncodeSuite struct{} +type UlReqEncodeSuite struct { + suite.Suite +} -var _ = Suite(&UlReqEncodeSuite{}) +func TestUlReqEncodeSuite(t *testing.T) { + suite.Run(t, new(UlReqEncodeSuite)) +} -func testUlReqEncode(c *C, ur *UploadRequest, expectedPayloads []string) { +func testUlReqEncode(s *UlReqEncodeSuite, ur *UploadRequest, expectedPayloads []string) { var buf bytes.Buffer e := newUlReqEncoder(&buf) err := e.Encode(ur) - c.Assert(err, IsNil) + s.NoError(err) obtained := buf.Bytes() - expected := pktlines(c, expectedPayloads...) + expected := pktlines(s.T(), expectedPayloads...) - comment := Commentf("\nobtained = %s\nexpected = %s\n", string(obtained), string(expected)) + comment := fmt.Sprintf("\nobtained = %s\nexpected = %s\n", string(obtained), string(expected)) - c.Assert(obtained, DeepEquals, expected, comment) + s.Equal(expected, obtained, comment) } -func testUlReqEncodeError(c *C, ur *UploadRequest, expectedErrorRegEx string) { +func testUlReqEncodeError(s *UlReqEncodeSuite, ur *UploadRequest, expectedErrorRegEx string) { var buf bytes.Buffer e := newUlReqEncoder(&buf) err := e.Encode(ur) - c.Assert(err, ErrorMatches, expectedErrorRegEx) + s.Regexp(regexp.MustCompile(expectedErrorRegEx), err) } -func (s *UlReqEncodeSuite) TestZeroValue(c *C) { +func (s *UlReqEncodeSuite) TestZeroValue() { ur := NewUploadRequest() expectedErrorRegEx := ".*empty wants.*" - testUlReqEncodeError(c, ur, expectedErrorRegEx) + testUlReqEncodeError(s, ur, expectedErrorRegEx) } -func (s *UlReqEncodeSuite) TestOneWant(c *C) { +func (s *UlReqEncodeSuite) TestOneWant() { ur := NewUploadRequest() ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) expected := []string{ "want 1111111111111111111111111111111111111111\n", - pktline.FlushString, + "", } - testUlReqEncode(c, ur, expected) + testUlReqEncode(s, ur, expected) } -func (s *UlReqEncodeSuite) TestOneWantWithCapabilities(c *C) { +func (s *UlReqEncodeSuite) TestOneWantWithCapabilities() { ur := NewUploadRequest() ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) ur.Capabilities.Add(capability.MultiACK) @@ -69,13 +74,13 @@ func (s *UlReqEncodeSuite) TestOneWantWithCapabilities(c *C) { expected := []string{ "want 1111111111111111111111111111111111111111 multi_ack ofs-delta side-band symref=HEAD:/refs/heads/master thin-pack\n", - pktline.FlushString, + "", } - testUlReqEncode(c, ur, expected) + testUlReqEncode(s, ur, expected) } -func (s *UlReqEncodeSuite) TestWants(c *C) { +func (s *UlReqEncodeSuite) TestWants() { ur := NewUploadRequest() ur.Wants = append(ur.Wants, plumbing.NewHash("4444444444444444444444444444444444444444"), @@ -91,13 +96,13 @@ func (s *UlReqEncodeSuite) TestWants(c *C) { "want 3333333333333333333333333333333333333333\n", "want 4444444444444444444444444444444444444444\n", "want 5555555555555555555555555555555555555555\n", - pktline.FlushString, + "", } - testUlReqEncode(c, ur, expected) + testUlReqEncode(s, ur, expected) } -func (s *UlReqEncodeSuite) TestWantsDuplicates(c *C) { +func (s *UlReqEncodeSuite) TestWantsDuplicates() { ur := NewUploadRequest() ur.Wants = append(ur.Wants, plumbing.NewHash("4444444444444444444444444444444444444444"), @@ -113,13 +118,13 @@ func (s *UlReqEncodeSuite) TestWantsDuplicates(c *C) { "want 2222222222222222222222222222222222222222\n", "want 3333333333333333333333333333333333333333\n", "want 4444444444444444444444444444444444444444\n", - pktline.FlushString, + "", } - testUlReqEncode(c, ur, expected) + testUlReqEncode(s, ur, expected) } -func (s *UlReqEncodeSuite) TestWantsWithCapabilities(c *C) { +func (s *UlReqEncodeSuite) TestWantsWithCapabilities() { ur := NewUploadRequest() ur.Wants = append(ur.Wants, plumbing.NewHash("4444444444444444444444444444444444444444"), @@ -141,13 +146,13 @@ func (s *UlReqEncodeSuite) TestWantsWithCapabilities(c *C) { "want 3333333333333333333333333333333333333333\n", "want 4444444444444444444444444444444444444444\n", "want 5555555555555555555555555555555555555555\n", - pktline.FlushString, + "", } - testUlReqEncode(c, ur, expected) + testUlReqEncode(s, ur, expected) } -func (s *UlReqEncodeSuite) TestShallow(c *C) { +func (s *UlReqEncodeSuite) TestShallow() { ur := NewUploadRequest() ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) ur.Capabilities.Add(capability.MultiACK) @@ -156,13 +161,13 @@ func (s *UlReqEncodeSuite) TestShallow(c *C) { expected := []string{ "want 1111111111111111111111111111111111111111 multi_ack\n", "shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n", - pktline.FlushString, + "", } - testUlReqEncode(c, ur, expected) + testUlReqEncode(s, ur, expected) } -func (s *UlReqEncodeSuite) TestManyShallows(c *C) { +func (s *UlReqEncodeSuite) TestManyShallows() { ur := NewUploadRequest() ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) ur.Capabilities.Add(capability.MultiACK) @@ -179,13 +184,13 @@ func (s *UlReqEncodeSuite) TestManyShallows(c *C) { "shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n", "shallow cccccccccccccccccccccccccccccccccccccccc\n", "shallow dddddddddddddddddddddddddddddddddddddddd\n", - pktline.FlushString, + "", } - testUlReqEncode(c, ur, expected) + testUlReqEncode(s, ur, expected) } -func (s *UlReqEncodeSuite) TestShallowsDuplicate(c *C) { +func (s *UlReqEncodeSuite) TestShallowsDuplicate() { ur := NewUploadRequest() ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) ur.Capabilities.Add(capability.MultiACK) @@ -201,13 +206,13 @@ func (s *UlReqEncodeSuite) TestShallowsDuplicate(c *C) { "shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n", "shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n", "shallow cccccccccccccccccccccccccccccccccccccccc\n", - pktline.FlushString, + "", } - testUlReqEncode(c, ur, expected) + testUlReqEncode(s, ur, expected) } -func (s *UlReqEncodeSuite) TestDepthCommits(c *C) { +func (s *UlReqEncodeSuite) TestDepthCommits() { ur := NewUploadRequest() ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) ur.Depth = DepthCommits(1234) @@ -215,13 +220,13 @@ func (s *UlReqEncodeSuite) TestDepthCommits(c *C) { expected := []string{ "want 1111111111111111111111111111111111111111\n", "deepen 1234\n", - pktline.FlushString, + "", } - testUlReqEncode(c, ur, expected) + testUlReqEncode(s, ur, expected) } -func (s *UlReqEncodeSuite) TestDepthSinceUTC(c *C) { +func (s *UlReqEncodeSuite) TestDepthSinceUTC() { ur := NewUploadRequest() ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) since := time.Date(2015, time.January, 2, 3, 4, 5, 0, time.UTC) @@ -230,21 +235,21 @@ func (s *UlReqEncodeSuite) TestDepthSinceUTC(c *C) { expected := []string{ "want 1111111111111111111111111111111111111111\n", "deepen-since 1420167845\n", - pktline.FlushString, + "", } - testUlReqEncode(c, ur, expected) + testUlReqEncode(s, ur, expected) } -func (s *UlReqEncodeSuite) TestDepthSinceNonUTC(c *C) { +func (s *UlReqEncodeSuite) TestDepthSinceNonUTC() { if runtime.GOOS == "js" { - c.Skip("time.LoadLocation not supported in wasm") + s.T().Skip("time.LoadLocation not supported in wasm") } ur := NewUploadRequest() ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) berlin, err := time.LoadLocation("Europe/Berlin") - c.Assert(err, IsNil) + s.NoError(err) since := time.Date(2015, time.January, 2, 3, 4, 5, 0, berlin) // since value is 2015-01-02 03:04:05 +0100 UTC (Europe/Berlin) or // 2015-01-02 02:04:05 +0000 UTC, which is 1420164245 Unix seconds. @@ -253,13 +258,13 @@ func (s *UlReqEncodeSuite) TestDepthSinceNonUTC(c *C) { expected := []string{ "want 1111111111111111111111111111111111111111\n", "deepen-since 1420164245\n", - pktline.FlushString, + "", } - testUlReqEncode(c, ur, expected) + testUlReqEncode(s, ur, expected) } -func (s *UlReqEncodeSuite) TestDepthReference(c *C) { +func (s *UlReqEncodeSuite) TestDepthReference() { ur := NewUploadRequest() ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) ur.Depth = DepthReference("refs/heads/feature-foo") @@ -267,13 +272,13 @@ func (s *UlReqEncodeSuite) TestDepthReference(c *C) { expected := []string{ "want 1111111111111111111111111111111111111111\n", "deepen-not refs/heads/feature-foo\n", - pktline.FlushString, + "", } - testUlReqEncode(c, ur, expected) + testUlReqEncode(s, ur, expected) } -func (s *UlReqEncodeSuite) TestFilter(c *C) { +func (s *UlReqEncodeSuite) TestFilter() { ur := NewUploadRequest() ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) ur.Filter = FilterTreeDepth(0) @@ -281,13 +286,13 @@ func (s *UlReqEncodeSuite) TestFilter(c *C) { expected := []string{ "want 1111111111111111111111111111111111111111\n", "filter tree:0\n", - pktline.FlushString, + "", } - testUlReqEncode(c, ur, expected) + testUlReqEncode(s, ur, expected) } -func (s *UlReqEncodeSuite) TestAll(c *C) { +func (s *UlReqEncodeSuite) TestAll() { ur := NewUploadRequest() ur.Wants = append(ur.Wants, plumbing.NewHash("4444444444444444444444444444444444444444"), @@ -322,8 +327,8 @@ func (s *UlReqEncodeSuite) TestAll(c *C) { "shallow cccccccccccccccccccccccccccccccccccccccc\n", "shallow dddddddddddddddddddddddddddddddddddddddd\n", "deepen-since 1420167845\n", - pktline.FlushString, + "", } - testUlReqEncode(c, ur, expected) + testUlReqEncode(s, ur, expected) } diff --git a/plumbing/protocol/packp/ulreq_test.go b/plumbing/protocol/packp/ulreq_test.go index 2797a4ea5..df32aacfe 100644 --- a/plumbing/protocol/packp/ulreq_test.go +++ b/plumbing/protocol/packp/ulreq_test.go @@ -1,19 +1,23 @@ package packp import ( + "testing" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/stretchr/testify/suite" ) -type UlReqSuite struct{} +type UlReqSuite struct { + suite.Suite +} -var _ = Suite(&UlReqSuite{}) +func TestUlReqSuite(t *testing.T) { + suite.Run(t, new(UlReqSuite)) +} -func (s *UlReqSuite) TestNewUploadRequestFromCapabilities(c *C) { +func (s *UlReqSuite) TestNewUploadRequestFromCapabilities() { cap := capability.NewList() cap.Set(capability.Sideband) cap.Set(capability.Sideband64k) @@ -24,86 +28,86 @@ func (s *UlReqSuite) TestNewUploadRequestFromCapabilities(c *C) { cap.Set(capability.Agent, "foo") r := NewUploadRequestFromCapabilities(cap) - c.Assert(r.Capabilities.String(), Equals, - "multi_ack_detailed side-band-64k thin-pack ofs-delta agent=go-git/5.x", + s.Equal("multi_ack_detailed side-band-64k thin-pack ofs-delta agent=go-git/5.x", + r.Capabilities.String(), ) } -func (s *UlReqSuite) TestValidateWants(c *C) { +func (s *UlReqSuite) TestValidateWants() { r := NewUploadRequest() err := r.Validate() - c.Assert(err, NotNil) + s.NotNil(err) r.Wants = append(r.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) err = r.Validate() - c.Assert(err, IsNil) + s.NoError(err) } -func (s *UlReqSuite) TestValidateShallows(c *C) { +func (s *UlReqSuite) TestValidateShallows() { r := NewUploadRequest() r.Wants = append(r.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) r.Shallows = append(r.Shallows, plumbing.NewHash("2222222222222222222222222222222222222222")) err := r.Validate() - c.Assert(err, NotNil) + s.NotNil(err) r.Capabilities.Set(capability.Shallow) err = r.Validate() - c.Assert(err, IsNil) + s.NoError(err) } -func (s *UlReqSuite) TestValidateDepthCommits(c *C) { +func (s *UlReqSuite) TestValidateDepthCommits() { r := NewUploadRequest() r.Wants = append(r.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) r.Depth = DepthCommits(42) err := r.Validate() - c.Assert(err, NotNil) + s.NotNil(err) r.Capabilities.Set(capability.Shallow) err = r.Validate() - c.Assert(err, IsNil) + s.NoError(err) } -func (s *UlReqSuite) TestValidateDepthReference(c *C) { +func (s *UlReqSuite) TestValidateDepthReference() { r := NewUploadRequest() r.Wants = append(r.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) r.Depth = DepthReference("1111111111111111111111111111111111111111") err := r.Validate() - c.Assert(err, NotNil) + s.NotNil(err) r.Capabilities.Set(capability.DeepenNot) err = r.Validate() - c.Assert(err, IsNil) + s.NoError(err) } -func (s *UlReqSuite) TestValidateDepthSince(c *C) { +func (s *UlReqSuite) TestValidateDepthSince() { r := NewUploadRequest() r.Wants = append(r.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) r.Depth = DepthSince(time.Now()) err := r.Validate() - c.Assert(err, NotNil) + s.NotNil(err) r.Capabilities.Set(capability.DeepenSince) err = r.Validate() - c.Assert(err, IsNil) + s.NoError(err) } -func (s *UlReqSuite) TestValidateConflictSideband(c *C) { +func (s *UlReqSuite) TestValidateConflictSideband() { r := NewUploadRequest() r.Wants = append(r.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) r.Capabilities.Set(capability.Sideband) r.Capabilities.Set(capability.Sideband64k) err := r.Validate() - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *UlReqSuite) TestValidateConflictMultiACK(c *C) { +func (s *UlReqSuite) TestValidateConflictMultiACK() { r := NewUploadRequest() r.Wants = append(r.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) r.Capabilities.Set(capability.MultiACK) r.Capabilities.Set(capability.MultiACKDetailed) err := r.Validate() - c.Assert(err, NotNil) + s.NotNil(err) } diff --git a/plumbing/protocol/packp/updreq.go b/plumbing/protocol/packp/updreq.go index 8f39b39cb..f77bfc7a9 100644 --- a/plumbing/protocol/packp/updreq.go +++ b/plumbing/protocol/packp/updreq.go @@ -4,9 +4,9 @@ import ( "errors" "io" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/sideband" ) var ( @@ -16,6 +16,9 @@ var ( // ReferenceUpdateRequest values represent reference upload requests. // Values from this type are not zero-value safe, use the New function instead. +// TODO: remove the Packfile and Progress fields to make this 1-1 with the +// wire protocol. +// See https://git-scm.com/docs/pack-protocol#_reference_update_request_and_packfile_transfer type ReferenceUpdateRequest struct { Capabilities *capability.List Commands []*Command @@ -48,6 +51,7 @@ func NewReferenceUpdateRequest() *ReferenceUpdateRequest { // - ofs-delta // - ref-delta // - delete-refs +// // It leaves up to the user to add the following capabilities later: // - atomic // - ofs-delta diff --git a/plumbing/protocol/packp/updreq_decode.go b/plumbing/protocol/packp/updreq_decode.go index 076de545f..dcf525364 100644 --- a/plumbing/protocol/packp/updreq_decode.go +++ b/plumbing/protocol/packp/updreq_decode.go @@ -7,8 +7,8 @@ import ( "fmt" "io" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" ) var ( @@ -83,14 +83,16 @@ func (req *ReferenceUpdateRequest) Decode(r io.Reader) error { rc = io.NopCloser(r) } - d := &updReqDecoder{r: rc, s: pktline.NewScanner(r)} + d := &updReqDecoder{r: rc, pr: r} return d.Decode(req) } type updReqDecoder struct { r io.ReadCloser - s *pktline.Scanner + pr io.Reader req *ReferenceUpdateRequest + + payload []byte } func (d *updReqDecoder) Decode(req *ReferenceUpdateRequest) error { @@ -113,16 +115,26 @@ func (d *updReqDecoder) Decode(req *ReferenceUpdateRequest) error { return nil } -func (d *updReqDecoder) scanLine() error { - if ok := d.s.Scan(); !ok { - return d.scanErrorOr(ErrEmpty) +func (d *updReqDecoder) readLine(e error) error { + _, p, err := pktline.ReadLine(d.pr) + if err == io.EOF { + return e + } + if err != nil { + return err } + d.payload = p + return nil } +func (d *updReqDecoder) scanLine() error { + return d.readLine(ErrEmpty) +} + func (d *updReqDecoder) decodeShallow() error { - b := d.s.Bytes() + b := d.payload if !bytes.HasPrefix(b, shallowNoSp) { return nil @@ -137,8 +149,8 @@ func (d *updReqDecoder) decodeShallow() error { return errInvalidShallowObjId(err) } - if ok := d.s.Scan(); !ok { - return d.scanErrorOr(errNoCommands) + if err := d.readLine(errNoCommands); err != nil { + return err } d.req.Shallow = &h @@ -148,8 +160,8 @@ func (d *updReqDecoder) decodeShallow() error { func (d *updReqDecoder) decodeCommands() error { for { - b := d.s.Bytes() - if bytes.Equal(b, pktline.Flush) { + b := d.payload + if len(b) == 0 { return nil } @@ -160,14 +172,14 @@ func (d *updReqDecoder) decodeCommands() error { d.req.Commands = append(d.req.Commands, c) - if ok := d.s.Scan(); !ok { - return d.s.Err() + if err := d.readLine(nil); err != nil { + return err } } } func (d *updReqDecoder) decodeCommandAndCapabilities() error { - b := d.s.Bytes() + b := d.payload i := bytes.IndexByte(b, 0) if i == -1 { return errMissingCapabilitiesDelimiter @@ -239,11 +251,3 @@ func parseHash(s string) (plumbing.Hash, error) { h := plumbing.NewHash(s) return h, nil } - -func (d *updReqDecoder) scanErrorOr(origErr error) error { - if err := d.s.Err(); err != nil { - return err - } - - return origErr -} diff --git a/plumbing/protocol/packp/updreq_decode_test.go b/plumbing/protocol/packp/updreq_decode_test.go index bdcbdf503..15a21b092 100644 --- a/plumbing/protocol/packp/updreq_decode_test.go +++ b/plumbing/protocol/packp/updreq_decode_test.go @@ -3,151 +3,156 @@ package packp import ( "bytes" "io" + "regexp" + "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" + "github.com/stretchr/testify/suite" ) -type UpdReqDecodeSuite struct{} +type UpdReqDecodeSuite struct { + suite.Suite +} -var _ = Suite(&UpdReqDecodeSuite{}) +func TestUpdReqDecodeSuite(t *testing.T) { + suite.Run(t, new(UpdReqDecodeSuite)) +} -func (s *UpdReqDecodeSuite) TestEmpty(c *C) { +func (s *UpdReqDecodeSuite) TestEmpty() { r := NewReferenceUpdateRequest() var buf bytes.Buffer - c.Assert(r.Decode(&buf), Equals, ErrEmpty) - c.Assert(r, DeepEquals, NewReferenceUpdateRequest()) + s.Equal(ErrEmpty, r.Decode(&buf)) + s.Equal(NewReferenceUpdateRequest(), r) } -func (s *UpdReqDecodeSuite) TestInvalidPktlines(c *C) { +func (s *UpdReqDecodeSuite) TestInvalidPktlines() { r := NewReferenceUpdateRequest() input := bytes.NewReader([]byte("xxxxxxxxxx")) - c.Assert(r.Decode(input), ErrorMatches, "invalid pkt-len found") + s.Regexp(regexp.MustCompile("invalid pkt-len found"), r.Decode(input)) } -func (s *UpdReqDecodeSuite) TestInvalidShadow(c *C) { +func (s *UpdReqDecodeSuite) TestInvalidShadow() { payloads := []string{ "shallow", "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00", - pktline.FlushString, + "", } - s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid shallow line length: expected 48, got 7$") + s.testDecoderErrorMatches(toPktLines(s.T(), payloads), "^malformed request: invalid shallow line length: expected 48, got 7$") payloads = []string{ "shallow ", "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00", - pktline.FlushString, + "", } - s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid shallow line length: expected 48, got 8$") + s.testDecoderErrorMatches(toPktLines(s.T(), payloads), "^malformed request: invalid shallow line length: expected 48, got 8$") payloads = []string{ "shallow 1ecf0ef2c2dffb796033e5a02219af86ec65", "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00", - pktline.FlushString, + "", } - s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid shallow line length: expected 48, got 44$") + s.testDecoderErrorMatches(toPktLines(s.T(), payloads), "^malformed request: invalid shallow line length: expected 48, got 44$") payloads = []string{ "shallow 1ecf0ef2c2dffb796033e5a02219af86ec6584e54", "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00", - pktline.FlushString, + "", } - s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid shallow line length: expected 48, got 49$") + s.testDecoderErrorMatches(toPktLines(s.T(), payloads), "^malformed request: invalid shallow line length: expected 48, got 49$") payloads = []string{ "shallow 1ecf0ef2c2dffb796033e5a02219af86ec6584eu", "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00", - pktline.FlushString, + "", } - s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid shallow object id: invalid hash: .*") + s.testDecoderErrorMatches(toPktLines(s.T(), payloads), "^malformed request: invalid shallow object id: invalid hash: .*") } -func (s *UpdReqDecodeSuite) TestMalformedCommand(c *C) { +func (s *UpdReqDecodeSuite) TestMalformedCommand() { payloads := []string{ "1ecf0ef2c2dffb796033e5a02219af86ec6584e5x2ecf0ef2c2dffb796033e5a02219af86ec6584e5xmyref\x00", - pktline.FlushString, + "", } - s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: malformed command: EOF$") + s.testDecoderErrorMatches(toPktLines(s.T(), payloads), "^malformed request: malformed command: EOF$") payloads = []string{ "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00", "1ecf0ef2c2dffb796033e5a02219af86ec6584e5x2ecf0ef2c2dffb796033e5a02219af86ec6584e5xmyref", - pktline.FlushString, + "", } - s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: malformed command: EOF$") + s.testDecoderErrorMatches(toPktLines(s.T(), payloads), "^malformed request: malformed command: EOF$") } -func (s *UpdReqDecodeSuite) TestInvalidCommandInvalidHash(c *C) { +func (s *UpdReqDecodeSuite) TestInvalidCommandInvalidHash() { payloads := []string{ "1ecf0ef2c2dffb796033e5a02219af86ec6584e 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00", - pktline.FlushString, + "", } - s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid old object id: invalid hash size: expected 40, got 39$") + s.testDecoderErrorMatches(toPktLines(s.T(), payloads), "^malformed request: invalid old object id: invalid hash size: expected 40, got 39$") payloads = []string{ "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e myref\x00", - pktline.FlushString, + "", } - s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid new object id: invalid hash size: expected 40, got 39$") + s.testDecoderErrorMatches(toPktLines(s.T(), payloads), "^malformed request: invalid new object id: invalid hash size: expected 40, got 39$") payloads = []string{ "1ecf0ef2c2dffb796033e5a02219af86e 2ecf0ef2c2dffb796033e5a02219af86ec6 m\x00", - pktline.FlushString, + "", } - s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid command and capabilities line length: expected at least 84, got 72$") + s.testDecoderErrorMatches(toPktLines(s.T(), payloads), "^malformed request: invalid command and capabilities line length: expected at least 84, got 72$") payloads = []string{ "1ecf0ef2c2dffb796033e5a02219af86ec6584eu 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00", - pktline.FlushString, + "", } - s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid old object id: invalid hash: .*$") + s.testDecoderErrorMatches(toPktLines(s.T(), payloads), "^malformed request: invalid old object id: invalid hash: .*$") payloads = []string{ "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584eu myref\x00", - pktline.FlushString, + "", } - s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid new object id: invalid hash: .*$") + s.testDecoderErrorMatches(toPktLines(s.T(), payloads), "^malformed request: invalid new object id: invalid hash: .*$") } -func (s *UpdReqDecodeSuite) TestInvalidCommandMissingNullDelimiter(c *C) { +func (s *UpdReqDecodeSuite) TestInvalidCommandMissingNullDelimiter() { payloads := []string{ "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref", - pktline.FlushString, + "", } - s.testDecoderErrorMatches(c, toPktLines(c, payloads), "capabilities delimiter not found") + s.testDecoderErrorMatches(toPktLines(s.T(), payloads), "capabilities delimiter not found") } -func (s *UpdReqDecodeSuite) TestInvalidCommandMissingName(c *C) { +func (s *UpdReqDecodeSuite) TestInvalidCommandMissingName() { payloads := []string{ "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5\x00", - pktline.FlushString, + "", } - s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid command and capabilities line length: expected at least 84, got 82$") + s.testDecoderErrorMatches(toPktLines(s.T(), payloads), "^malformed request: invalid command and capabilities line length: expected at least 84, got 82$") payloads = []string{ "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 \x00", - pktline.FlushString, + "", } - s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid command and capabilities line length: expected at least 84, got 83$") + s.testDecoderErrorMatches(toPktLines(s.T(), payloads), "^malformed request: invalid command and capabilities line length: expected at least 84, got 83$") payloads = []string{ "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00", "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5", - pktline.FlushString, + "", } - s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid command line length: expected at least 83, got 81$") + s.testDecoderErrorMatches(toPktLines(s.T(), payloads), "^malformed request: invalid command line length: expected at least 83, got 81$") payloads = []string{ "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00", "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 ", - pktline.FlushString, + "", } - s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid command line length: expected at least 83, got 82$") + s.testDecoderErrorMatches(toPktLines(s.T(), payloads), "^malformed request: invalid command line length: expected at least 83, got 82$") } -func (s *UpdReqDecodeSuite) TestOneUpdateCommand(c *C) { +func (s *UpdReqDecodeSuite) TestOneUpdateCommand() { hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5") hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5") name := plumbing.ReferenceName("myref") @@ -160,13 +165,13 @@ func (s *UpdReqDecodeSuite) TestOneUpdateCommand(c *C) { payloads := []string{ "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00", - pktline.FlushString, + "", } - s.testDecodeOkExpected(c, expected, payloads) + s.testDecodeOkExpected(expected, payloads) } -func (s *UpdReqDecodeSuite) TestMultipleCommands(c *C) { +func (s *UpdReqDecodeSuite) TestMultipleCommands() { hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5") hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5") @@ -182,13 +187,13 @@ func (s *UpdReqDecodeSuite) TestMultipleCommands(c *C) { "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref1\x00", "0000000000000000000000000000000000000000 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref2", "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 0000000000000000000000000000000000000000 myref3", - pktline.FlushString, + "", } - s.testDecodeOkExpected(c, expected, payloads) + s.testDecodeOkExpected(expected, payloads) } -func (s *UpdReqDecodeSuite) TestMultipleCommandsAndCapabilities(c *C) { +func (s *UpdReqDecodeSuite) TestMultipleCommandsAndCapabilities() { hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5") hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5") @@ -205,13 +210,13 @@ func (s *UpdReqDecodeSuite) TestMultipleCommandsAndCapabilities(c *C) { "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref1\x00shallow", "0000000000000000000000000000000000000000 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref2", "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 0000000000000000000000000000000000000000 myref3", - pktline.FlushString, + "", } - s.testDecodeOkExpected(c, expected, payloads) + s.testDecodeOkExpected(expected, payloads) } -func (s *UpdReqDecodeSuite) TestMultipleCommandsAndCapabilitiesShallow(c *C) { +func (s *UpdReqDecodeSuite) TestMultipleCommandsAndCapabilitiesShallow() { hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5") hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5") @@ -230,13 +235,13 @@ func (s *UpdReqDecodeSuite) TestMultipleCommandsAndCapabilitiesShallow(c *C) { "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref1\x00shallow", "0000000000000000000000000000000000000000 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref2", "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 0000000000000000000000000000000000000000 myref3", - pktline.FlushString, + "", } - s.testDecodeOkExpected(c, expected, payloads) + s.testDecodeOkExpected(expected, payloads) } -func (s *UpdReqDecodeSuite) TestWithPackfile(c *C) { +func (s *UpdReqDecodeSuite) TestWithPackfile() { hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5") hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5") name := plumbing.ReferenceName("myref") @@ -250,58 +255,69 @@ func (s *UpdReqDecodeSuite) TestWithPackfile(c *C) { payloads := []string{ "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00", - pktline.FlushString, + "", } var buf bytes.Buffer - e := pktline.NewEncoder(&buf) - c.Assert(e.EncodeString(payloads...), IsNil) + for _, p := range payloads { + if p == "" { + s.Nil(pktline.WriteFlush(&buf)) + } else { + _, err := pktline.WriteString(&buf, p) + s.NoError(err) + } + } buf.Write(packfileContent) - s.testDecodeOkRaw(c, expected, buf.Bytes()) + s.testDecodeOkRaw(expected, buf.Bytes()) } -func (s *UpdReqDecodeSuite) testDecoderErrorMatches(c *C, input io.Reader, pattern string) { +func (s *UpdReqDecodeSuite) testDecoderErrorMatches(input io.Reader, pattern string) { r := NewReferenceUpdateRequest() - c.Assert(r.Decode(input), ErrorMatches, pattern) + s.Regexp(regexp.MustCompile(pattern), r.Decode(input)) } -func (s *UpdReqDecodeSuite) testDecodeOK(c *C, payloads []string) *ReferenceUpdateRequest { +func (s *UpdReqDecodeSuite) testDecodeOK(payloads []string) *ReferenceUpdateRequest { var buf bytes.Buffer - e := pktline.NewEncoder(&buf) - err := e.EncodeString(payloads...) - c.Assert(err, IsNil) + for _, p := range payloads { + if p == "" { + s.NoError(pktline.WriteFlush(&buf)) + } else { + _, err := pktline.WriteString(&buf, p) + s.NoError(err) + } + } r := NewReferenceUpdateRequest() - c.Assert(r.Decode(&buf), IsNil) + s.Nil(r.Decode(&buf)) return r } -func (s *UpdReqDecodeSuite) testDecodeOkRaw(c *C, expected *ReferenceUpdateRequest, raw []byte) { +func (s *UpdReqDecodeSuite) testDecodeOkRaw(expected *ReferenceUpdateRequest, raw []byte) { req := NewReferenceUpdateRequest() - c.Assert(req.Decode(bytes.NewBuffer(raw)), IsNil) - c.Assert(req.Packfile, NotNil) - s.compareReaders(c, req.Packfile, expected.Packfile) + s.Nil(req.Decode(bytes.NewBuffer(raw))) + s.NotNil(req.Packfile) + s.compareReaders(req.Packfile, expected.Packfile) req.Packfile = nil expected.Packfile = nil - c.Assert(req, DeepEquals, expected) + s.Equal(expected, req) } -func (s *UpdReqDecodeSuite) testDecodeOkExpected(c *C, expected *ReferenceUpdateRequest, payloads []string) { - req := s.testDecodeOK(c, payloads) - c.Assert(req.Packfile, NotNil) - s.compareReaders(c, req.Packfile, expected.Packfile) +func (s *UpdReqDecodeSuite) testDecodeOkExpected(expected *ReferenceUpdateRequest, payloads []string) { + req := s.testDecodeOK(payloads) + s.NotNil(req.Packfile) + s.compareReaders(req.Packfile, expected.Packfile) req.Packfile = nil expected.Packfile = nil - c.Assert(req, DeepEquals, expected) + s.Equal(expected, req) } -func (s *UpdReqDecodeSuite) compareReaders(c *C, a io.ReadCloser, b io.ReadCloser) { +func (s *UpdReqDecodeSuite) compareReaders(a io.ReadCloser, b io.ReadCloser) { pba, err := io.ReadAll(a) - c.Assert(err, IsNil) - c.Assert(a.Close(), IsNil) + s.NoError(err) + s.NoError(a.Close()) pbb, err := io.ReadAll(b) - c.Assert(err, IsNil) - c.Assert(b.Close(), IsNil) - c.Assert(pba, DeepEquals, pbb) + s.NoError(err) + s.NoError(b.Close()) + s.Equal(pbb, pba) } diff --git a/plumbing/protocol/packp/updreq_encode.go b/plumbing/protocol/packp/updreq_encode.go index 1205cfaf1..c376cea70 100644 --- a/plumbing/protocol/packp/updreq_encode.go +++ b/plumbing/protocol/packp/updreq_encode.go @@ -4,9 +4,9 @@ import ( "fmt" "io" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" ) // Encode writes the ReferenceUpdateRequest encoding to the stream. @@ -15,18 +15,16 @@ func (req *ReferenceUpdateRequest) Encode(w io.Writer) error { return err } - e := pktline.NewEncoder(w) - - if err := req.encodeShallow(e, req.Shallow); err != nil { + if err := req.encodeShallow(w, req.Shallow); err != nil { return err } - if err := req.encodeCommands(e, req.Commands, req.Capabilities); err != nil { + if err := req.encodeCommands(w, req.Commands, req.Capabilities); err != nil { return err } if req.Capabilities.Supports(capability.PushOptions) { - if err := req.encodeOptions(e, req.Options); err != nil { + if err := req.encodeOptions(w, req.Options); err != nil { return err } } @@ -42,32 +40,33 @@ func (req *ReferenceUpdateRequest) Encode(w io.Writer) error { return nil } -func (req *ReferenceUpdateRequest) encodeShallow(e *pktline.Encoder, - h *plumbing.Hash) error { - +func (req *ReferenceUpdateRequest) encodeShallow(w io.Writer, + h *plumbing.Hash, +) error { if h == nil { return nil } objId := []byte(h.String()) - return e.Encodef("%s%s", shallow, objId) + _, err := pktline.Writef(w, "%s%s", shallow, objId) + return err } -func (req *ReferenceUpdateRequest) encodeCommands(e *pktline.Encoder, - cmds []*Command, cap *capability.List) error { - - if err := e.Encodef("%s\x00%s", +func (req *ReferenceUpdateRequest) encodeCommands(w io.Writer, + cmds []*Command, cap *capability.List, +) error { + if _, err := pktline.Writef(w, "%s\x00%s", formatCommand(cmds[0]), cap.String()); err != nil { return err } for _, cmd := range cmds[1:] { - if err := e.Encodef(formatCommand(cmd)); err != nil { + if _, err := pktline.Writef(w, formatCommand(cmd)); err != nil { return err } } - return e.Flush() + return pktline.WriteFlush(w) } func formatCommand(cmd *Command) string { @@ -76,14 +75,14 @@ func formatCommand(cmd *Command) string { return fmt.Sprintf("%s %s %s", o, n, cmd.Name) } -func (req *ReferenceUpdateRequest) encodeOptions(e *pktline.Encoder, - opts []*Option) error { - +func (req *ReferenceUpdateRequest) encodeOptions(w io.Writer, + opts []*Option, +) error { for _, opt := range opts { - if err := e.Encodef("%s=%s", opt.Key, opt.Value); err != nil { + if _, err := pktline.Writef(w, "%s=%s", opt.Key, opt.Value); err != nil { return err } } - return e.Flush() + return pktline.WriteFlush(w) } diff --git a/plumbing/protocol/packp/updreq_encode_test.go b/plumbing/protocol/packp/updreq_encode_test.go index 97868bd64..76a5ea6e3 100644 --- a/plumbing/protocol/packp/updreq_encode_test.go +++ b/plumbing/protocol/packp/updreq_encode_test.go @@ -2,40 +2,44 @@ package packp import ( "bytes" + "fmt" "io" + "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/stretchr/testify/suite" ) -type UpdReqEncodeSuite struct{} +type UpdReqEncodeSuite struct { + suite.Suite +} -var _ = Suite(&UpdReqEncodeSuite{}) +func TestUpdReqEncodeSuite(t *testing.T) { + suite.Run(t, new(UpdReqEncodeSuite)) +} -func (s *UpdReqEncodeSuite) testEncode(c *C, input *ReferenceUpdateRequest, +func (s *UpdReqEncodeSuite) testEncode(input *ReferenceUpdateRequest, expected []byte) { var buf bytes.Buffer - c.Assert(input.Encode(&buf), IsNil) + s.Nil(input.Encode(&buf)) obtained := buf.Bytes() - comment := Commentf("\nobtained = %s\nexpected = %s\n", string(obtained), string(expected)) - c.Assert(obtained, DeepEquals, expected, comment) + comment := fmt.Sprintf("\nobtained = %s\nexpected = %s\n", string(obtained), string(expected)) + s.Equal(expected, obtained, comment) } -func (s *UpdReqEncodeSuite) TestZeroValue(c *C) { +func (s *UpdReqEncodeSuite) TestZeroValue() { r := &ReferenceUpdateRequest{} var buf bytes.Buffer - c.Assert(r.Encode(&buf), Equals, ErrEmptyCommands) + s.Equal(ErrEmptyCommands, r.Encode(&buf)) r = NewReferenceUpdateRequest() - c.Assert(r.Encode(&buf), Equals, ErrEmptyCommands) + s.Equal(ErrEmptyCommands, r.Encode(&buf)) } -func (s *UpdReqEncodeSuite) TestOneUpdateCommand(c *C) { +func (s *UpdReqEncodeSuite) TestOneUpdateCommand() { hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5") hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5") name := plumbing.ReferenceName("myref") @@ -45,15 +49,15 @@ func (s *UpdReqEncodeSuite) TestOneUpdateCommand(c *C) { {Name: name, Old: hash1, New: hash2}, } - expected := pktlines(c, + expected := pktlines(s.T(), "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00", - pktline.FlushString, + "", ) - s.testEncode(c, r, expected) + s.testEncode(r, expected) } -func (s *UpdReqEncodeSuite) TestMultipleCommands(c *C) { +func (s *UpdReqEncodeSuite) TestMultipleCommands() { hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5") hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5") @@ -64,17 +68,17 @@ func (s *UpdReqEncodeSuite) TestMultipleCommands(c *C) { {Name: plumbing.ReferenceName("myref3"), Old: hash1, New: plumbing.ZeroHash}, } - expected := pktlines(c, + expected := pktlines(s.T(), "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref1\x00", "0000000000000000000000000000000000000000 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref2", "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 0000000000000000000000000000000000000000 myref3", - pktline.FlushString, + "", ) - s.testEncode(c, r, expected) + s.testEncode(r, expected) } -func (s *UpdReqEncodeSuite) TestMultipleCommandsAndCapabilities(c *C) { +func (s *UpdReqEncodeSuite) TestMultipleCommandsAndCapabilities() { hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5") hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5") @@ -86,17 +90,17 @@ func (s *UpdReqEncodeSuite) TestMultipleCommandsAndCapabilities(c *C) { } r.Capabilities.Add("shallow") - expected := pktlines(c, + expected := pktlines(s.T(), "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref1\x00shallow", "0000000000000000000000000000000000000000 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref2", "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 0000000000000000000000000000000000000000 myref3", - pktline.FlushString, + "", ) - s.testEncode(c, r, expected) + s.testEncode(r, expected) } -func (s *UpdReqEncodeSuite) TestMultipleCommandsAndCapabilitiesShallow(c *C) { +func (s *UpdReqEncodeSuite) TestMultipleCommandsAndCapabilitiesShallow() { hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5") hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5") @@ -109,18 +113,18 @@ func (s *UpdReqEncodeSuite) TestMultipleCommandsAndCapabilitiesShallow(c *C) { r.Capabilities.Add("shallow") r.Shallow = &hash1 - expected := pktlines(c, + expected := pktlines(s.T(), "shallow 1ecf0ef2c2dffb796033e5a02219af86ec6584e5", "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref1\x00shallow", "0000000000000000000000000000000000000000 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref2", "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 0000000000000000000000000000000000000000 myref3", - pktline.FlushString, + "", ) - s.testEncode(c, r, expected) + s.testEncode(r, expected) } -func (s *UpdReqEncodeSuite) TestWithPackfile(c *C) { +func (s *UpdReqEncodeSuite) TestWithPackfile() { hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5") hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5") name := plumbing.ReferenceName("myref") @@ -135,16 +139,16 @@ func (s *UpdReqEncodeSuite) TestWithPackfile(c *C) { } r.Packfile = packfileReadCloser - expected := pktlines(c, + expected := pktlines(s.T(), "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00", - pktline.FlushString, + "", ) expected = append(expected, packfileContent...) - s.testEncode(c, r, expected) + s.testEncode(r, expected) } -func (s *UpdReqEncodeSuite) TestPushOptions(c *C) { +func (s *UpdReqEncodeSuite) TestPushOptions() { hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5") hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5") name := plumbing.ReferenceName("myref") @@ -159,18 +163,18 @@ func (s *UpdReqEncodeSuite) TestPushOptions(c *C) { {Key: "AnotherKey", Value: "AnotherValue"}, } - expected := pktlines(c, + expected := pktlines(s.T(), "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00push-options", - pktline.FlushString, + "", "SomeKey=SomeValue", "AnotherKey=AnotherValue", - pktline.FlushString, + "", ) - s.testEncode(c, r, expected) + s.testEncode(r, expected) } -func (s *UpdReqEncodeSuite) TestPushAtomic(c *C) { +func (s *UpdReqEncodeSuite) TestPushAtomic() { hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5") hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5") name := plumbing.ReferenceName("myref") @@ -181,10 +185,10 @@ func (s *UpdReqEncodeSuite) TestPushAtomic(c *C) { {Name: name, Old: hash1, New: hash2}, } - expected := pktlines(c, + expected := pktlines(s.T(), "1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00atomic", - pktline.FlushString, + "", ) - s.testEncode(c, r, expected) + s.testEncode(r, expected) } diff --git a/plumbing/protocol/packp/updreq_test.go b/plumbing/protocol/packp/updreq_test.go index 80e03fbe7..7e76cec2f 100644 --- a/plumbing/protocol/packp/updreq_test.go +++ b/plumbing/protocol/packp/updreq_test.go @@ -1,16 +1,21 @@ package packp import ( - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" + "testing" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/stretchr/testify/suite" ) -type UpdReqSuite struct{} +type UpdReqSuite struct { + suite.Suite +} -var _ = Suite(&UpdReqSuite{}) +func TestUpdReqSuite(t *testing.T) { + suite.Run(t, new(UpdReqSuite)) +} -func (s *UpdReqSuite) TestNewReferenceUpdateRequestFromCapabilities(c *C) { +func (s *UpdReqSuite) TestNewReferenceUpdateRequestFromCapabilities() { cap := capability.NewList() cap.Set(capability.Sideband) cap.Set(capability.Sideband64k) @@ -22,18 +27,18 @@ func (s *UpdReqSuite) TestNewReferenceUpdateRequestFromCapabilities(c *C) { cap.Set(capability.Agent, "foo") r := NewReferenceUpdateRequestFromCapabilities(cap) - c.Assert(r.Capabilities.String(), Equals, - "agent=go-git/5.x report-status", + s.Equal("agent=go-git/5.x report-status", + r.Capabilities.String(), ) cap = capability.NewList() cap.Set(capability.Agent, "foo") r = NewReferenceUpdateRequestFromCapabilities(cap) - c.Assert(r.Capabilities.String(), Equals, "agent=go-git/5.x") + s.Equal("agent=go-git/5.x", r.Capabilities.String()) cap = capability.NewList() r = NewReferenceUpdateRequestFromCapabilities(cap) - c.Assert(r.Capabilities.String(), Equals, "") + s.Equal("", r.Capabilities.String()) } diff --git a/plumbing/protocol/packp/uppackreq.go b/plumbing/protocol/packp/uppackreq.go index 48f443856..b7873e50b 100644 --- a/plumbing/protocol/packp/uppackreq.go +++ b/plumbing/protocol/packp/uppackreq.go @@ -5,9 +5,9 @@ import ( "fmt" "io" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" ) // UploadPackRequest represents a upload-pack request. @@ -15,14 +15,27 @@ import ( type UploadPackRequest struct { UploadRequest UploadHaves + UploadPackCommands chan UploadPackCommand +} + +type UploadPackCommand struct { + Acks []UploadPackRequestAck + Done bool +} + +type UploadPackRequestAck struct { + Hash plumbing.Hash + IsCommon bool + IsReady bool } // NewUploadPackRequest creates a new UploadPackRequest and returns a pointer. func NewUploadPackRequest() *UploadPackRequest { ur := NewUploadRequest() return &UploadPackRequest{ - UploadHaves: UploadHaves{}, - UploadRequest: *ur, + UploadHaves: UploadHaves{}, + UploadRequest: *ur, + UploadPackCommands: make(chan UploadPackCommand, 1), } } @@ -33,8 +46,9 @@ func NewUploadPackRequest() *UploadPackRequest { func NewUploadPackRequestFromCapabilities(adv *capability.List) *UploadPackRequest { ur := NewUploadRequestFromCapabilities(adv) return &UploadPackRequest{ - UploadHaves: UploadHaves{}, - UploadRequest: *ur, + UploadHaves: UploadHaves{}, + UploadRequest: *ur, + UploadPackCommands: make(chan UploadPackCommand, 1), } } @@ -71,8 +85,6 @@ type UploadHaves struct { // Encode encodes the UploadHaves into the Writer. If flush is true, a flush // command will be encoded at the end of the writer content. func (u *UploadHaves) Encode(w io.Writer, flush bool) error { - e := pktline.NewEncoder(w) - plumbing.HashesSort(u.Haves) var last plumbing.Hash @@ -81,7 +93,7 @@ func (u *UploadHaves) Encode(w io.Writer, flush bool) error { continue } - if err := e.Encodef("have %s\n", have); err != nil { + if _, err := pktline.Writef(w, "have %s\n", have); err != nil { return fmt.Errorf("sending haves for %q: %s", have, err) } @@ -89,7 +101,7 @@ func (u *UploadHaves) Encode(w io.Writer, flush bool) error { } if flush && len(u.Haves) != 0 { - if err := e.Flush(); err != nil { + if err := pktline.WriteFlush(w); err != nil { return fmt.Errorf("sending flush-pkt after haves: %s", err) } } diff --git a/plumbing/protocol/packp/uppackreq_test.go b/plumbing/protocol/packp/uppackreq_test.go index ad38565a9..8fb735df7 100644 --- a/plumbing/protocol/packp/uppackreq_test.go +++ b/plumbing/protocol/packp/uppackreq_test.go @@ -2,59 +2,67 @@ package packp import ( "bytes" + "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/stretchr/testify/suite" ) -type UploadPackRequestSuite struct{} +type UploadPackRequestSuite struct { + suite.Suite +} -var _ = Suite(&UploadPackRequestSuite{}) +func TestUploadPackRequestSuite(t *testing.T) { + suite.Run(t, new(UploadPackRequestSuite)) +} -func (s *UploadPackRequestSuite) TestNewUploadPackRequestFromCapabilities(c *C) { +func (s *UploadPackRequestSuite) TestNewUploadPackRequestFromCapabilities() { cap := capability.NewList() cap.Set(capability.Agent, "foo") r := NewUploadPackRequestFromCapabilities(cap) - c.Assert(r.Capabilities.String(), Equals, "agent=go-git/5.x") + s.Equal("agent=go-git/5.x", r.Capabilities.String()) } -func (s *UploadPackRequestSuite) TestIsEmpty(c *C) { +func (s *UploadPackRequestSuite) TestIsEmpty() { r := NewUploadPackRequest() r.Wants = append(r.Wants, plumbing.NewHash("d82f291cde9987322c8a0c81a325e1ba6159684c")) r.Wants = append(r.Wants, plumbing.NewHash("2b41ef280fdb67a9b250678686a0c3e03b0a9989")) r.Haves = append(r.Haves, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) - c.Assert(r.IsEmpty(), Equals, false) + s.False(r.IsEmpty()) r = NewUploadPackRequest() r.Wants = append(r.Wants, plumbing.NewHash("d82f291cde9987322c8a0c81a325e1ba6159684c")) r.Wants = append(r.Wants, plumbing.NewHash("2b41ef280fdb67a9b250678686a0c3e03b0a9989")) r.Haves = append(r.Haves, plumbing.NewHash("d82f291cde9987322c8a0c81a325e1ba6159684c")) - c.Assert(r.IsEmpty(), Equals, false) + s.False(r.IsEmpty()) r = NewUploadPackRequest() r.Wants = append(r.Wants, plumbing.NewHash("d82f291cde9987322c8a0c81a325e1ba6159684c")) r.Haves = append(r.Haves, plumbing.NewHash("d82f291cde9987322c8a0c81a325e1ba6159684c")) - c.Assert(r.IsEmpty(), Equals, true) + s.True(r.IsEmpty()) r = NewUploadPackRequest() r.Wants = append(r.Wants, plumbing.NewHash("d82f291cde9987322c8a0c81a325e1ba6159684c")) r.Haves = append(r.Haves, plumbing.NewHash("d82f291cde9987322c8a0c81a325e1ba6159684c")) r.Shallows = append(r.Shallows, plumbing.NewHash("2b41ef280fdb67a9b250678686a0c3e03b0a9989")) - c.Assert(r.IsEmpty(), Equals, false) + s.False(r.IsEmpty()) } -type UploadHavesSuite struct{} +type UploadHavesSuite struct { + suite.Suite +} -var _ = Suite(&UploadHavesSuite{}) +func TestUploadHavesSuite(t *testing.T) { + suite.Run(t, new(UploadHavesSuite)) +} -func (s *UploadHavesSuite) TestEncode(c *C) { +func (s *UploadHavesSuite) TestEncode() { uh := &UploadHaves{} uh.Haves = append(uh.Haves, plumbing.NewHash("1111111111111111111111111111111111111111"), @@ -66,11 +74,12 @@ func (s *UploadHavesSuite) TestEncode(c *C) { buf := bytes.NewBuffer(nil) err := uh.Encode(buf, true) - c.Assert(err, IsNil) - c.Assert(buf.String(), Equals, ""+ + s.NoError(err) + s.Equal(""+ "0032have 1111111111111111111111111111111111111111\n"+ "0032have 2222222222222222222222222222222222222222\n"+ "0032have 3333333333333333333333333333333333333333\n"+ "0000", + buf.String(), ) } diff --git a/plumbing/protocol/packp/uppackresp.go b/plumbing/protocol/packp/uppackresp.go index a485cb7b2..c4bfdf7ae 100644 --- a/plumbing/protocol/packp/uppackresp.go +++ b/plumbing/protocol/packp/uppackresp.go @@ -1,13 +1,12 @@ package packp import ( + "bufio" "errors" "io" - "bufio" - - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/jesseduffield/go-git/v5/utils/ioutil" ) // ErrUploadPackResponseNotDecoded is returned if Read is called without @@ -17,6 +16,7 @@ var ErrUploadPackResponseNotDecoded = errors.New("upload-pack-response should be // UploadPackResponse contains all the information responded by the upload-pack // service, the response implements io.ReadCloser that allows to read the // packfile directly from it. +// TODO: v6, to be removed type UploadPackResponse struct { ShallowUpdate ServerResponse @@ -34,8 +34,9 @@ func NewUploadPackResponse(req *UploadPackRequest) *UploadPackResponse { req.Capabilities.Supports(capability.MultiACKDetailed) return &UploadPackResponse{ - isShallow: isShallow, - isMultiACK: isMultiACK, + isShallow: isShallow, + isMultiACK: isMultiACK, + ServerResponse: ServerResponse{req: req}, } } @@ -78,7 +79,7 @@ func (r *UploadPackResponse) Encode(w io.Writer) (err error) { } } - if err := r.ServerResponse.Encode(w, r.isMultiACK); err != nil { + if err := r.ServerResponse.Encode(w); err != nil { return err } diff --git a/plumbing/protocol/packp/uppackresp_test.go b/plumbing/protocol/packp/uppackresp_test.go index ec56507e2..70515062a 100644 --- a/plumbing/protocol/packp/uppackresp_test.go +++ b/plumbing/protocol/packp/uppackresp_test.go @@ -5,17 +5,20 @@ import ( "io" "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/stretchr/testify/suite" ) -type UploadPackResponseSuite struct{} +type UploadPackResponseSuite struct { + suite.Suite +} -var _ = Suite(&UploadPackResponseSuite{}) +func TestUploadPackResponseSuite(t *testing.T) { + suite.Run(t, new(UploadPackResponseSuite)) +} -func (s *UploadPackResponseSuite) TestDecodeNAK(c *C) { +func (s *UploadPackResponseSuite) TestDecodeNAK() { raw := "0008NAK\nPACK" req := NewUploadPackRequest() @@ -23,14 +26,14 @@ func (s *UploadPackResponseSuite) TestDecodeNAK(c *C) { defer res.Close() err := res.Decode(io.NopCloser(bytes.NewBufferString(raw))) - c.Assert(err, IsNil) + s.NoError(err) pack, err := io.ReadAll(res) - c.Assert(err, IsNil) - c.Assert(pack, DeepEquals, []byte("PACK")) + s.NoError(err) + s.Equal([]byte("PACK"), pack) } -func (s *UploadPackResponseSuite) TestDecodeDepth(c *C) { +func (s *UploadPackResponseSuite) TestDecodeDepth() { raw := "00000008NAK\nPACK" req := NewUploadPackRequest() @@ -40,14 +43,14 @@ func (s *UploadPackResponseSuite) TestDecodeDepth(c *C) { defer res.Close() err := res.Decode(io.NopCloser(bytes.NewBufferString(raw))) - c.Assert(err, IsNil) + s.NoError(err) pack, err := io.ReadAll(res) - c.Assert(err, IsNil) - c.Assert(pack, DeepEquals, []byte("PACK")) + s.NoError(err) + s.Equal([]byte("PACK"), pack) } -func (s *UploadPackResponseSuite) TestDecodeMalformed(c *C) { +func (s *UploadPackResponseSuite) TestDecodeMalformed() { raw := "00000008ACK\nPACK" req := NewUploadPackRequest() @@ -57,14 +60,10 @@ func (s *UploadPackResponseSuite) TestDecodeMalformed(c *C) { defer res.Close() err := res.Decode(io.NopCloser(bytes.NewBufferString(raw))) - c.Assert(err, NotNil) + s.NotNil(err) } -// multi_ack isn't fully implemented, this ensures that Decode ignores that fact, -// as in some circumstances that's OK to assume so. -// -// TODO: Review as part of multi_ack implementation. -func (s *UploadPackResponseSuite) TestDecodeMultiACK(c *C) { +func (s *UploadPackResponseSuite) TestDecodeMultiACK() { req := NewUploadPackRequest() req.Capabilities.Set(capability.MultiACK) @@ -72,10 +71,10 @@ func (s *UploadPackResponseSuite) TestDecodeMultiACK(c *C) { defer res.Close() err := res.Decode(io.NopCloser(bytes.NewBuffer(nil))) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *UploadPackResponseSuite) TestReadNoDecode(c *C) { +func (s *UploadPackResponseSuite) TestReadNoDecode() { req := NewUploadPackRequest() req.Capabilities.Set(capability.MultiACK) @@ -83,54 +82,85 @@ func (s *UploadPackResponseSuite) TestReadNoDecode(c *C) { defer res.Close() n, err := res.Read(nil) - c.Assert(err, Equals, ErrUploadPackResponseNotDecoded) - c.Assert(n, Equals, 0) + s.ErrorIs(err, ErrUploadPackResponseNotDecoded) + s.Equal(0, n) } -func (s *UploadPackResponseSuite) TestEncodeNAK(c *C) { +func (s *UploadPackResponseSuite) TestEncodeNAK() { pf := io.NopCloser(bytes.NewBuffer([]byte("[PACK]"))) req := NewUploadPackRequest() res := NewUploadPackResponseWithPackfile(req, pf) - defer func() { c.Assert(res.Close(), IsNil) }() - + defer func() { s.Nil(res.Close()) }() + + go func() { + req.UploadPackCommands <- UploadPackCommand{ + Acks: []UploadPackRequestAck{}, + Done: true, + } + close(req.UploadPackCommands) + }() b := bytes.NewBuffer(nil) - c.Assert(res.Encode(b), IsNil) + s.Nil(res.Encode(b)) expected := "0008NAK\n[PACK]" - c.Assert(b.String(), Equals, expected) + s.Equal(expected, b.String()) } -func (s *UploadPackResponseSuite) TestEncodeDepth(c *C) { +func (s *UploadPackResponseSuite) TestEncodeDepth() { pf := io.NopCloser(bytes.NewBuffer([]byte("PACK"))) req := NewUploadPackRequest() req.Depth = DepthCommits(1) res := NewUploadPackResponseWithPackfile(req, pf) - defer func() { c.Assert(res.Close(), IsNil) }() - + defer func() { s.Nil(res.Close()) }() + + go func() { + req.UploadPackCommands <- UploadPackCommand{ + Acks: []UploadPackRequestAck{}, + Done: true, + } + close(req.UploadPackCommands) + }() b := bytes.NewBuffer(nil) - c.Assert(res.Encode(b), IsNil) + s.Nil(res.Encode(b)) expected := "00000008NAK\nPACK" - c.Assert(b.String(), Equals, expected) + s.Equal(expected, b.String()) } -func (s *UploadPackResponseSuite) TestEncodeMultiACK(c *C) { +func (s *UploadPackResponseSuite) TestEncodeMultiACK() { pf := io.NopCloser(bytes.NewBuffer([]byte("[PACK]"))) req := NewUploadPackRequest() + req.Capabilities.Set(capability.MultiACK) res := NewUploadPackResponseWithPackfile(req, pf) - defer func() { c.Assert(res.Close(), IsNil) }() - res.ACKs = []plumbing.Hash{ - plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f81"), - plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f82"), - } - + defer func() { s.Nil(res.Close()) }() + go func() { + req.UploadPackCommands <- UploadPackCommand{ + Acks: []UploadPackRequestAck{ + {Hash: plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f81")}, + {Hash: plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f82"), IsCommon: true}, + }, + } + req.UploadPackCommands <- UploadPackCommand{ + Acks: []UploadPackRequestAck{}, + Done: true, + } + close(req.UploadPackCommands) + }() b := bytes.NewBuffer(nil) - c.Assert(res.Encode(b), NotNil) + s.Nil(res.Encode(b)) + + expected := "003aACK 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f82 continue\n" + + "0008NAK\n" + + "0031ACK 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f82\n" + + "[PACK]" + s.Equal(expected, b.String()) } func FuzzDecoder(f *testing.F) { + f.Add([]byte("0045ACK 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f81\n")) + f.Add([]byte("003aACK5dc01c595e6c6ec9ccda4f6f69c131c0dd945f82 \n0008NAK\n0")) f.Fuzz(func(t *testing.T, input []byte) { req := NewUploadPackRequest() diff --git a/plumbing/protocol/version.go b/plumbing/protocol/version.go new file mode 100644 index 000000000..48245a600 --- /dev/null +++ b/plumbing/protocol/version.go @@ -0,0 +1,52 @@ +package protocol + +import ( + "errors" + "fmt" +) + +var ErrUnknownProtocol = errors.New("unknown Git Wire protocol") + +// Version sets the preferred version for the Git wire protocol. +type Version int + +const ( + // V0 represents the original Wire protocol. + V0 Version = iota + // V1 represents the version V1 of the Wire protocol. + V1 + // V2 represents the version V2 of the Wire protocol. + V2 + + Undefined Version = -1 +) + +// String converts a Version into string. +// The Unknown version is converted to empty string. +func (v Version) String() string { + switch v { + case V0: + return "0" + case V1: + return "1" + case V2: + return "2" + } + + return "" +} + +// Parse parses a string and returns the matching protocol version. +// Unrecognised strings will return a ErrUnknownProtocol. +func Parse(v string) (Version, error) { + switch v { + case "0": + return V0, nil + case "1": + return V1, nil + case "2": + return V2, nil + } + + return Undefined, fmt.Errorf("cannot parse %q: %w", v, ErrUnknownProtocol) +} diff --git a/plumbing/reference.go b/plumbing/reference.go index ddba93029..4daa34164 100644 --- a/plumbing/reference.go +++ b/plumbing/reference.go @@ -188,7 +188,7 @@ func (r ReferenceName) Validate() error { isBranch := r.IsBranch() isTag := r.IsTag() - for _, part := range parts { + for i, part := range parts { // rule 6 if len(part) == 0 { return ErrInvalidReferenceName @@ -205,7 +205,7 @@ func (r ReferenceName) Validate() error { return ErrInvalidReferenceName } - if (isBranch || isTag) && strings.HasPrefix(part, "-") { // branches & tags can't start with - + if (isBranch || isTag) && strings.HasPrefix(part, "-") && (i == 2) { // branches & tags can't start with - return ErrInvalidReferenceName } } diff --git a/plumbing/reference_test.go b/plumbing/reference_test.go index ce570752f..f10e5cdf2 100644 --- a/plumbing/reference_test.go +++ b/plumbing/reference_test.go @@ -1,109 +1,114 @@ package plumbing import ( + "fmt" "testing" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) -type ReferenceSuite struct{} +type ReferenceSuite struct { + suite.Suite +} -var _ = Suite(&ReferenceSuite{}) +func TestReferenceSuite(t *testing.T) { + suite.Run(t, new(ReferenceSuite)) +} const ( ExampleReferenceName ReferenceName = "refs/heads/v4" ) -func (s *ReferenceSuite) TestReferenceTypeString(c *C) { - c.Assert(SymbolicReference.String(), Equals, "symbolic-reference") +func (s *ReferenceSuite) TestReferenceTypeString() { + s.Equal("symbolic-reference", SymbolicReference.String()) } -func (s *ReferenceSuite) TestReferenceNameShort(c *C) { - c.Assert(ExampleReferenceName.Short(), Equals, "v4") +func (s *ReferenceSuite) TestReferenceNameShort() { + s.Equal("v4", ExampleReferenceName.Short()) } -func (s *ReferenceSuite) TestReferenceNameWithSlash(c *C) { +func (s *ReferenceSuite) TestReferenceNameWithSlash() { r := ReferenceName("refs/remotes/origin/feature/AllowSlashes") - c.Assert(r.Short(), Equals, "origin/feature/AllowSlashes") + s.Equal("origin/feature/AllowSlashes", r.Short()) } -func (s *ReferenceSuite) TestReferenceNameNote(c *C) { +func (s *ReferenceSuite) TestReferenceNameNote() { r := ReferenceName("refs/notes/foo") - c.Assert(r.Short(), Equals, "notes/foo") + s.Equal("notes/foo", r.Short()) } -func (s *ReferenceSuite) TestNewReferenceFromStrings(c *C) { +func (s *ReferenceSuite) TestNewReferenceFromStrings() { r := NewReferenceFromStrings("refs/heads/v4", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") - c.Assert(r.Type(), Equals, HashReference) - c.Assert(r.Name(), Equals, ExampleReferenceName) - c.Assert(r.Hash(), Equals, NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) + s.Equal(HashReference, r.Type()) + s.Equal(ExampleReferenceName, r.Name()) + s.Equal(NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"), r.Hash()) r = NewReferenceFromStrings("HEAD", "ref: refs/heads/v4") - c.Assert(r.Type(), Equals, SymbolicReference) - c.Assert(r.Name(), Equals, HEAD) - c.Assert(r.Target(), Equals, ExampleReferenceName) + s.Equal(SymbolicReference, r.Type()) + s.Equal(HEAD, r.Name()) + s.Equal(ExampleReferenceName, r.Target()) } -func (s *ReferenceSuite) TestNewSymbolicReference(c *C) { +func (s *ReferenceSuite) TestNewSymbolicReference() { r := NewSymbolicReference(HEAD, ExampleReferenceName) - c.Assert(r.Type(), Equals, SymbolicReference) - c.Assert(r.Name(), Equals, HEAD) - c.Assert(r.Target(), Equals, ExampleReferenceName) + s.Equal(SymbolicReference, r.Type()) + s.Equal(HEAD, r.Name()) + s.Equal(ExampleReferenceName, r.Target()) } -func (s *ReferenceSuite) TestNewHashReference(c *C) { +func (s *ReferenceSuite) TestNewHashReference() { r := NewHashReference(ExampleReferenceName, NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) - c.Assert(r.Type(), Equals, HashReference) - c.Assert(r.Name(), Equals, ExampleReferenceName) - c.Assert(r.Hash(), Equals, NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) + s.Equal(HashReference, r.Type()) + s.Equal(ExampleReferenceName, r.Name()) + s.Equal(NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"), r.Hash()) } -func (s *ReferenceSuite) TestNewBranchReferenceName(c *C) { +func (s *ReferenceSuite) TestNewBranchReferenceName() { r := NewBranchReferenceName("foo") - c.Assert(r.String(), Equals, "refs/heads/foo") + s.Equal("refs/heads/foo", r.String()) } -func (s *ReferenceSuite) TestNewNoteReferenceName(c *C) { +func (s *ReferenceSuite) TestNewNoteReferenceName() { r := NewNoteReferenceName("foo") - c.Assert(r.String(), Equals, "refs/notes/foo") + s.Equal("refs/notes/foo", r.String()) } -func (s *ReferenceSuite) TestNewRemoteReferenceName(c *C) { +func (s *ReferenceSuite) TestNewRemoteReferenceName() { r := NewRemoteReferenceName("bar", "foo") - c.Assert(r.String(), Equals, "refs/remotes/bar/foo") + s.Equal("refs/remotes/bar/foo", r.String()) } -func (s *ReferenceSuite) TestNewRemoteHEADReferenceName(c *C) { +func (s *ReferenceSuite) TestNewRemoteHEADReferenceName() { r := NewRemoteHEADReferenceName("foo") - c.Assert(r.String(), Equals, "refs/remotes/foo/HEAD") + s.Equal("refs/remotes/foo/HEAD", r.String()) } -func (s *ReferenceSuite) TestNewTagReferenceName(c *C) { +func (s *ReferenceSuite) TestNewTagReferenceName() { r := NewTagReferenceName("foo") - c.Assert(r.String(), Equals, "refs/tags/foo") + s.Equal("refs/tags/foo", r.String()) } -func (s *ReferenceSuite) TestIsBranch(c *C) { +func (s *ReferenceSuite) TestIsBranch() { r := ExampleReferenceName - c.Assert(r.IsBranch(), Equals, true) + s.True(r.IsBranch()) } -func (s *ReferenceSuite) TestIsNote(c *C) { +func (s *ReferenceSuite) TestIsNote() { r := ReferenceName("refs/notes/foo") - c.Assert(r.IsNote(), Equals, true) + s.True(r.IsNote()) } -func (s *ReferenceSuite) TestIsRemote(c *C) { +func (s *ReferenceSuite) TestIsRemote() { r := ReferenceName("refs/remotes/origin/master") - c.Assert(r.IsRemote(), Equals, true) + s.True(r.IsRemote()) } -func (s *ReferenceSuite) TestIsTag(c *C) { +func (s *ReferenceSuite) TestIsTag() { r := ReferenceName("refs/tags/v3.1.") - c.Assert(r.IsTag(), Equals, true) + s.True(r.IsTag()) } -func (s *ReferenceSuite) TestValidReferenceNames(c *C) { +func (s *ReferenceSuite) TestValidReferenceNames() { valid := []ReferenceName{ "refs/heads/master", "refs/notes/commits", @@ -115,9 +120,11 @@ func (s *ReferenceSuite) TestValidReferenceNames(c *C) { "refs/pulls/1/abc.123", "refs/pulls", "refs/-", // should this be allowed? + "refs/ab/-testing", + "refs/123-testing", } for _, v := range valid { - c.Assert(v.Validate(), IsNil) + s.Nil(v.Validate()) } invalid := []ReferenceName{ @@ -156,9 +163,9 @@ func (s *ReferenceSuite) TestValidReferenceNames(c *C) { } for i, v := range invalid { - comment := Commentf("invalid reference name case %d: %s", i, v) - c.Assert(v.Validate(), NotNil, comment) - c.Assert(v.Validate(), ErrorMatches, "invalid reference name", comment) + comment := fmt.Sprintf("invalid reference name case %d: %s", i, v) + s.Error(v.Validate(), comment) + s.ErrorContains(v.Validate(), "invalid reference name", comment) } } diff --git a/plumbing/revlist/revlist.go b/plumbing/revlist/revlist.go index b9109870f..3f34089dd 100644 --- a/plumbing/revlist/revlist.go +++ b/plumbing/revlist/revlist.go @@ -6,10 +6,10 @@ import ( "fmt" "io" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/filemode" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/plumbing/storer" ) // Objects applies a complementary set. It gets all the hashes from all @@ -228,3 +228,26 @@ func hashListToSet(hashes []plumbing.Hash) map[plumbing.Hash]bool { return result } + +// ObjectsWithRef find all hashes linked to objs +// return a map of hashes containing an array of hash objs +func ObjectsWithRef( + s storer.EncodedObjectStorer, + objs, + ignore []plumbing.Hash, +) (map[plumbing.Hash][]plumbing.Hash, error) { + all := map[plumbing.Hash][]plumbing.Hash{} + for _, obj := range objs { + walkerFunc := func(h plumbing.Hash) { + if hashes, ok := all[h]; ok { + all[h] = append(hashes, obj) + } else { + all[h] = []plumbing.Hash{obj} + } + } + if err := processObject(s, obj, map[plumbing.Hash]bool{}, map[plumbing.Hash]bool{}, ignore, walkerFunc); err != nil { + return nil, err + } + } + return all, nil +} diff --git a/plumbing/revlist/revlist_test.go b/plumbing/revlist/revlist_test.go index 9f2f93b53..6870519fd 100644 --- a/plumbing/revlist/revlist_test.go +++ b/plumbing/revlist/revlist_test.go @@ -3,24 +3,29 @@ package revlist import ( "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) -func Test(t *testing.T) { TestingT(t) } +type RevListFixtureSuite struct { + fixtures.Suite +} type RevListSuite struct { - fixtures.Suite + suite.Suite + RevListFixtureSuite Storer storer.EncodedObjectStorer } -var _ = Suite(&RevListSuite{}) +func TestRevListSuite(t *testing.T) { + suite.Run(t, new(RevListSuite)) +} const ( initialCommit = "b029517f6300c2da0f4b651b8642506cd6aaf45d" @@ -50,12 +55,12 @@ const ( // |/ // * b029517 Initial commit -func (s *RevListSuite) SetUpTest(c *C) { +func (s *RevListSuite) SetupTest() { sto := filesystem.NewStorage(fixtures.Basic().One().DotGit(), cache.NewObjectLRUDefault()) s.Storer = sto } -func (s *RevListSuite) TestRevListObjects_Submodules(c *C) { +func (s *RevListSuite) TestRevListObjects_Submodules() { submodules := map[string]bool{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5": true, } @@ -63,12 +68,12 @@ func (s *RevListSuite) TestRevListObjects_Submodules(c *C) { sto := filesystem.NewStorage(fixtures.ByTag("submodule").One().DotGit(), cache.NewObjectLRUDefault()) ref, err := storer.ResolveReference(sto, plumbing.HEAD) - c.Assert(err, IsNil) + s.NoError(err) revList, err := Objects(sto, []plumbing.Hash{ref.Hash()}, nil) - c.Assert(err, IsNil) + s.NoError(err) for _, h := range revList { - c.Assert(submodules[h.String()], Equals, false) + s.False(submodules[h.String()]) } } @@ -79,7 +84,7 @@ func (s *RevListSuite) TestRevListObjects_Submodules(c *C) { // * | 35e8510 binary file // |/ // * b029517 Initial commit -func (s *RevListSuite) TestRevListObjects(c *C) { +func (s *RevListSuite) TestRevListObjects() { revList := map[string]bool{ "b8e471f58bcbca63b07bda20e428190409c2db47": true, // second commit "c2d30fa8ef288618f65f6eed6e168e0d514886f4": true, // init tree @@ -88,19 +93,19 @@ func (s *RevListSuite) TestRevListObjects(c *C) { localHist, err := Objects(s.Storer, []plumbing.Hash{plumbing.NewHash(initialCommit)}, nil) - c.Assert(err, IsNil) + s.NoError(err) remoteHist, err := Objects(s.Storer, []plumbing.Hash{plumbing.NewHash(secondCommit)}, localHist) - c.Assert(err, IsNil) + s.NoError(err) for _, h := range remoteHist { - c.Assert(revList[h.String()], Equals, true) + s.True(revList[h.String()]) } - c.Assert(len(remoteHist), Equals, len(revList)) + s.Len(revList, len(remoteHist)) } -func (s *RevListSuite) TestRevListObjectsTagObject(c *C) { +func (s *RevListSuite) TestRevListObjectsTagObject() { sto := filesystem.NewStorage( fixtures.ByTag("tags"). ByURL("https://github.com/git-fixtures/tags.git").One().DotGit(), cache.NewObjectLRUDefault()) @@ -113,16 +118,16 @@ func (s *RevListSuite) TestRevListObjectsTagObject(c *C) { } hist, err := Objects(sto, []plumbing.Hash{plumbing.NewHash("ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc")}, nil) - c.Assert(err, IsNil) + s.NoError(err) for _, h := range hist { - c.Assert(expected[h.String()], Equals, true) + s.True(expected[h.String()]) } - c.Assert(len(hist), Equals, len(expected)) + s.Len(expected, len(hist)) } -func (s *RevListSuite) TestRevListObjectsWithStorageForIgnores(c *C) { +func (s *RevListSuite) TestRevListObjectsWithStorageForIgnores() { sto := filesystem.NewStorage( fixtures.ByTag("merge-conflict").One().DotGit(), cache.NewObjectLRUDefault()) @@ -139,13 +144,13 @@ func (s *RevListSuite) TestRevListObjectsWithStorageForIgnores(c *C) { } hist, err := ObjectsWithStorageForIgnores(sto, s.Storer, []plumbing.Hash{plumbing.NewHash("1980fcf55330d9d94c34abee5ab734afecf96aba")}, []plumbing.Hash{plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")}) - c.Assert(err, IsNil) + s.NoError(err) for _, h := range hist { - c.Assert(expected[h.String()], Equals, true) + s.True(expected[h.String()]) } - c.Assert(len(hist), Equals, len(expected)) + s.Len(expected, len(hist)) } // --- @@ -155,7 +160,7 @@ func (s *RevListSuite) TestRevListObjectsWithStorageForIgnores(c *C) { // * | 35e8510 binary file // |/ // * b029517 Initial commit -func (s *RevListSuite) TestRevListObjectsWithBlobsAndTrees(c *C) { +func (s *RevListSuite) TestRevListObjectsWithBlobsAndTrees() { revList := map[string]bool{ "b8e471f58bcbca63b07bda20e428190409c2db47": true, // second commit } @@ -166,41 +171,41 @@ func (s *RevListSuite) TestRevListObjectsWithBlobsAndTrees(c *C) { plumbing.NewHash("c2d30fa8ef288618f65f6eed6e168e0d514886f4"), plumbing.NewHash("d3ff53e0564a9f87d8e84b6e28e5060e517008aa"), }, nil) - c.Assert(err, IsNil) + s.NoError(err) remoteHist, err := Objects(s.Storer, []plumbing.Hash{plumbing.NewHash(secondCommit)}, localHist) - c.Assert(err, IsNil) + s.NoError(err) for _, h := range remoteHist { - c.Assert(revList[h.String()], Equals, true) + s.True(revList[h.String()]) } - c.Assert(len(remoteHist), Equals, len(revList)) + s.Len(revList, len(remoteHist)) } -func (s *RevListSuite) TestRevListObjectsReverse(c *C) { +func (s *RevListSuite) TestRevListObjectsReverse() { localHist, err := Objects(s.Storer, []plumbing.Hash{plumbing.NewHash(secondCommit)}, nil) - c.Assert(err, IsNil) + s.NoError(err) remoteHist, err := Objects(s.Storer, []plumbing.Hash{plumbing.NewHash(initialCommit)}, localHist) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(len(remoteHist), Equals, 0) + s.Len(remoteHist, 0) } -func (s *RevListSuite) TestRevListObjectsSameCommit(c *C) { +func (s *RevListSuite) TestRevListObjectsSameCommit() { localHist, err := Objects(s.Storer, []plumbing.Hash{plumbing.NewHash(secondCommit)}, nil) - c.Assert(err, IsNil) + s.NoError(err) remoteHist, err := Objects(s.Storer, []plumbing.Hash{plumbing.NewHash(secondCommit)}, localHist) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(len(remoteHist), Equals, 0) + s.Len(remoteHist, 0) } // * 6ecf0ef vendor stuff @@ -208,16 +213,16 @@ func (s *RevListSuite) TestRevListObjectsSameCommit(c *C) { // |/ // * 918c48b some code // ----- -func (s *RevListSuite) TestRevListObjectsNewBranch(c *C) { +func (s *RevListSuite) TestRevListObjectsNewBranch() { localHist, err := Objects(s.Storer, []plumbing.Hash{plumbing.NewHash(someCommit)}, nil) - c.Assert(err, IsNil) + s.NoError(err) remoteHist, err := Objects( s.Storer, []plumbing.Hash{ plumbing.NewHash(someCommitBranch), plumbing.NewHash(someCommitOtherBranch)}, localHist) - c.Assert(err, IsNil) + s.NoError(err) revList := map[string]bool{ "a8d315b2b1c615d43042c3a62402b8a54288cf5c": true, // init tree @@ -230,9 +235,9 @@ func (s *RevListSuite) TestRevListObjectsNewBranch(c *C) { } for _, h := range remoteHist { - c.Assert(revList[h.String()], Equals, true) + s.True(revList[h.String()]) } - c.Assert(len(remoteHist), Equals, len(revList)) + s.Len(revList, len(remoteHist)) } // This tests will ensure that a5b8b09 and b8e471f will be visited even if @@ -249,15 +254,15 @@ func (s *RevListSuite) TestRevListObjectsNewBranch(c *C) { // * | 35e8510 binary file // |/ // * b029517 Initial commit -func (s *RevListSuite) TestReachableObjectsNoRevisit(c *C) { +func (s *RevListSuite) TestReachableObjectsNoRevisit() { obj, err := s.Storer.EncodedObject(plumbing.CommitObject, plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a")) - c.Assert(err, IsNil) + s.NoError(err) do, err := object.DecodeObject(s.Storer, obj) - c.Assert(err, IsNil) + s.NoError(err) commit, ok := do.(*object.Commit) - c.Assert(ok, Equals, true) + s.True(ok) var visited []plumbing.Hash err = reachableObjects( @@ -271,23 +276,24 @@ func (s *RevListSuite) TestReachableObjectsNoRevisit(c *C) { nil, func(h plumbing.Hash) { obj, err := s.Storer.EncodedObject(plumbing.AnyObject, h) - c.Assert(err, IsNil) + s.NoError(err) do, err := object.DecodeObject(s.Storer, obj) - c.Assert(err, IsNil) + s.NoError(err) if _, ok := do.(*object.Commit); ok { visited = append(visited, h) } }, ) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(visited, DeepEquals, []plumbing.Hash{ + s.Equal([]plumbing.Hash{ plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"), plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea"), plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69"), plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"), plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"), - }) + }, visited, + ) } diff --git a/plumbing/transport/server/loader.go b/plumbing/server/loader.go similarity index 78% rename from plumbing/transport/server/loader.go rename to plumbing/server/loader.go index e7e2b075e..ded1cf1ae 100644 --- a/plumbing/transport/server/loader.go +++ b/plumbing/server/loader.go @@ -1,10 +1,10 @@ package server import ( - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/storage/filesystem" "github.com/go-git/go-billy/v5" "github.com/go-git/go-billy/v5/osfs" @@ -40,8 +40,16 @@ func (l *fsLoader) Load(ep *transport.Endpoint) (storer.Storer, error) { return nil, err } - if _, err := fs.Stat("config"); err != nil { - return nil, transport.ErrRepositoryNotFound + var bare bool + if _, err := fs.Stat("config"); err == nil { + bare = true + } + + if !bare { + // do not use git.GitDirName due to import cycle + if _, err := fs.Stat(".git"); err != nil { + return nil, transport.ErrRepositoryNotFound + } } return filesystem.NewStorage(fs, cache.NewObjectLRUDefault()), nil diff --git a/plumbing/server/loader_test.go b/plumbing/server/loader_test.go new file mode 100644 index 000000000..af9112731 --- /dev/null +++ b/plumbing/server/loader_test.go @@ -0,0 +1,99 @@ +package server + +import ( + "os" + "os/exec" + "path/filepath" + "testing" + + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/suite" +) + +type loaderSuiteRepo struct { + bare bool + + path string +} + +type LoaderSuite struct { + suite.Suite + Repos map[string]loaderSuiteRepo +} + +func TestLoaderSuite(t *testing.T) { + suite.Run(t, + &LoaderSuite{ + Repos: map[string]loaderSuiteRepo{ + "repo": {path: "repo.git"}, + "bare": {path: "bare.git", bare: true}, + }, + }, + ) +} + +func (s *LoaderSuite) SetupSuite() { + if err := exec.Command("git", "--version").Run(); err != nil { + s.T().Skip("git command not found") + } + + dir, err := os.MkdirTemp("", "") + s.NoError(err) + + for key, repo := range s.Repos { + repo.path = filepath.Join(dir, repo.path) + if repo.bare { + s.Nil(exec.Command("git", "init", "--bare", repo.path).Run()) + } else { + s.Nil(exec.Command("git", "init", repo.path).Run()) + } + s.Repos[key] = repo + } + +} + +func (s *LoaderSuite) endpoint(url string) *transport.Endpoint { + ep, err := transport.NewEndpoint(url) + s.NoError(err) + return ep +} + +func (s *LoaderSuite) TestLoadNonExistent() { + sto, err := DefaultLoader.Load(s.endpoint("does-not-exist")) + s.ErrorIs(err, transport.ErrRepositoryNotFound) + s.Nil(sto) +} + +func (s *LoaderSuite) TestLoadNonExistentIgnoreHost() { + sto, err := DefaultLoader.Load(s.endpoint("https://github.com/does-not-exist")) + s.ErrorIs(err, transport.ErrRepositoryNotFound) + s.Nil(sto) +} + +func (s *LoaderSuite) TestLoad() { + sto, err := DefaultLoader.Load(s.endpoint(s.Repos["repo"].path)) + s.NoError(err) + s.NotNil(sto) +} + +func (s *LoaderSuite) TestLoadBare() { + sto, err := DefaultLoader.Load(s.endpoint(s.Repos["bare"].path)) + s.NoError(err) + s.NotNil(sto) +} + +func (s *LoaderSuite) TestMapLoader() { + ep, err := transport.NewEndpoint("file://test") + sto := memory.NewStorage() + s.NoError(err) + + loader := MapLoader{ep.String(): sto} + + ep, err = transport.NewEndpoint("file://test") + s.NoError(err) + + loaderSto, err := loader.Load(ep) + s.NoError(err) + s.Equal(loaderSto, sto) +} diff --git a/plumbing/transport/server/receive_pack_test.go b/plumbing/server/receive_pack_test.go similarity index 52% rename from plumbing/transport/server/receive_pack_test.go rename to plumbing/server/receive_pack_test.go index 6c704bd76..2059844d5 100644 --- a/plumbing/transport/server/receive_pack_test.go +++ b/plumbing/server/receive_pack_test.go @@ -2,42 +2,40 @@ package server_test import ( "context" + "fmt" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/protocol/packp" - "github.com/go-git/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp" + "github.com/jesseduffield/go-git/v5/plumbing/transport" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) type ReceivePackSuite struct { BaseSuite } -var _ = Suite(&ReceivePackSuite{}) - -func (s *ReceivePackSuite) SetUpSuite(c *C) { - s.BaseSuite.SetUpSuite(c) +func (s *ReceivePackSuite) SetupSuite() { + s.BaseSuite.SetupSuite() s.ReceivePackSuite.Client = s.client } -func (s *ReceivePackSuite) SetUpTest(c *C) { - s.prepareRepositories(c) +func (s *ReceivePackSuite) SetupTest() { + s.prepareRepositories() } -func (s *ReceivePackSuite) TearDownTest(c *C) { - s.Suite.TearDownSuite(c) +func (s *ReceivePackSuite) TearDownTest() { + s.BaseSuite.TearDownSuite() } // Overwritten, server returns error earlier. -func (s *ReceivePackSuite) TestAdvertisedReferencesNotExists(c *C) { +func (s *ReceivePackSuite) TestAdvertisedReferencesNotExists() { r, err := s.Client.NewReceivePackSession(s.NonExistentEndpoint, s.EmptyAuth) - c.Assert(err, Equals, transport.ErrRepositoryNotFound) - c.Assert(r, IsNil) + s.ErrorIs(err, transport.ErrRepositoryNotFound) + s.Nil(r) } -func (s *ReceivePackSuite) TestReceivePackWithNilPackfile(c *C) { +func (s *ReceivePackSuite) TestReceivePackWithNilPackfile() { endpoint := s.Endpoint auth := s.EmptyAuth @@ -49,16 +47,16 @@ func (s *ReceivePackSuite) TestReceivePackWithNilPackfile(c *C) { // default is already nil, but be explicit since this is what the test is for req.Packfile = nil - comment := Commentf( + comment := fmt.Sprintf( "failed with ep=%s fixture=%s", endpoint.String(), fixture.URL, ) r, err := s.Client.NewReceivePackSession(endpoint, auth) - c.Assert(err, IsNil, comment) - defer func() { c.Assert(r.Close(), IsNil, comment) }() + s.Nil(err, comment) + defer func() { s.Nil(r.Close(), comment) }() report, err := r.ReceivePack(context.Background(), req) - c.Assert(report, IsNil, comment) - c.Assert(err, NotNil, comment) + s.Nil(report, comment) + s.NotNil(err, comment) } diff --git a/plumbing/transport/internal/common/server.go b/plumbing/server/serve.go similarity index 88% rename from plumbing/transport/internal/common/server.go rename to plumbing/server/serve.go index e2480848a..d35824fbe 100644 --- a/plumbing/transport/internal/common/server.go +++ b/plumbing/server/serve.go @@ -1,13 +1,13 @@ -package common +package server import ( "context" "fmt" "io" - "github.com/go-git/go-git/v5/plumbing/protocol/packp" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/utils/ioutil" ) // ServerCommand is used for a single server command execution. diff --git a/plumbing/transport/server/server.go b/plumbing/server/server.go similarity index 83% rename from plumbing/transport/server/server.go rename to plumbing/server/server.go index cf5d6f43f..346ef81db 100644 --- a/plumbing/transport/server/server.go +++ b/plumbing/server/server.go @@ -7,15 +7,17 @@ import ( "errors" "fmt" "io" - - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/packfile" - "github.com/go-git/go-git/v5/plumbing/protocol/packp" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - "github.com/go-git/go-git/v5/plumbing/revlist" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/utils/ioutil" + "time" + + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/packfile" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/jesseduffield/go-git/v5/plumbing/revlist" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/utils/trace" ) var DefaultServer = NewServer(DefaultLoader) @@ -136,6 +138,11 @@ func (s *upSession) AdvertisedReferencesContext(ctx context.Context) (*packp.Adv } func (s *upSession) UploadPack(ctx context.Context, req *packp.UploadPackRequest) (*packp.UploadPackResponse, error) { + start := time.Now() + defer func() { + trace.Performance.Printf("performance: %.9f s: upload_pack", time.Since(start).Seconds()) + }() + if req.IsEmpty() { return nil, transport.ErrEmptyUploadPackRequest } @@ -161,7 +168,7 @@ func (s *upSession) UploadPack(ctx context.Context, req *packp.UploadPackRequest return nil, fmt.Errorf("shallow not supported") } - objs, err := s.objectsToUpload(req) + havesWithRef, err := revlist.ObjectsWithRef(s.storer, req.Wants, nil) if err != nil { return nil, err } @@ -169,8 +176,30 @@ func (s *upSession) UploadPack(ctx context.Context, req *packp.UploadPackRequest pr, pw := io.Pipe() e := packfile.NewEncoder(pw, s.storer, false) go func() { - // TODO: plumb through a pack window. - _, err := e.Encode(objs, 10) + allHaves := []plumbing.Hash{} + foundWants := map[plumbing.Hash]bool{} + for haves := range req.HavesUR { + acks := []packp.UploadPackRequestAck{} + for _, hu := range haves.Haves { + refs, ok := havesWithRef[hu] + if ok { + for _, ref := range refs { + foundWants[ref] = true + } + } + acks = append(acks, packp.UploadPackRequestAck{Hash: hu, IsCommon: ok, IsReady: ok && (len(refs) >= len(req.Wants) || len(foundWants) >= len(req.Wants))}) + allHaves = append(allHaves, hu) + } + + req.UploadPackCommands <- packp.UploadPackCommand{Acks: acks, Done: haves.Done} + } + close(req.UploadPackCommands) + objs, err := s.objectsToUpload(req.Wants, allHaves) + if err != nil { + pw.CloseWithError(err) + return + } + _, err = e.Encode(objs, 10) pw.CloseWithError(err) }() @@ -179,13 +208,8 @@ func (s *upSession) UploadPack(ctx context.Context, req *packp.UploadPackRequest ), nil } -func (s *upSession) objectsToUpload(req *packp.UploadPackRequest) ([]plumbing.Hash, error) { - haves, err := revlist.Objects(s.storer, req.Haves, nil) - if err != nil { - return nil, err - } - - return revlist.Objects(s.storer, req.Wants, haves) +func (s *upSession) objectsToUpload(wants, haves []plumbing.Hash) ([]plumbing.Hash, error) { + return revlist.Objects(s.storer, wants, haves) } func (*upSession) setSupportedCapabilities(c *capability.List) error { @@ -236,6 +260,11 @@ var ( ) func (s *rpSession) ReceivePack(ctx context.Context, req *packp.ReferenceUpdateRequest) (*packp.ReportStatus, error) { + start := time.Now() + defer func() { + trace.Performance.Printf("performance: %.9f s: receive_pack", time.Since(start).Seconds()) + }() + if s.caps == nil { s.caps = capability.NewList() if err := s.setSupportedCapabilities(s.caps); err != nil { diff --git a/plumbing/transport/server/server_test.go b/plumbing/server/server_test.go similarity index 50% rename from plumbing/transport/server/server_test.go rename to plumbing/server/server_test.go index 24de099ff..fa82eb5ad 100644 --- a/plumbing/transport/server/server_test.go +++ b/plumbing/server/server_test.go @@ -1,24 +1,18 @@ package server_test import ( - "testing" - - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/plumbing/transport/client" - "github.com/go-git/go-git/v5/plumbing/transport/server" - "github.com/go-git/go-git/v5/plumbing/transport/test" - "github.com/go-git/go-git/v5/storage/filesystem" - "github.com/go-git/go-git/v5/storage/memory" + "github.com/jesseduffield/go-git/v5/internal/transport/test" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/server" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/plumbing/transport/file" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/storage/memory" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) -func Test(t *testing.T) { TestingT(t) } - type BaseSuite struct { - fixtures.Suite test.ReceivePackSuite loader server.MapLoader @@ -27,7 +21,7 @@ type BaseSuite struct { asClient bool } -func (s *BaseSuite) SetUpSuite(c *C) { +func (s *BaseSuite) SetupSuite() { s.loader = server.MapLoader{} if s.asClient { s.client = server.NewClient(s.loader) @@ -35,30 +29,31 @@ func (s *BaseSuite) SetUpSuite(c *C) { s.client = server.NewServer(s.loader) } - s.clientBackup = client.Protocols["file"] - client.Protocols["file"] = s.client + s.clientBackup = file.DefaultClient + transport.Register("file", s.client) } -func (s *BaseSuite) TearDownSuite(c *C) { +func (s *BaseSuite) TearDownSuite() { if s.clientBackup == nil { - delete(client.Protocols, "file") + transport.Unregister("file") } else { - client.Protocols["file"] = s.clientBackup + transport.Register("file", s.clientBackup) } + fixtures.Clean() } -func (s *BaseSuite) prepareRepositories(c *C) { +func (s *BaseSuite) prepareRepositories() { var err error fs := fixtures.Basic().One().DotGit() s.Endpoint, err = transport.NewEndpoint(fs.Root()) - c.Assert(err, IsNil) + s.Nil(err) s.loader[s.Endpoint.String()] = filesystem.NewStorage(fs, cache.NewObjectLRUDefault()) s.EmptyEndpoint, err = transport.NewEndpoint("/empty.git") - c.Assert(err, IsNil) + s.Nil(err) s.loader[s.EmptyEndpoint.String()] = memory.NewStorage() s.NonExistentEndpoint, err = transport.NewEndpoint("/non-existent.git") - c.Assert(err, IsNil) + s.Nil(err) } diff --git a/plumbing/server/upload_pack_test.go b/plumbing/server/upload_pack_test.go new file mode 100644 index 000000000..a581535d6 --- /dev/null +++ b/plumbing/server/upload_pack_test.go @@ -0,0 +1,55 @@ +package server_test + +import ( + "testing" + + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/stretchr/testify/suite" +) + +func TestUploadPackSuite(t *testing.T) { + suite.Run(t, new(UploadPackSuite)) +} + +type UploadPackSuite struct { + BaseSuite +} + +func (s *UploadPackSuite) SetupSuite() { + s.BaseSuite.SetupSuite() + s.Client = s.client +} + +func (s *UploadPackSuite) SetupTest() { + s.prepareRepositories() +} + +// Overwritten, server returns error earlier. +func (s *UploadPackSuite) TestAdvertisedReferencesNotExists() { + r, err := s.Client.NewUploadPackSession(s.NonExistentEndpoint, s.EmptyAuth) + s.ErrorIs(err, transport.ErrRepositoryNotFound) + s.Nil(r) +} + +func (s *UploadPackSuite) TestUploadPackWithContext() { + s.T().Skip("UploadPack cannot be canceled on server") +} + +func TestClientLikeUploadPackSuite(t *testing.T) { + suite.Run(t, new(ClientLikeUploadPackSuite)) +} + +// Tests server with `asClient = true`. This is recommended when using a server +// registered directly with `transport.Register`. +type ClientLikeUploadPackSuite struct { + UploadPackSuite +} + +func (s *ClientLikeUploadPackSuite) SetupSuite() { + s.asClient = true + s.UploadPackSuite.SetupSuite() +} + +func (s *ClientLikeUploadPackSuite) TestAdvertisedReferencesEmpty() { + s.UploadPackSuite.TestAdvertisedReferencesEmpty() +} diff --git a/plumbing/serverinfo/serverinfo.go b/plumbing/serverinfo/serverinfo.go index d7ea7ef06..fb0f5eaa6 100644 --- a/plumbing/serverinfo/serverinfo.go +++ b/plumbing/serverinfo/serverinfo.go @@ -4,12 +4,12 @@ import ( "fmt" "github.com/go-git/go-billy/v5" - "github.com/go-git/go-git/v5" - "github.com/go-git/go-git/v5/internal/reference" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage" + "github.com/jesseduffield/go-git/v5" + "github.com/jesseduffield/go-git/v5/internal/reference" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage" ) // UpdateServerInfo updates the server info files in the repository. diff --git a/plumbing/serverinfo/serverinfo_test.go b/plumbing/serverinfo/serverinfo_test.go index 251746b6d..b840b3ff3 100644 --- a/plumbing/serverinfo/serverinfo_test.go +++ b/plumbing/serverinfo/serverinfo_test.go @@ -8,39 +8,41 @@ import ( "github.com/go-git/go-billy/v5" "github.com/go-git/go-billy/v5/memfs" fixtures "github.com/go-git/go-git-fixtures/v4" - "github.com/go-git/go-git/v5" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage" - "github.com/go-git/go-git/v5/storage/memory" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/suite" ) -type ServerInfoSuite struct{} - -var _ = Suite(&ServerInfoSuite{}) +type ServerInfoSuite struct { + suite.Suite +} -func Test(t *testing.T) { TestingT(t) } +func TestServerInfoSuite(t *testing.T) { + suite.Run(t, new(ServerInfoSuite)) +} -func (s *ServerInfoSuite) TestUpdateServerInfoInit(c *C) { +func (s *ServerInfoSuite) TestUpdateServerInfoInit() { fs := memfs.New() st := memory.NewStorage() r, err := git.Init(st, fs) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) err = UpdateServerInfo(st, fs) - c.Assert(err, IsNil) + s.NoError(err) } -func assertInfoRefs(c *C, st storage.Storer, fs billy.Filesystem) { +func assertInfoRefs(s *ServerInfoSuite, st storage.Storer, fs billy.Filesystem) { refsFile, err := fs.Open("info/refs") - c.Assert(err, IsNil) + s.NoError(err) defer refsFile.Close() bts, err := io.ReadAll(refsFile) - c.Assert(err, IsNil) + s.NoError(err) localRefs := make(map[plumbing.ReferenceName]plumbing.Hash) for _, line := range strings.Split(string(bts), "\n") { @@ -48,14 +50,14 @@ func assertInfoRefs(c *C, st storage.Storer, fs billy.Filesystem) { continue } parts := strings.Split(line, "\t") - c.Assert(parts, HasLen, 2) + s.Len(parts, 2) hash := plumbing.NewHash(parts[0]) name := plumbing.ReferenceName(parts[1]) localRefs[name] = hash } refs, err := st.IterReferences() - c.Assert(err, IsNil) + s.NoError(err) err = refs.ForEach(func(ref *plumbing.Reference) error { name := ref.Name() @@ -66,48 +68,48 @@ func assertInfoRefs(c *C, st storage.Storer, fs billy.Filesystem) { return nil } ref, err := st.Reference(ref.Target()) - c.Assert(err, IsNil) + s.NoError(err) hash = ref.Hash() fallthrough case plumbing.HashReference: h, ok := localRefs[name] - c.Assert(ok, Equals, true) - c.Assert(h, Equals, hash) + s.True(ok) + s.Equal(hash, h) if name.IsTag() { tag, err := object.GetTag(st, hash) if err == nil { t, ok := localRefs[name+"^{}"] - c.Assert(ok, Equals, true) - c.Assert(t, Equals, tag.Target) + s.True(ok) + s.Equal(tag.Target, t) } } } return nil }) - c.Assert(err, IsNil) + s.NoError(err) } -func assertObjectPacks(c *C, st storage.Storer, fs billy.Filesystem) { +func assertObjectPacks(s *ServerInfoSuite, st storage.Storer, fs billy.Filesystem) { infoPacks, err := fs.Open("objects/info/packs") - c.Assert(err, IsNil) + s.NoError(err) defer infoPacks.Close() bts, err := io.ReadAll(infoPacks) - c.Assert(err, IsNil) + s.NoError(err) pos, ok := st.(storer.PackedObjectStorer) - c.Assert(ok, Equals, true) + s.True(ok) localPacks := make(map[string]struct{}) packs, err := pos.ObjectPacks() - c.Assert(err, IsNil) + s.NoError(err) for _, line := range strings.Split(string(bts), "\n") { if line == "" { continue } parts := strings.Split(line, " ") - c.Assert(parts, HasLen, 2) + s.Len(parts, 2) pack := strings.TrimPrefix(parts[1], "pack-") pack = strings.TrimSuffix(pack, ".pack") localPacks[pack] = struct{}{} @@ -115,72 +117,72 @@ func assertObjectPacks(c *C, st storage.Storer, fs billy.Filesystem) { for _, p := range packs { _, ok := localPacks[p.String()] - c.Assert(ok, Equals, true) + s.True(ok) } } -func (s *ServerInfoSuite) TestUpdateServerInfoTags(c *C) { +func (s *ServerInfoSuite) TestUpdateServerInfoTags() { fs := memfs.New() st := memory.NewStorage() r, err := git.Clone(st, fs, &git.CloneOptions{ URL: fixtures.ByURL("https://github.com/git-fixtures/tags.git").One().URL, }) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) err = UpdateServerInfo(st, fs) - c.Assert(err, IsNil) + s.NoError(err) - assertInfoRefs(c, st, fs) - assertObjectPacks(c, st, fs) + assertInfoRefs(s, st, fs) + assertObjectPacks(s, st, fs) } -func (s *ServerInfoSuite) TestUpdateServerInfoBasic(c *C) { +func (s *ServerInfoSuite) TestUpdateServerInfoBasic() { fs := memfs.New() st := memory.NewStorage() r, err := git.Clone(st, fs, &git.CloneOptions{ URL: fixtures.Basic().One().URL, }) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) err = UpdateServerInfo(st, fs) - c.Assert(err, IsNil) + s.NoError(err) - assertInfoRefs(c, st, fs) - assertObjectPacks(c, st, fs) + assertInfoRefs(s, st, fs) + assertObjectPacks(s, st, fs) } -func (s *ServerInfoSuite) TestUpdateServerInfoBasicChange(c *C) { +func (s *ServerInfoSuite) TestUpdateServerInfoBasicChange() { fs := memfs.New() st := memory.NewStorage() r, err := git.Clone(st, fs, &git.CloneOptions{ URL: fixtures.Basic().One().URL, }) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) err = UpdateServerInfo(st, fs) - c.Assert(err, IsNil) + s.NoError(err) - assertInfoRefs(c, st, fs) - assertObjectPacks(c, st, fs) + assertInfoRefs(s, st, fs) + assertObjectPacks(s, st, fs) head, err := r.Head() - c.Assert(err, IsNil) + s.NoError(err) ref := plumbing.NewHashReference("refs/heads/my-branch", head.Hash()) err = r.Storer.SetReference(ref) - c.Assert(err, IsNil) + s.NoError(err) _, err = r.CreateTag("test-tag", head.Hash(), &git.CreateTagOptions{ Message: "test-tag", }) - c.Assert(err, IsNil) + s.NoError(err) err = UpdateServerInfo(st, fs) - c.Assert(err, IsNil) + s.NoError(err) - assertInfoRefs(c, st, fs) - assertObjectPacks(c, st, fs) + assertInfoRefs(s, st, fs) + assertObjectPacks(s, st, fs) } diff --git a/plumbing/storer/index.go b/plumbing/storer/index.go index 33113949b..0cb5287d6 100644 --- a/plumbing/storer/index.go +++ b/plumbing/storer/index.go @@ -1,6 +1,6 @@ package storer -import "github.com/go-git/go-git/v5/plumbing/format/index" +import "github.com/jesseduffield/go-git/v5/plumbing/format/index" // IndexStorer generic storage of index.Index type IndexStorer interface { diff --git a/plumbing/storer/object.go b/plumbing/storer/object.go index 126b3742d..6de7cde7b 100644 --- a/plumbing/storer/object.go +++ b/plumbing/storer/object.go @@ -5,7 +5,7 @@ import ( "io" "time" - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" ) var ( @@ -15,12 +15,15 @@ var ( // EncodedObjectStorer generic storage of objects type EncodedObjectStorer interface { + // RawObjectWriter returns a io.WriterCloser to write the object without the + // need of providing a plumbing.EncodedObject. + RawObjectWriter(typ plumbing.ObjectType, sz int64) (w io.WriteCloser, err error) // NewEncodedObject returns a new plumbing.EncodedObject, the real type // of the object can be a custom implementation or the default one, // plumbing.MemoryObject. NewEncodedObject() plumbing.EncodedObject // SetEncodedObject saves an object into the storage, the object should - // be create with the NewEncodedObject, method, and file if the type is + // be created with the NewEncodedObject, method, and file if the type is // not supported. SetEncodedObject(plumbing.EncodedObject) (plumbing.Hash, error) // EncodedObject gets an object by hash with the given diff --git a/plumbing/storer/object_test.go b/plumbing/storer/object_test.go index f2e6a5e05..ccc5a827f 100644 --- a/plumbing/storer/object_test.go +++ b/plumbing/storer/object_test.go @@ -2,23 +2,24 @@ package storer import ( "fmt" + "io" "testing" - "github.com/go-git/go-git/v5/plumbing" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } - type ObjectSuite struct { + suite.Suite Objects []plumbing.EncodedObject Hash []plumbing.Hash } -var _ = Suite(&ObjectSuite{}) +func TestObjectSuite(t *testing.T) { + suite.Run(t, new(ObjectSuite)) +} -func (s *ObjectSuite) SetUpSuite(c *C) { +func (s *ObjectSuite) SetupSuite() { s.Objects = []plumbing.EncodedObject{ s.buildObject([]byte("foo")), s.buildObject([]byte("bar")), @@ -29,7 +30,7 @@ func (s *ObjectSuite) SetUpSuite(c *C) { } } -func (s *ObjectSuite) TestMultiObjectIterNext(c *C) { +func (s *ObjectSuite) TestMultiObjectIterNext() { expected := []plumbing.EncodedObject{ &plumbing.MemoryObject{}, &plumbing.MemoryObject{}, @@ -47,7 +48,7 @@ func (s *ObjectSuite) TestMultiObjectIterNext(c *C) { var i int iter.ForEach(func(o plumbing.EncodedObject) error { - c.Assert(o, Equals, expected[i]) + s.Equal(expected[i], o) i++ return nil }) @@ -62,54 +63,54 @@ func (s *ObjectSuite) buildObject(content []byte) plumbing.EncodedObject { return o } -func (s *ObjectSuite) TestObjectLookupIter(c *C) { +func (s *ObjectSuite) TestObjectLookupIter() { var count int storage := &MockObjectStorage{s.Objects} i := NewEncodedObjectLookupIter(storage, plumbing.CommitObject, s.Hash) err := i.ForEach(func(o plumbing.EncodedObject) error { - c.Assert(o, NotNil) - c.Assert(o.Hash().String(), Equals, s.Hash[count].String()) + s.NotNil(o) + s.Equal(s.Hash[count].String(), o.Hash().String()) count++ return nil }) - c.Assert(err, IsNil) + s.NoError(err) i.Close() } -func (s *ObjectSuite) TestObjectSliceIter(c *C) { +func (s *ObjectSuite) TestObjectSliceIter() { var count int i := NewEncodedObjectSliceIter(s.Objects) err := i.ForEach(func(o plumbing.EncodedObject) error { - c.Assert(o, NotNil) - c.Assert(o.Hash().String(), Equals, s.Hash[count].String()) + s.NotNil(o) + s.Equal(s.Hash[count].String(), o.Hash().String()) count++ return nil }) - c.Assert(count, Equals, 2) - c.Assert(err, IsNil) - c.Assert(i.series, HasLen, 0) + s.Equal(2, count) + s.NoError(err) + s.Len(i.series, 0) } -func (s *ObjectSuite) TestObjectSliceIterStop(c *C) { +func (s *ObjectSuite) TestObjectSliceIterStop() { i := NewEncodedObjectSliceIter(s.Objects) var count = 0 err := i.ForEach(func(o plumbing.EncodedObject) error { - c.Assert(o, NotNil) - c.Assert(o.Hash().String(), Equals, s.Hash[count].String()) + s.NotNil(o) + s.Equal(s.Hash[count].String(), o.Hash().String()) count++ return ErrStop }) - c.Assert(count, Equals, 1) - c.Assert(err, IsNil) + s.Equal(1, count) + s.NoError(err) } -func (s *ObjectSuite) TestObjectSliceIterError(c *C) { +func (s *ObjectSuite) TestObjectSliceIterError() { i := NewEncodedObjectSliceIter([]plumbing.EncodedObject{ s.buildObject([]byte("foo")), }) @@ -118,13 +119,17 @@ func (s *ObjectSuite) TestObjectSliceIterError(c *C) { return fmt.Errorf("a random error") }) - c.Assert(err, NotNil) + s.NotNil(err) } type MockObjectStorage struct { db []plumbing.EncodedObject } +func (o *MockObjectStorage) RawObjectWriter(typ plumbing.ObjectType, sz int64) (w io.WriteCloser, err error) { + return nil, nil +} + func (o *MockObjectStorage) NewEncodedObject() plumbing.EncodedObject { return nil } diff --git a/plumbing/storer/reference.go b/plumbing/storer/reference.go index 1d74ef3c6..3d0699d77 100644 --- a/plumbing/storer/reference.go +++ b/plumbing/storer/reference.go @@ -4,7 +4,7 @@ import ( "errors" "io" - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" ) const MaxResolveRecursion = 1024 diff --git a/plumbing/storer/reference_test.go b/plumbing/storer/reference_test.go index 7a4d8b483..801b52a53 100644 --- a/plumbing/storer/reference_test.go +++ b/plumbing/storer/reference_test.go @@ -3,17 +3,21 @@ package storer import ( "errors" "io" + "testing" - "github.com/go-git/go-git/v5/plumbing" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/stretchr/testify/suite" ) -type ReferenceSuite struct{} +type ReferenceSuite struct { + suite.Suite +} -var _ = Suite(&ReferenceSuite{}) +func TestReferenceSuite(t *testing.T) { + suite.Run(t, new(ReferenceSuite)) +} -func (s *ReferenceSuite) TestReferenceSliceIterNext(c *C) { +func (s *ReferenceSuite) TestReferenceSliceIterNext() { slice := []*plumbing.Reference{ plumbing.NewReferenceFromStrings("foo", "foo"), plumbing.NewReferenceFromStrings("bar", "bar"), @@ -21,19 +25,19 @@ func (s *ReferenceSuite) TestReferenceSliceIterNext(c *C) { i := NewReferenceSliceIter(slice) foo, err := i.Next() - c.Assert(err, IsNil) - c.Assert(foo == slice[0], Equals, true) + s.NoError(err) + s.True(foo == slice[0]) bar, err := i.Next() - c.Assert(err, IsNil) - c.Assert(bar == slice[1], Equals, true) + s.NoError(err) + s.True(bar == slice[1]) empty, err := i.Next() - c.Assert(err, Equals, io.EOF) - c.Assert(empty, IsNil) + s.ErrorIs(err, io.EOF) + s.Nil(empty) } -func (s *ReferenceSuite) TestReferenceSliceIterForEach(c *C) { +func (s *ReferenceSuite) TestReferenceSliceIterForEach() { slice := []*plumbing.Reference{ plumbing.NewReferenceFromStrings("foo", "foo"), plumbing.NewReferenceFromStrings("bar", "bar"), @@ -42,15 +46,15 @@ func (s *ReferenceSuite) TestReferenceSliceIterForEach(c *C) { i := NewReferenceSliceIter(slice) var count int i.ForEach(func(r *plumbing.Reference) error { - c.Assert(r == slice[count], Equals, true) + s.True(r == slice[count]) count++ return nil }) - c.Assert(count, Equals, 2) + s.Equal(2, count) } -func (s *ReferenceSuite) TestReferenceSliceIterForEachError(c *C) { +func (s *ReferenceSuite) TestReferenceSliceIterForEachError() { slice := []*plumbing.Reference{ plumbing.NewReferenceFromStrings("foo", "foo"), plumbing.NewReferenceFromStrings("bar", "bar"), @@ -60,7 +64,7 @@ func (s *ReferenceSuite) TestReferenceSliceIterForEachError(c *C) { var count int exampleErr := errors.New("SOME ERROR") err := i.ForEach(func(r *plumbing.Reference) error { - c.Assert(r == slice[count], Equals, true) + s.True(r == slice[count]) count++ if count == 2 { return exampleErr @@ -69,11 +73,11 @@ func (s *ReferenceSuite) TestReferenceSliceIterForEachError(c *C) { return nil }) - c.Assert(err, Equals, exampleErr) - c.Assert(count, Equals, 2) + s.ErrorIs(err, exampleErr) + s.Equal(2, count) } -func (s *ReferenceSuite) TestReferenceSliceIterForEachStop(c *C) { +func (s *ReferenceSuite) TestReferenceSliceIterForEachStop() { slice := []*plumbing.Reference{ plumbing.NewReferenceFromStrings("foo", "foo"), plumbing.NewReferenceFromStrings("bar", "bar"), @@ -83,15 +87,15 @@ func (s *ReferenceSuite) TestReferenceSliceIterForEachStop(c *C) { var count int i.ForEach(func(r *plumbing.Reference) error { - c.Assert(r == slice[count], Equals, true) + s.True(r == slice[count]) count++ return ErrStop }) - c.Assert(count, Equals, 1) + s.Equal(1, count) } -func (s *ReferenceSuite) TestReferenceFilteredIterNext(c *C) { +func (s *ReferenceSuite) TestReferenceFilteredIterNext() { slice := []*plumbing.Reference{ plumbing.NewReferenceFromStrings("foo", "foo"), plumbing.NewReferenceFromStrings("bar", "bar"), @@ -101,16 +105,16 @@ func (s *ReferenceSuite) TestReferenceFilteredIterNext(c *C) { return r.Name() == "bar" }, NewReferenceSliceIter(slice)) foo, err := i.Next() - c.Assert(err, IsNil) - c.Assert(foo == slice[0], Equals, false) - c.Assert(foo == slice[1], Equals, true) + s.NoError(err) + s.False(foo == slice[0]) + s.True(foo == slice[1]) empty, err := i.Next() - c.Assert(err, Equals, io.EOF) - c.Assert(empty, IsNil) + s.ErrorIs(err, io.EOF) + s.Nil(empty) } -func (s *ReferenceSuite) TestReferenceFilteredIterForEach(c *C) { +func (s *ReferenceSuite) TestReferenceFilteredIterForEach() { slice := []*plumbing.Reference{ plumbing.NewReferenceFromStrings("foo", "foo"), plumbing.NewReferenceFromStrings("bar", "bar"), @@ -121,15 +125,15 @@ func (s *ReferenceSuite) TestReferenceFilteredIterForEach(c *C) { }, NewReferenceSliceIter(slice)) var count int i.ForEach(func(r *plumbing.Reference) error { - c.Assert(r == slice[1], Equals, true) + s.True(r == slice[1]) count++ return nil }) - c.Assert(count, Equals, 1) + s.Equal(1, count) } -func (s *ReferenceSuite) TestReferenceFilteredIterError(c *C) { +func (s *ReferenceSuite) TestReferenceFilteredIterError() { slice := []*plumbing.Reference{ plumbing.NewReferenceFromStrings("foo", "foo"), plumbing.NewReferenceFromStrings("bar", "bar"), @@ -141,7 +145,7 @@ func (s *ReferenceSuite) TestReferenceFilteredIterError(c *C) { var count int exampleErr := errors.New("SOME ERROR") err := i.ForEach(func(r *plumbing.Reference) error { - c.Assert(r == slice[1], Equals, true) + s.True(r == slice[1]) count++ if count == 1 { return exampleErr @@ -150,11 +154,11 @@ func (s *ReferenceSuite) TestReferenceFilteredIterError(c *C) { return nil }) - c.Assert(err, Equals, exampleErr) - c.Assert(count, Equals, 1) + s.ErrorIs(err, exampleErr) + s.Equal(1, count) } -func (s *ReferenceSuite) TestReferenceFilteredIterForEachStop(c *C) { +func (s *ReferenceSuite) TestReferenceFilteredIterForEachStop() { slice := []*plumbing.Reference{ plumbing.NewReferenceFromStrings("foo", "foo"), plumbing.NewReferenceFromStrings("bar", "bar"), @@ -166,15 +170,15 @@ func (s *ReferenceSuite) TestReferenceFilteredIterForEachStop(c *C) { var count int i.ForEach(func(r *plumbing.Reference) error { - c.Assert(r == slice[1], Equals, true) + s.True(r == slice[1]) count++ return ErrStop }) - c.Assert(count, Equals, 1) + s.Equal(1, count) } -func (s *ReferenceSuite) TestMultiReferenceIterForEach(c *C) { +func (s *ReferenceSuite) TestMultiReferenceIterForEach() { i := NewMultiReferenceIter( []ReferenceIter{ NewReferenceSliceIter([]*plumbing.Reference{ @@ -192,7 +196,7 @@ func (s *ReferenceSuite) TestMultiReferenceIterForEach(c *C) { return nil }) - c.Assert(err, IsNil) - c.Assert(result, HasLen, 2) - c.Assert(result, DeepEquals, []string{"foo", "bar"}) + s.NoError(err) + s.Len(result, 2) + s.Equal([]string{"foo", "bar"}, result) } diff --git a/plumbing/storer/shallow.go b/plumbing/storer/shallow.go index 39ef5ea5c..409ae4d62 100644 --- a/plumbing/storer/shallow.go +++ b/plumbing/storer/shallow.go @@ -1,6 +1,6 @@ package storer -import "github.com/go-git/go-git/v5/plumbing" +import "github.com/jesseduffield/go-git/v5/plumbing" // ShallowStorer is a storage of references to shallow commits by hash, // meaning that these commits have missing parents because of a shallow fetch. diff --git a/plumbing/tag.go b/plumbing/tag.go new file mode 100644 index 000000000..cde8f4d90 --- /dev/null +++ b/plumbing/tag.go @@ -0,0 +1,17 @@ +package plumbing + +// TagMode defines how the tags will be fetched from the remote repository. +type TagMode int + +const ( + InvalidTagMode TagMode = iota + // TagFollowing any tag that points into the histories being fetched is also + // fetched. TagFollowing requires a server with `include-tag` capability + // in order to fetch the annotated tags objects. + TagFollowing + // AllTags fetch all tags from the remote (i.e., fetch remote tags + // refs/tags/* into local tags with the same name) + AllTags + // NoTags fetch no tags from the remote at all + NoTags +) diff --git a/plumbing/transport/client/client.go b/plumbing/transport/client/client.go deleted file mode 100644 index 1948c2301..000000000 --- a/plumbing/transport/client/client.go +++ /dev/null @@ -1,51 +0,0 @@ -// Package client contains helper function to deal with the different client -// protocols. -package client - -import ( - "fmt" - - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/plumbing/transport/file" - "github.com/go-git/go-git/v5/plumbing/transport/git" - "github.com/go-git/go-git/v5/plumbing/transport/http" - "github.com/go-git/go-git/v5/plumbing/transport/ssh" -) - -// Protocols are the protocols supported by default. -var Protocols = map[string]transport.Transport{ - "http": http.DefaultClient, - "https": http.DefaultClient, - "ssh": ssh.DefaultClient, - "git": git.DefaultClient, - "file": file.DefaultClient, -} - -// InstallProtocol adds or modifies an existing protocol. -func InstallProtocol(scheme string, c transport.Transport) { - if c == nil { - delete(Protocols, scheme) - return - } - - Protocols[scheme] = c -} - -// NewClient returns the appropriate client among of the set of known protocols: -// http://, https://, ssh:// and file://. -// See `InstallProtocol` to add or modify protocols. -func NewClient(endpoint *transport.Endpoint) (transport.Transport, error) { - return getTransport(endpoint) -} - -func getTransport(endpoint *transport.Endpoint) (transport.Transport, error) { - f, ok := Protocols[endpoint.Protocol] - if !ok { - return nil, fmt.Errorf("unsupported scheme %q", endpoint.Protocol) - } - - if f == nil { - return nil, fmt.Errorf("malformed client for scheme %q, client is defined as nil", endpoint.Protocol) - } - return f, nil -} diff --git a/plumbing/transport/client/client_test.go b/plumbing/transport/client/client_test.go deleted file mode 100644 index 92db525a5..000000000 --- a/plumbing/transport/client/client_test.go +++ /dev/null @@ -1,69 +0,0 @@ -package client - -import ( - "net/http" - "testing" - - "github.com/go-git/go-git/v5/plumbing/transport" - - . "gopkg.in/check.v1" -) - -func Test(t *testing.T) { TestingT(t) } - -type ClientSuite struct{} - -var _ = Suite(&ClientSuite{}) - -func (s *ClientSuite) TestNewClientSSH(c *C) { - e, err := transport.NewEndpoint("ssh://github.com/src-d/go-git") - c.Assert(err, IsNil) - - output, err := NewClient(e) - c.Assert(err, IsNil) - c.Assert(output, NotNil) -} - -func (s *ClientSuite) TestNewClientUnknown(c *C) { - e, err := transport.NewEndpoint("unknown://github.com/src-d/go-git") - c.Assert(err, IsNil) - - _, err = NewClient(e) - c.Assert(err, NotNil) -} - -func (s *ClientSuite) TestNewClientNil(c *C) { - Protocols["newscheme"] = nil - e, err := transport.NewEndpoint("newscheme://github.com/src-d/go-git") - c.Assert(err, IsNil) - - _, err = NewClient(e) - c.Assert(err, NotNil) -} - -func (s *ClientSuite) TestInstallProtocol(c *C) { - InstallProtocol("newscheme", &dummyClient{}) - c.Assert(Protocols["newscheme"], NotNil) -} - -func (s *ClientSuite) TestInstallProtocolNilValue(c *C) { - InstallProtocol("newscheme", &dummyClient{}) - InstallProtocol("newscheme", nil) - - _, ok := Protocols["newscheme"] - c.Assert(ok, Equals, false) -} - -type dummyClient struct { - *http.Client -} - -func (*dummyClient) NewUploadPackSession(*transport.Endpoint, transport.AuthMethod) ( - transport.UploadPackSession, error) { - return nil, nil -} - -func (*dummyClient) NewReceivePackSession(*transport.Endpoint, transport.AuthMethod) ( - transport.ReceivePackSession, error) { - return nil, nil -} diff --git a/plumbing/transport/client/example_test.go b/plumbing/transport/client/example_test.go deleted file mode 100644 index e1b388764..000000000 --- a/plumbing/transport/client/example_test.go +++ /dev/null @@ -1,21 +0,0 @@ -package client_test - -import ( - "crypto/tls" - "net/http" - - "github.com/go-git/go-git/v5/plumbing/transport/client" - githttp "github.com/go-git/go-git/v5/plumbing/transport/http" -) - -func ExampleInstallProtocol() { - // Create custom net/http client that. - httpClient := &http.Client{ - Transport: &http.Transport{ - TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, - }, - } - - // Install it as default client for https URLs. - client.InstallProtocol("https", githttp.NewClient(httpClient)) -} diff --git a/plumbing/transport/common.go b/plumbing/transport/common.go index fae1aa98c..02c21874b 100644 --- a/plumbing/transport/common.go +++ b/plumbing/transport/common.go @@ -1,325 +1,497 @@ -// Package transport includes the implementation for different transport -// protocols. +// Package transport implements the git pack protocol with a pluggable +// This is a low-level package to implement new transports. Use a concrete +// implementation instead (e.g. http, file, ssh). // -// `Client` can be used to fetch and send packfiles to a git server. -// The `client` package provides higher level functions to instantiate the -// appropriate `Client` based on the repository URL. -// -// go-git supports HTTP and SSH (see `Protocols`), but you can also install -// your own protocols (see the `client` package). -// -// Each protocol has its own implementation of `Client`, but you should -// generally not use them directly, use `client.NewClient` instead. +// A simple example of usage can be found in the file package. package transport import ( - "bytes" + "bufio" "context" "errors" "fmt" "io" - "net/url" - "path/filepath" - "strconv" + "regexp" "strings" + "time" + + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/sideband" + "github.com/jesseduffield/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/utils/trace" +) - giturl "github.com/go-git/go-git/v5/internal/url" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/protocol/packp" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" +const ( + readErrorSecondsTimeout = 10 ) var ( - ErrRepositoryNotFound = errors.New("repository not found") - ErrEmptyRemoteRepository = errors.New("remote repository is empty") - ErrAuthenticationRequired = errors.New("authentication required") - ErrAuthorizationFailed = errors.New("authorization failed") - ErrEmptyUploadPackRequest = errors.New("empty git-upload-pack given") - ErrInvalidAuthMethod = errors.New("invalid auth method") - ErrAlreadyConnected = errors.New("session already established") + ErrTimeoutExceeded = errors.New("timeout exceeded") + // stdErrSkipPattern is used for skipping lines from a command's stderr output. + // Any line matching this pattern will be skipped from further + // processing and not be returned to calling code. + stdErrSkipPattern = regexp.MustCompile("^remote:( =*){0,1}$") ) -const ( - UploadPackServiceName = "git-upload-pack" - ReceivePackServiceName = "git-receive-pack" -) +// Commander creates Command instances. This is the main entry point for +// transport implementations. +type Commander interface { + // Command creates a new Command for the given git command and + // endpoint. cmd can be git-upload-pack or git-receive-pack. An + // error should be returned if the endpoint is not supported or the + // command cannot be created (e.g. binary does not exist, connection + // cannot be established). + Command(cmd string, ep *Endpoint, auth AuthMethod) (Command, error) +} -// Transport can initiate git-upload-pack and git-receive-pack processes. -// It is implemented both by the client and the server, making this a RPC. -type Transport interface { - // NewUploadPackSession starts a git-upload-pack session for an endpoint. - NewUploadPackSession(*Endpoint, AuthMethod) (UploadPackSession, error) - // NewReceivePackSession starts a git-receive-pack session for an endpoint. - NewReceivePackSession(*Endpoint, AuthMethod) (ReceivePackSession, error) +// Command is used for a single command execution. +// This interface is modeled after exec.Cmd and ssh.Session in the standard +// library. +type Command interface { + // StderrPipe returns a pipe that will be connected to the command's + // standard error when the command starts. It should not be called after + // Start. + StderrPipe() (io.Reader, error) + // StdinPipe returns a pipe that will be connected to the command's + // standard input when the command starts. It should not be called after + // Start. The pipe should be closed when no more input is expected. + StdinPipe() (io.WriteCloser, error) + // StdoutPipe returns a pipe that will be connected to the command's + // standard output when the command starts. It should not be called after + // Start. + StdoutPipe() (io.Reader, error) + // Start starts the specified command. It does not wait for it to + // complete. + Start() error + // Close closes the command and releases any resources used by it. It + // will block until the command exits. + Close() error } -type Session interface { - // AdvertisedReferences retrieves the advertised references for a - // repository. - // If the repository does not exist, returns ErrRepositoryNotFound. - // If the repository exists, but is empty, returns ErrEmptyRemoteRepository. - AdvertisedReferences() (*packp.AdvRefs, error) - // AdvertisedReferencesContext retrieves the advertised references for a - // repository. - // If the repository does not exist, returns ErrRepositoryNotFound. - // If the repository exists, but is empty, returns ErrEmptyRemoteRepository. - AdvertisedReferencesContext(context.Context) (*packp.AdvRefs, error) - io.Closer +// CommandKiller expands the Command interface, enabling it for being killed. +type CommandKiller interface { + // Kill and close the session whatever the state it is. It will block until + // the command is terminated. + Kill() error } -type AuthMethod interface { - fmt.Stringer - Name() string +type client struct { + cmdr Commander } -// UploadPackSession represents a git-upload-pack session. -// A git-upload-pack session has two steps: reference discovery -// (AdvertisedReferences) and uploading pack (UploadPack). -type UploadPackSession interface { - Session - // UploadPack takes a git-upload-pack request and returns a response, - // including a packfile. Don't be confused by terminology, the client - // side of a git-upload-pack is called git-fetch-pack, although here - // the same interface is used to make it RPC-like. - UploadPack(context.Context, *packp.UploadPackRequest) (*packp.UploadPackResponse, error) +// NewClient creates a new client using the given Commander. +func NewClient(runner Commander) Transport { + return &client{runner} } -// ReceivePackSession represents a git-receive-pack session. -// A git-receive-pack session has two steps: reference discovery -// (AdvertisedReferences) and receiving pack (ReceivePack). -// In that order. -type ReceivePackSession interface { - Session - // ReceivePack sends an update references request and a packfile - // reader and returns a ReportStatus and error. Don't be confused by - // terminology, the client side of a git-receive-pack is called - // git-send-pack, although here the same interface is used to make it - // RPC-like. - ReceivePack(context.Context, *packp.ReferenceUpdateRequest) (*packp.ReportStatus, error) +// NewUploadPackSession creates a new UploadPackSession. +func (c *client) NewUploadPackSession(ep *Endpoint, auth AuthMethod) ( + UploadPackSession, error, +) { + return c.newSession(UploadPackServiceName, ep, auth) } -// Endpoint represents a Git URL in any supported protocol. -type Endpoint struct { - // Protocol is the protocol of the endpoint (e.g. git, https, file). - Protocol string - // User is the user. - User string - // Password is the password. - Password string - // Host is the host. - Host string - // Port is the port to connect, if 0 the default port for the given protocol - // will be used. - Port int - // Path is the repository path. - Path string - // InsecureSkipTLS skips ssl verify if protocol is https - InsecureSkipTLS bool - // CaBundle specify additional ca bundle with system cert pool - CaBundle []byte - // Proxy provides info required for connecting to a proxy. - Proxy ProxyOptions +// NewReceivePackSession creates a new ReceivePackSession. +func (c *client) NewReceivePackSession(ep *Endpoint, auth AuthMethod) ( + ReceivePackSession, error, +) { + return c.newSession(ReceivePackServiceName, ep, auth) } -type ProxyOptions struct { - URL string - Username string - Password string +type session struct { + Stdin io.WriteCloser + Stdout io.Reader + Command Command + + isReceivePack bool + advRefs *packp.AdvRefs + packRun bool + finished bool + firstErrLine chan string } -func (o *ProxyOptions) Validate() error { - if o.URL != "" { - _, err := url.Parse(o.URL) - return err +func (c *client) newSession(s string, ep *Endpoint, auth AuthMethod) (*session, error) { + cmd, err := c.cmdr.Command(s, ep, auth) + if err != nil { + return nil, err } - return nil -} -func (o *ProxyOptions) FullURL() (*url.URL, error) { - proxyURL, err := url.Parse(o.URL) + stdin, err := cmd.StdinPipe() if err != nil { return nil, err } - if o.Username != "" { - if o.Password != "" { - proxyURL.User = url.UserPassword(o.Username, o.Password) - } else { - proxyURL.User = url.User(o.Username) - } + + stdout, err := cmd.StdoutPipe() + if err != nil { + return nil, err + } + + stderr, err := cmd.StderrPipe() + if err != nil { + return nil, err + } + + if err := cmd.Start(); err != nil { + return nil, err } - return proxyURL, nil + + return &session{ + Stdin: stdin, + Stdout: stdout, + Command: cmd, + firstErrLine: c.listenFirstError(stderr), + isReceivePack: s == ReceivePackServiceName, + }, nil } -var defaultPorts = map[string]int{ - "http": 80, - "https": 443, - "git": 9418, - "ssh": 22, +func (c *client) listenFirstError(r io.Reader) chan string { + if r == nil { + return nil + } + + errLine := make(chan string, 1) + go func() { + s := bufio.NewScanner(r) + for { + if s.Scan() { + line := s.Text() + if !stdErrSkipPattern.MatchString(line) { + errLine <- line + break + } + } else { + close(errLine) + break + } + } + + _, _ = io.Copy(io.Discard, r) + }() + + return errLine } -// String returns a string representation of the Git URL. -func (u *Endpoint) String() string { - var buf bytes.Buffer - if u.Protocol != "" { - buf.WriteString(u.Protocol) - buf.WriteByte(':') +func (s *session) AdvertisedReferences() (*packp.AdvRefs, error) { + return s.AdvertisedReferencesContext(context.TODO()) +} + +// AdvertisedReferences retrieves the advertised references from the server. +func (s *session) AdvertisedReferencesContext(ctx context.Context) (*packp.AdvRefs, error) { + if s.advRefs != nil { + return s.advRefs, nil + } + + ar := packp.NewAdvRefs() + if err := ar.Decode(s.StdoutContext(ctx)); err != nil { + if err := s.handleAdvRefDecodeError(err); err != nil { + return nil, err + } } - if u.Protocol != "" || u.Host != "" || u.User != "" || u.Password != "" { - buf.WriteString("//") + // Some servers like jGit, announce capabilities instead of returning an + // packp message with a flush. This verifies that we received a empty + // adv-refs, even it contains capabilities. + if !s.isReceivePack && ar.IsEmpty() { + return nil, ErrEmptyRemoteRepository + } - if u.User != "" || u.Password != "" { - buf.WriteString(url.PathEscape(u.User)) - if u.Password != "" { - buf.WriteByte(':') - buf.WriteString(url.PathEscape(u.Password)) - } + FilterUnsupportedCapabilities(ar.Capabilities) + s.advRefs = ar + return ar, nil +} - buf.WriteByte('@') +func (s *session) handleAdvRefDecodeError(err error) error { + var errLine *pktline.ErrorLine + if errors.As(err, &errLine) { + if isRepoNotFoundError(errLine.Text) { + return ErrRepositoryNotFound } - if u.Host != "" { - buf.WriteString(u.Host) + return errLine + } - if u.Port != 0 { - port, ok := defaultPorts[strings.ToLower(u.Protocol)] - if !ok || ok && port != u.Port { - fmt.Fprintf(&buf, ":%d", u.Port) - } - } + // If repository is not found, we get empty stdout and server writes an + // error to stderr. + if errors.Is(err, packp.ErrEmptyInput) { + // TODO:(v6): handle this error in a better way. + // Instead of checking the stderr output for a specific error message, + // define an ExitError and embed the stderr output and exit (if one + // exists) in the error struct. Just like exec.ExitError. + s.finished = true + if err := s.checkNotFoundError(); err != nil { + return err } + + return io.ErrUnexpectedEOF + } + + // For empty (but existing) repositories, we get empty advertised-references + // message. But valid. That is, it includes at least a flush. + if err == packp.ErrEmptyAdvRefs { + // Empty repositories are valid for git-receive-pack. + if s.isReceivePack { + return nil + } + + if err := s.finish(); err != nil { + return err + } + + return ErrEmptyRemoteRepository } - if u.Path != "" && u.Path[0] != '/' && u.Host != "" { - buf.WriteByte('/') + // Some server sends the errors as normal content (git protocol), so when + // we try to decode it fails, we need to check the content of it, to detect + // not found errors + if uerr, ok := err.(*packp.ErrUnexpectedData); ok { + if isRepoNotFoundError(string(uerr.Data)) { + return ErrRepositoryNotFound + } } - buf.WriteString(u.Path) - return buf.String() + return err } -func NewEndpoint(endpoint string) (*Endpoint, error) { - if e, ok := parseSCPLike(endpoint); ok { - return e, nil +// UploadPack performs a request to the server to fetch a packfile. A reader is +// returned with the packfile content. The reader must be closed after reading. +func (s *session) UploadPack(ctx context.Context, req *packp.UploadPackRequest) (*packp.UploadPackResponse, error) { + start := time.Now() + defer func() { + trace.Performance.Printf("performance: %.9f s: upload_pack", time.Since(start).Seconds()) + }() + + if req.IsEmpty() { + // XXX: IsEmpty means haves are a subset of wants, in that case we have + // everything we asked for. Close the connection and return nil. + if err := s.finish(); err != nil { + return nil, err + } + // TODO:(v6) return nil here + return nil, ErrEmptyUploadPackRequest } - if e, ok := parseFile(endpoint); ok { - return e, nil + if err := req.Validate(); err != nil { + return nil, err } - return parseURL(endpoint) -} + if _, err := s.AdvertisedReferencesContext(ctx); err != nil { + return nil, err + } -func parseURL(endpoint string) (*Endpoint, error) { - u, err := url.Parse(endpoint) - if err != nil { + s.packRun = true + + in := s.StdinContext(ctx) + out := s.StdoutContext(ctx) + + if err := uploadPack(in, out, req); err != nil { return nil, err } - if !u.IsAbs() { - return nil, plumbing.NewPermanentError(fmt.Errorf( - "invalid endpoint: %s", endpoint, - )) + r, err := ioutil.NonEmptyReader(out) + if err == ioutil.ErrEmptyReader { + if c, ok := s.Stdout.(io.Closer); ok { + _ = c.Close() + } + + return nil, ErrEmptyUploadPackRequest } - var user, pass string - if u.User != nil { - user = u.User.Username() - pass, _ = u.User.Password() + if err != nil { + return nil, err } - host := u.Hostname() - if strings.Contains(host, ":") { - // IPv6 address - host = "[" + host + "]" + rc := ioutil.NewReadCloser(r, s) + return DecodeUploadPackResponse(rc, req) +} + +func (s *session) StdinContext(ctx context.Context) io.WriteCloser { + return ioutil.NewWriteCloserOnError( + ioutil.NewContextWriteCloser(ctx, s.Stdin), + s.onError, + ) +} + +func (s *session) StdoutContext(ctx context.Context) io.Reader { + return ioutil.NewReaderOnError( + ioutil.NewContextReader(ctx, s.Stdout), + s.onError, + ) +} + +func (s *session) onError(err error) { + if k, ok := s.Command.(CommandKiller); ok { + _ = k.Kill() } - return &Endpoint{ - Protocol: u.Scheme, - User: user, - Password: pass, - Host: host, - Port: getPort(u), - Path: getPath(u), - }, nil + _ = s.Close() } -func getPort(u *url.URL) int { - p := u.Port() - if p == "" { - return 0 +func (s *session) ReceivePack(ctx context.Context, req *packp.ReferenceUpdateRequest) (*packp.ReportStatus, error) { + start := time.Now() + defer func() { + trace.Performance.Printf("performance: %.9f s: receive_pack", time.Since(start).Seconds()) + }() + + if _, err := s.AdvertisedReferences(); err != nil { + return nil, err } - i, err := strconv.Atoi(p) - if err != nil { - return 0 + s.packRun = true + + w := s.StdinContext(ctx) + if err := req.Encode(w); err != nil { + return nil, err + } + + if err := w.Close(); err != nil { + return nil, err + } + + if !req.Capabilities.Supports(capability.ReportStatus) { + // If we don't have report-status, we can only + // check return value error. + return nil, s.Command.Close() + } + + r := s.StdoutContext(ctx) + + var d *sideband.Demuxer + if req.Capabilities.Supports(capability.Sideband64k) { + d = sideband.NewDemuxer(sideband.Sideband64k, r) + } else if req.Capabilities.Supports(capability.Sideband) { + d = sideband.NewDemuxer(sideband.Sideband, r) + } + if d != nil { + d.Progress = req.Progress + r = d + } + + report := packp.NewReportStatus() + if err := report.Decode(r); err != nil { + return nil, err + } + + if err := report.Error(); err != nil { + defer s.Close() + return report, err } - return i + return report, s.Command.Close() } -func getPath(u *url.URL) string { - var res string = u.Path - if u.RawQuery != "" { - res += "?" + u.RawQuery +func (s *session) finish() error { + if s.finished { + return nil } - if u.Fragment != "" { - res += "#" + u.Fragment + s.finished = true + + // If we did not run a upload/receive-pack, we close the connection + // gracefully by sending a flush packet to the server. If the server + // operates correctly, it will exit with status 0. + if !s.packRun { + return pktline.WriteFlush(s.Stdin) } - return res + return nil +} + +func (s *session) Close() (err error) { + err = s.finish() + + defer ioutil.CheckClose(s.Command, &err) + return } -func parseSCPLike(endpoint string) (*Endpoint, bool) { - if giturl.MatchesScheme(endpoint) || !giturl.MatchesScpLike(endpoint) { - return nil, false +func (s *session) checkNotFoundError() error { + t := time.NewTicker(time.Second * readErrorSecondsTimeout) + defer t.Stop() + + select { + case <-t.C: + return ErrTimeoutExceeded + case line, ok := <-s.firstErrLine: + if !ok || len(line) == 0 { + return nil + } + + if isRepoNotFoundError(line) { + return ErrRepositoryNotFound + } + + return fmt.Errorf("unknown error: %s", line) } +} - user, host, portStr, path := giturl.FindScpLikeComponents(endpoint) - port, err := strconv.Atoi(portStr) - if err != nil { - port = 22 +const ( + githubRepoNotFoundErr = "Repository not found." + bitbucketRepoNotFoundErr = "repository does not exist." + localRepoNotFoundErr = "does not appear to be a git repository" + gitProtocolNotFoundErr = "Repository not found." + gitProtocolNoSuchErr = "no such repository" + gitProtocolAccessDeniedErr = "access denied" + gogsAccessDeniedErr = "Repository does not exist or you do not have access" + gitlabRepoNotFoundErr = "The project you were looking for could not be found" +) + +func isRepoNotFoundError(s string) bool { + for _, err := range []string{ + githubRepoNotFoundErr, + bitbucketRepoNotFoundErr, + localRepoNotFoundErr, + gitProtocolNotFoundErr, + gitProtocolNoSuchErr, + gitProtocolAccessDeniedErr, + gogsAccessDeniedErr, + gitlabRepoNotFoundErr, + } { + if strings.Contains(s, err) { + return true + } } - return &Endpoint{ - Protocol: "ssh", - User: user, - Host: host, - Port: port, - Path: path, - }, true + return false } -func parseFile(endpoint string) (*Endpoint, bool) { - if giturl.MatchesScheme(endpoint) { - return nil, false +// uploadPack implements the git-upload-pack protocol. +func uploadPack(w io.WriteCloser, _ io.Reader, req *packp.UploadPackRequest) error { + // TODO support acks for common objects + // TODO build a proper state machine for all these processing options + + if err := req.UploadRequest.Encode(w); err != nil { + return fmt.Errorf("sending upload-req message: %s", err) } - path, err := filepath.Abs(endpoint) - if err != nil { - return nil, false + if err := req.UploadHaves.Encode(w, true); err != nil { + return fmt.Errorf("sending haves message: %s", err) + } + + if err := sendDone(w); err != nil { + return fmt.Errorf("sending done message: %s", err) } - return &Endpoint{ - Protocol: "file", - Path: path, - }, true + if err := w.Close(); err != nil { + return fmt.Errorf("closing input: %s", err) + } + + return nil } -// UnsupportedCapabilities are the capabilities not supported by any client -// implementation -var UnsupportedCapabilities = []capability.Capability{ - capability.MultiACK, - capability.MultiACKDetailed, - capability.ThinPack, +func sendDone(w io.Writer) error { + _, err := pktline.Writef(w, "done\n") + return err } -// FilterUnsupportedCapabilities it filter out all the UnsupportedCapabilities -// from a capability.List, the intended usage is on the client implementation -// to filter the capabilities from an AdvRefs message. -func FilterUnsupportedCapabilities(list *capability.List) { - for _, c := range UnsupportedCapabilities { - list.Delete(c) +// DecodeUploadPackResponse decodes r into a new packp.UploadPackResponse +func DecodeUploadPackResponse(r io.ReadCloser, req *packp.UploadPackRequest) ( + *packp.UploadPackResponse, error, +) { + res := packp.NewUploadPackResponse(req) + if err := res.Decode(r); err != nil { + return nil, fmt.Errorf("error decoding upload-pack response: %s", err) } + + return res, nil } diff --git a/plumbing/transport/common_test.go b/plumbing/transport/common_test.go index 1501f73f2..47b9bb5fa 100644 --- a/plumbing/transport/common_test.go +++ b/plumbing/transport/common_test.go @@ -2,241 +2,166 @@ package transport import ( "fmt" - "net/url" - "os" - "path/filepath" - "runtime" "testing" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } +func TestCommonSuite(t *testing.T) { + suite.Run(t, new(CommonSuite)) +} + +type CommonSuite struct { + suite.Suite +} -type SuiteCommon struct{} +func (s *CommonSuite) TestIsRepoNotFoundErrorForUnknownSource() { + msg := "unknown system is complaining of something very sad :(" -var _ = Suite(&SuiteCommon{}) + isRepoNotFound := isRepoNotFoundError(msg) -func (s *SuiteCommon) TestNewEndpointHTTP(c *C) { - e, err := NewEndpoint("http://git:pass@github.com/user/repository.git?foo#bar") - c.Assert(err, IsNil) - c.Assert(e.Protocol, Equals, "http") - c.Assert(e.User, Equals, "git") - c.Assert(e.Password, Equals, "pass") - c.Assert(e.Host, Equals, "github.com") - c.Assert(e.Port, Equals, 0) - c.Assert(e.Path, Equals, "/user/repository.git?foo#bar") - c.Assert(e.String(), Equals, "http://git:pass@github.com/user/repository.git?foo#bar") + s.False(isRepoNotFound) } -func (s *SuiteCommon) TestNewEndpointPorts(c *C) { - e, err := NewEndpoint("http://git:pass@github.com:8080/user/repository.git?foo#bar") - c.Assert(err, IsNil) - c.Assert(e.String(), Equals, "http://git:pass@github.com:8080/user/repository.git?foo#bar") +func (s *CommonSuite) TestIsRepoNotFoundError() { + msg := "no such repository : some error stuf" - e, err = NewEndpoint("https://git:pass@github.com:443/user/repository.git?foo#bar") - c.Assert(err, IsNil) - c.Assert(e.String(), Equals, "https://git:pass@github.com/user/repository.git?foo#bar") + isRepoNotFound := isRepoNotFoundError(msg) - e, err = NewEndpoint("ssh://git:pass@github.com:22/user/repository.git?foo#bar") - c.Assert(err, IsNil) - c.Assert(e.String(), Equals, "ssh://git:pass@github.com/user/repository.git?foo#bar") + s.True(isRepoNotFound) +} - e, err = NewEndpoint("git://github.com:9418/user/repository.git?foo#bar") - c.Assert(err, IsNil) - c.Assert(e.String(), Equals, "git://github.com/user/repository.git?foo#bar") +func (s *CommonSuite) TestIsRepoNotFoundErrorForGithub() { + msg := fmt.Sprintf("%s : some error stuf", githubRepoNotFoundErr) -} + isRepoNotFound := isRepoNotFoundError(msg) -func (s *SuiteCommon) TestNewEndpointSSH(c *C) { - e, err := NewEndpoint("ssh://git@github.com/user/repository.git") - c.Assert(err, IsNil) - c.Assert(e.Protocol, Equals, "ssh") - c.Assert(e.User, Equals, "git") - c.Assert(e.Password, Equals, "") - c.Assert(e.Host, Equals, "github.com") - c.Assert(e.Port, Equals, 0) - c.Assert(e.Path, Equals, "/user/repository.git") - c.Assert(e.String(), Equals, "ssh://git@github.com/user/repository.git") + s.True(isRepoNotFound) } -func (s *SuiteCommon) TestNewEndpointSSHNoUser(c *C) { - e, err := NewEndpoint("ssh://github.com/user/repository.git") - c.Assert(err, IsNil) - c.Assert(e.Protocol, Equals, "ssh") - c.Assert(e.User, Equals, "") - c.Assert(e.Password, Equals, "") - c.Assert(e.Host, Equals, "github.com") - c.Assert(e.Port, Equals, 0) - c.Assert(e.Path, Equals, "/user/repository.git") - c.Assert(e.String(), Equals, "ssh://github.com/user/repository.git") -} +func (s *CommonSuite) TestIsRepoNotFoundErrorForBitBucket() { + msg := fmt.Sprintf("%s : some error stuf", bitbucketRepoNotFoundErr) + + isRepoNotFound := isRepoNotFoundError(msg) -func (s *SuiteCommon) TestNewEndpointSSHWithPort(c *C) { - e, err := NewEndpoint("ssh://git@github.com:777/user/repository.git") - c.Assert(err, IsNil) - c.Assert(e.Protocol, Equals, "ssh") - c.Assert(e.User, Equals, "git") - c.Assert(e.Password, Equals, "") - c.Assert(e.Host, Equals, "github.com") - c.Assert(e.Port, Equals, 777) - c.Assert(e.Path, Equals, "/user/repository.git") - c.Assert(e.String(), Equals, "ssh://git@github.com:777/user/repository.git") + s.True(isRepoNotFound) } -func (s *SuiteCommon) TestNewEndpointSCPLike(c *C) { - e, err := NewEndpoint("git@github.com:user/repository.git") - c.Assert(err, IsNil) - c.Assert(e.Protocol, Equals, "ssh") - c.Assert(e.User, Equals, "git") - c.Assert(e.Password, Equals, "") - c.Assert(e.Host, Equals, "github.com") - c.Assert(e.Port, Equals, 22) - c.Assert(e.Path, Equals, "user/repository.git") - c.Assert(e.String(), Equals, "ssh://git@github.com/user/repository.git") +func (s *CommonSuite) TestIsRepoNotFoundErrorForLocal() { + msg := fmt.Sprintf("some error stuf : %s", localRepoNotFoundErr) + + isRepoNotFound := isRepoNotFoundError(msg) + + s.True(isRepoNotFound) } -func (s *SuiteCommon) TestNewEndpointSCPLikeWithNumericPath(c *C) { - e, err := NewEndpoint("git@github.com:9999/user/repository.git") - c.Assert(err, IsNil) - c.Assert(e.Protocol, Equals, "ssh") - c.Assert(e.User, Equals, "git") - c.Assert(e.Password, Equals, "") - c.Assert(e.Host, Equals, "github.com") - c.Assert(e.Port, Equals, 22) - c.Assert(e.Path, Equals, "9999/user/repository.git") - c.Assert(e.String(), Equals, "ssh://git@github.com/9999/user/repository.git") +func (s *CommonSuite) TestIsRepoNotFoundErrorForGitProtocolNotFound() { + msg := fmt.Sprintf("%s : some error stuf", gitProtocolNotFoundErr) + + isRepoNotFound := isRepoNotFoundError(msg) + + s.True(isRepoNotFound) } -func (s *SuiteCommon) TestNewEndpointSCPLikeWithPort(c *C) { - e, err := NewEndpoint("git@github.com:8080:9999/user/repository.git") - c.Assert(err, IsNil) - c.Assert(e.Protocol, Equals, "ssh") - c.Assert(e.User, Equals, "git") - c.Assert(e.Password, Equals, "") - c.Assert(e.Host, Equals, "github.com") - c.Assert(e.Port, Equals, 8080) - c.Assert(e.Path, Equals, "9999/user/repository.git") - c.Assert(e.String(), Equals, "ssh://git@github.com:8080/9999/user/repository.git") +func (s *CommonSuite) TestIsRepoNotFoundErrorForGitProtocolNoSuch() { + msg := fmt.Sprintf("%s : some error stuf", gitProtocolNoSuchErr) + + isRepoNotFound := isRepoNotFoundError(msg) + + s.True(isRepoNotFound) } -func (s *SuiteCommon) TestNewEndpointFileAbs(c *C) { - var err error - abs := "/foo.git" +func (s *CommonSuite) TestIsRepoNotFoundErrorForGitProtocolAccessDenied() { + msg := fmt.Sprintf("%s : some error stuf", gitProtocolAccessDeniedErr) - if runtime.GOOS == "windows" { - abs, err = filepath.Abs(abs) - c.Assert(err, IsNil) - } + isRepoNotFound := isRepoNotFoundError(msg) - e, err := NewEndpoint("/foo.git") - c.Assert(err, IsNil) - c.Assert(e.Protocol, Equals, "file") - c.Assert(e.User, Equals, "") - c.Assert(e.Password, Equals, "") - c.Assert(e.Host, Equals, "") - c.Assert(e.Port, Equals, 0) - c.Assert(e.Path, Equals, abs) - c.Assert(e.String(), Equals, "file://"+abs) + s.True(isRepoNotFound) } -func (s *SuiteCommon) TestNewEndpointFileRel(c *C) { - abs, err := filepath.Abs("foo.git") - c.Assert(err, IsNil) - - e, err := NewEndpoint("foo.git") - c.Assert(err, IsNil) - c.Assert(e.Protocol, Equals, "file") - c.Assert(e.User, Equals, "") - c.Assert(e.Password, Equals, "") - c.Assert(e.Host, Equals, "") - c.Assert(e.Port, Equals, 0) - c.Assert(e.Path, Equals, abs) - c.Assert(e.String(), Equals, "file://"+abs) +func (s *CommonSuite) TestIsRepoNotFoundErrorForGogsAccessDenied() { + msg := fmt.Sprintf("%s : some error stuf", gogsAccessDeniedErr) + + isRepoNotFound := isRepoNotFoundError(msg) + + s.True(isRepoNotFound) } -func (s *SuiteCommon) TestNewEndpointFileWindows(c *C) { - abs := "C:\\foo.git" +func (s *CommonSuite) TestIsRepoNotFoundErrorForGitlab() { + msg := fmt.Sprintf("%s : some error stuf", gitlabRepoNotFoundErr) + + isRepoNotFound := isRepoNotFoundError(msg) + + s.True(isRepoNotFound) +} - if runtime.GOOS != "windows" { - cwd, err := os.Getwd() - c.Assert(err, IsNil) +func (s *CommonSuite) TestCheckNotFoundError() { + firstErrLine := make(chan string, 1) - abs = filepath.Join(cwd, "C:\\foo.git") + session := session{ + firstErrLine: firstErrLine, } - e, err := NewEndpoint("C:\\foo.git") - c.Assert(err, IsNil) - c.Assert(e.Protocol, Equals, "file") - c.Assert(e.User, Equals, "") - c.Assert(e.Password, Equals, "") - c.Assert(e.Host, Equals, "") - c.Assert(e.Port, Equals, 0) - c.Assert(e.Path, Equals, abs) - c.Assert(e.String(), Equals, "file://"+abs) -} + firstErrLine <- "" -func (s *SuiteCommon) TestNewEndpointFileURL(c *C) { - e, err := NewEndpoint("file:///foo.git") - c.Assert(err, IsNil) - c.Assert(e.Protocol, Equals, "file") - c.Assert(e.User, Equals, "") - c.Assert(e.Password, Equals, "") - c.Assert(e.Host, Equals, "") - c.Assert(e.Port, Equals, 0) - c.Assert(e.Path, Equals, "/foo.git") - c.Assert(e.String(), Equals, "file:///foo.git") -} + err := session.checkNotFoundError() -func (s *SuiteCommon) TestValidEndpoint(c *C) { - user := "person@mail.com" - pass := " !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~" - e, err := NewEndpoint(fmt.Sprintf( - "http://%s:%s@github.com/user/repository.git", - url.PathEscape(user), - url.PathEscape(pass), - )) - c.Assert(err, IsNil) - c.Assert(e, NotNil) - c.Assert(e.User, Equals, user) - c.Assert(e.Password, Equals, pass) - c.Assert(e.Host, Equals, "github.com") - c.Assert(e.Path, Equals, "/user/repository.git") - - c.Assert(e.String(), Equals, "http://person@mail.com:%20%21%22%23$%25&%27%28%29%2A+%2C-.%2F:%3B%3C=%3E%3F@%5B%5C%5D%5E_%60%7B%7C%7D~@github.com/user/repository.git") + s.Nil(err) } -func (s *SuiteCommon) TestNewEndpointInvalidURL(c *C) { - e, err := NewEndpoint("http://\\") - c.Assert(err, NotNil) - c.Assert(e, IsNil) -} +func (s *CommonSuite) TestAdvertisedReferencesWithRemoteUnknownError() { + var ( + stderr = "something" + wantErr = fmt.Errorf("unknown error: something") + ) -func (s *SuiteCommon) TestFilterUnsupportedCapabilities(c *C) { - l := capability.NewList() - l.Set(capability.MultiACK) + client := NewClient(mockCommander{stderr: stderr}) + sess, err := client.NewUploadPackSession(nil, nil) + if err != nil { + s.T().Fatalf("unexpected error: %s", err) + } - FilterUnsupportedCapabilities(l) - c.Assert(l.Supports(capability.MultiACK), Equals, false) -} + _, err = sess.AdvertisedReferences() -func (s *SuiteCommon) TestNewEndpointIPv6(c *C) { - // see issue https://github.com/go-git/go-git/issues/740 - // - // IPv6 host names are not being properly handled, which results in unhelpful - // error messages depending on the format used. - // - e, err := NewEndpoint("http://[::1]:8080/foo.git") - c.Assert(err, IsNil) - c.Assert(e.Host, Equals, "[::1]") - c.Assert(e.String(), Equals, "http://[::1]:8080/foo.git") + if wantErr != nil { + if wantErr != err { + if wantErr.Error() != err.Error() { + s.T().Fatalf("expected a different error: got '%s', expected '%s'", err, wantErr) + } + } + } else if err != nil { + s.T().Fatalf("unexpected error: %s", err) + } } -func FuzzNewEndpoint(f *testing.F) { +func (s *CommonSuite) TestAdvertisedReferencesWithRemoteNotFoundError() { + var ( + stderr = `remote: +remote: ======================================================================== +remote: +remote: ERROR: The project you were looking for could not be found or you don't have permission to view it. - f.Fuzz(func(t *testing.T, input string) { - NewEndpoint(input) - }) +remote: +remote: ======================================================================== +remote:` + wantErr = ErrRepositoryNotFound + ) + + client := NewClient(mockCommander{stderr: stderr}) + sess, err := client.NewUploadPackSession(nil, nil) + if err != nil { + s.T().Fatalf("unexpected error: %s", err) + } + + _, err = sess.AdvertisedReferences() + + if wantErr != nil { + if wantErr != err { + if wantErr.Error() != err.Error() { + s.T().Fatalf("expected a different error: got '%s', expected '%s'", err, wantErr) + } + } + } else if err != nil { + s.T().Fatalf("unexpected error: %s", err) + } } diff --git a/plumbing/transport/file/client.go b/plumbing/transport/file/client.go index d921d0a5a..cd3a0c6cd 100644 --- a/plumbing/transport/file/client.go +++ b/plumbing/transport/file/client.go @@ -10,11 +10,14 @@ import ( "runtime" "strings" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/plumbing/transport/internal/common" + "github.com/jesseduffield/go-git/v5/plumbing/transport" "golang.org/x/sys/execabs" ) +func init() { + transport.Register("file", DefaultClient) +} + // DefaultClient is the default local client. var DefaultClient = NewClient( transport.UploadPackServiceName, @@ -29,7 +32,7 @@ type runner struct { // NewClient returns a new local client using the given git-upload-pack and // git-receive-pack binaries. func NewClient(uploadPackBin, receivePackBin string) transport.Transport { - return common.NewClient(&runner{ + return transport.NewClient(&runner{ UploadPackBin: uploadPackBin, ReceivePackBin: receivePackBin, }) @@ -75,7 +78,7 @@ func prefixExecPath(cmd string) (string, error) { } func (r *runner) Command(cmd string, ep *transport.Endpoint, auth transport.AuthMethod, -) (common.Command, error) { +) (transport.Command, error) { switch cmd { case transport.UploadPackServiceName: diff --git a/plumbing/transport/file/client_test.go b/plumbing/transport/file/client_test.go index daa08713f..5f1f00972 100644 --- a/plumbing/transport/file/client_test.go +++ b/plumbing/transport/file/client_test.go @@ -7,33 +7,33 @@ import ( "strings" "testing" - "github.com/go-git/go-git/v5/plumbing/transport" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } +func TestClientSuite(t *testing.T) { + suite.Run(t, new(ClientSuite)) +} type ClientSuite struct { CommonSuite } -var _ = Suite(&ClientSuite{}) - -func (s *ClientSuite) TestCommand(c *C) { +func (s *ClientSuite) TestCommand() { runner := &runner{ UploadPackBin: transport.UploadPackServiceName, ReceivePackBin: transport.ReceivePackServiceName, } ep, err := transport.NewEndpoint(filepath.Join("fake", "repo")) - c.Assert(err, IsNil) + s.Nil(err) var emptyAuth transport.AuthMethod _, err = runner.Command("git-receive-pack", ep, emptyAuth) - c.Assert(err, IsNil) + s.Nil(err) // Make sure we get an error for one that doesn't exist. _, err = runner.Command("git-fake-command", ep, emptyAuth) - c.Assert(err, NotNil) + s.NotNil(err) } const bareConfig = `[core] @@ -41,20 +41,20 @@ repositoryformatversion = 0 filemode = true bare = true` -func prepareRepo(c *C, path string) *transport.Endpoint { +func prepareRepo(t *testing.T, path string) *transport.Endpoint { ep, err := transport.NewEndpoint(path) - c.Assert(err, IsNil) + assert.Nil(t, err) // git-receive-pack refuses to update refs/heads/master on non-bare repo // so we ensure bare repo config. config := filepath.Join(path, "config") if _, err := os.Stat(config); err == nil { f, err := os.OpenFile(config, os.O_TRUNC|os.O_WRONLY, 0) - c.Assert(err, IsNil) + assert.Nil(t, err) content := strings.NewReader(bareConfig) _, err = io.Copy(f, content) - c.Assert(err, IsNil) - c.Assert(f.Close(), IsNil) + assert.Nil(t, err) + assert.Nil(t, f.Close()) } return ep diff --git a/plumbing/transport/file/common_test.go b/plumbing/transport/file/common_test.go index a217e9716..6431f7737 100644 --- a/plumbing/transport/file/common_test.go +++ b/plumbing/transport/file/common_test.go @@ -6,37 +6,32 @@ import ( "path/filepath" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) type CommonSuite struct { - fixtures.Suite + suite.Suite ReceivePackBin string UploadPackBin string tmpDir string // to be removed at teardown } -var _ = Suite(&CommonSuite{}) - -func (s *CommonSuite) SetUpSuite(c *C) { +func (s *CommonSuite) SetupSuite() { if err := exec.Command("git", "--version").Run(); err != nil { - c.Skip("git command not found") + s.T().Skip("git command not found") } - var err error - s.tmpDir, err = os.MkdirTemp("", "") - c.Assert(err, IsNil) + s.tmpDir = s.T().TempDir() s.ReceivePackBin = filepath.Join(s.tmpDir, "git-receive-pack") s.UploadPackBin = filepath.Join(s.tmpDir, "git-upload-pack") bin := filepath.Join(s.tmpDir, "go-git") cmd := exec.Command("go", "build", "-o", bin) cmd.Dir = "../../../cli/go-git" - c.Assert(cmd.Run(), IsNil) - c.Assert(os.Symlink(bin, s.ReceivePackBin), IsNil) - c.Assert(os.Symlink(bin, s.UploadPackBin), IsNil) + s.Nil(cmd.Run()) + s.Nil(os.Symlink(bin, s.ReceivePackBin)) + s.Nil(os.Symlink(bin, s.UploadPackBin)) } -func (s *CommonSuite) TearDownSuite(c *C) { - defer s.Suite.TearDownSuite(c) - c.Assert(os.RemoveAll(s.tmpDir), IsNil) +func (s *CommonSuite) TearDownSuite() { + fixtures.Clean() } diff --git a/plumbing/transport/file/receive_pack_test.go b/plumbing/transport/file/receive_pack_test.go index 686bdcc5d..5cfc14813 100644 --- a/plumbing/transport/file/receive_pack_test.go +++ b/plumbing/transport/file/receive_pack_test.go @@ -2,74 +2,75 @@ package file import ( "os" + "regexp" + "testing" - "github.com/go-git/go-git/v5/plumbing/transport/test" + "github.com/jesseduffield/go-git/v5/internal/transport/test" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) +func TestReceivePackSuite(t *testing.T) { + suite.Run(t, &ReceivePackSuite{}) +} + type ReceivePackSuite struct { CommonSuite - test.ReceivePackSuite + rps test.ReceivePackSuite } -var _ = Suite(&ReceivePackSuite{}) - -func (s *ReceivePackSuite) SetUpSuite(c *C) { - s.CommonSuite.SetUpSuite(c) - s.ReceivePackSuite.Client = DefaultClient +func (s *ReceivePackSuite) SetupSuite() { + s.CommonSuite.SetupSuite() + s.rps.SetS(s) + s.rps.Client = DefaultClient } -func (s *ReceivePackSuite) SetUpTest(c *C) { +func (s *ReceivePackSuite) SetupTest() { fixture := fixtures.Basic().One() path := fixture.DotGit().Root() - s.Endpoint = prepareRepo(c, path) + s.rps.Endpoint = prepareRepo(s.T(), path) fixture = fixtures.ByTag("empty").One() path = fixture.DotGit().Root() - s.EmptyEndpoint = prepareRepo(c, path) - - s.NonExistentEndpoint = prepareRepo(c, "/non-existent") -} + s.rps.EmptyEndpoint = prepareRepo(s.T(), path) -func (s *ReceivePackSuite) TearDownTest(c *C) { - s.Suite.TearDownSuite(c) + s.rps.NonExistentEndpoint = prepareRepo(s.T(), "/non-existent") } // TODO: fix test -func (s *ReceivePackSuite) TestCommandNoOutput(c *C) { - c.Skip("failing test") +func (s *ReceivePackSuite) TestCommandNoOutput() { + s.T().Skip("failing test") if _, err := os.Stat("/bin/true"); os.IsNotExist(err) { - c.Skip("/bin/true not found") + s.T().Skip("/bin/true not found") } client := NewClient("true", "true") - session, err := client.NewReceivePackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) + session, err := client.NewReceivePackSession(s.rps.Endpoint, s.rps.EmptyAuth) + s.Nil(err) ar, err := session.AdvertisedReferences() - c.Assert(err, IsNil) - c.Assert(ar, IsNil) + s.Nil(err) + s.Nil(ar) } -func (s *ReceivePackSuite) TestMalformedInputNoErrors(c *C) { +func (s *ReceivePackSuite) TestMalformedInputNoErrors() { if _, err := os.Stat("/usr/bin/yes"); os.IsNotExist(err) { - c.Skip("/usr/bin/yes not found") + s.T().Skip("/usr/bin/yes not found") } client := NewClient("yes", "yes") - session, err := client.NewReceivePackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) + session, err := client.NewReceivePackSession(s.rps.Endpoint, s.rps.EmptyAuth) + s.Nil(err) ar, err := session.AdvertisedReferences() - c.Assert(err, NotNil) - c.Assert(ar, IsNil) + s.NotNil(err) + s.Nil(ar) } -func (s *ReceivePackSuite) TestNonExistentCommand(c *C) { +func (s *ReceivePackSuite) TestNonExistentCommand() { cmd := "/non-existent-git" client := NewClient(cmd, cmd) - session, err := client.NewReceivePackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, ErrorMatches, ".*(no such file or directory.*|.*file does not exist)*.") - c.Assert(session, IsNil) + session, err := client.NewReceivePackSession(s.rps.Endpoint, s.rps.EmptyAuth) + s.Regexp(regexp.MustCompile(".*(no such file or directory|file does not exist)*."), err) + s.Nil(session) } diff --git a/plumbing/transport/file/server.go b/plumbing/transport/file/server.go index b45d7a71c..7a30d0b5c 100644 --- a/plumbing/transport/file/server.go +++ b/plumbing/transport/file/server.go @@ -4,10 +4,9 @@ import ( "fmt" "os" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/plumbing/transport/internal/common" - "github.com/go-git/go-git/v5/plumbing/transport/server" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/plumbing/server" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/utils/ioutil" ) // ServeUploadPack serves a git-upload-pack request using standard output, input @@ -25,7 +24,7 @@ func ServeUploadPack(path string) error { return fmt.Errorf("error creating session: %s", err) } - return common.ServeUploadPack(srvCmd, s) + return server.ServeUploadPack(srvCmd, s) } // ServeReceivePack serves a git-receive-pack request using standard output, @@ -43,10 +42,10 @@ func ServeReceivePack(path string) error { return fmt.Errorf("error creating session: %s", err) } - return common.ServeReceivePack(srvCmd, s) + return server.ServeReceivePack(srvCmd, s) } -var srvCmd = common.ServerCommand{ +var srvCmd = server.ServerCommand{ Stdin: os.Stdin, Stdout: ioutil.WriteNopCloser(os.Stdout), Stderr: os.Stderr, diff --git a/plumbing/transport/file/server_test.go b/plumbing/transport/file/server_test.go index b6ac4e0b8..a457cb8e5 100644 --- a/plumbing/transport/file/server_test.go +++ b/plumbing/transport/file/server_test.go @@ -1,13 +1,20 @@ package file import ( + "fmt" "os" "os/exec" + "testing" - "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" + fixtures "github.com/go-git/go-git-fixtures/v4" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" ) +func TestServerSuite(t *testing.T) { + suite.Run(t, new(ServerSuite)) +} + type ServerSuite struct { CommonSuite RemoteName string @@ -15,10 +22,8 @@ type ServerSuite struct { DstPath string } -var _ = Suite(&ServerSuite{}) - -func (s *ServerSuite) SetUpSuite(c *C) { - s.CommonSuite.SetUpSuite(c) +func (s *ServerSuite) SetupSuite() { + s.CommonSuite.SetupSuite() s.RemoteName = "test" @@ -30,12 +35,12 @@ func (s *ServerSuite) SetUpSuite(c *C) { cmd := exec.Command("git", "remote", "add", s.RemoteName, s.DstPath) cmd.Dir = s.SrcPath - c.Assert(cmd.Run(), IsNil) + s.Nil(cmd.Run()) } -func (s *ServerSuite) TestPush(c *C) { - if !s.checkExecPerm(c) { - c.Skip("go-git binary has not execution permissions") +func (s *ServerSuite) TestPush() { + if !s.checkExecPerm(s.T()) { + s.T().Skip("go-git binary has not execution permissions") } // git <2.0 cannot push to an empty repository without a refspec. @@ -47,15 +52,15 @@ func (s *ServerSuite) TestPush(c *C) { cmd.Env = os.Environ() cmd.Env = append(cmd.Env, "GIT_TRACE=true", "GIT_TRACE_PACKET=true") out, err := cmd.CombinedOutput() - c.Assert(err, IsNil, Commentf("combined stdout and stderr:\n%s\n", out)) + s.Nil(err, fmt.Sprintf("combined stdout and stderr:\n%s\n", out)) } -func (s *ServerSuite) TestClone(c *C) { - if !s.checkExecPerm(c) { - c.Skip("go-git binary has not execution permissions") +func (s *ServerSuite) TestClone() { + if !s.checkExecPerm(s.T()) { + s.T().Skip("go-git binary has not execution permissions") } - pathToClone := c.MkDir() + pathToClone := s.T().TempDir() cmd := exec.Command("git", "clone", "--upload-pack", s.UploadPackBin, @@ -64,12 +69,12 @@ func (s *ServerSuite) TestClone(c *C) { cmd.Env = os.Environ() cmd.Env = append(cmd.Env, "GIT_TRACE=true", "GIT_TRACE_PACKET=true") out, err := cmd.CombinedOutput() - c.Assert(err, IsNil, Commentf("combined stdout and stderr:\n%s\n", out)) + s.Nil(err, fmt.Sprintf("combined stdout and stderr:\n%s\n", out)) } -func (s *ServerSuite) checkExecPerm(c *C) bool { - const userExecPermMask = 0100 +func (s *ServerSuite) checkExecPerm(t *testing.T) bool { + const userExecPermMask = 0o100 info, err := os.Stat(s.ReceivePackBin) - c.Assert(err, IsNil) + assert.Nil(t, err) return (info.Mode().Perm() & userExecPermMask) == userExecPermMask } diff --git a/plumbing/transport/file/upload_pack_test.go b/plumbing/transport/file/upload_pack_test.go index fe7c6af8f..80afce52c 100644 --- a/plumbing/transport/file/upload_pack_test.go +++ b/plumbing/transport/file/upload_pack_test.go @@ -2,83 +2,87 @@ package file import ( "os" + "testing" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/plumbing/transport/test" + "github.com/jesseduffield/go-git/v5/internal/transport/test" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) +func TestUploadPackSuite(t *testing.T) { + suite.Run(t, new(UploadPackSuite)) +} + type UploadPackSuite struct { CommonSuite - test.UploadPackSuite + ups test.UploadPackSuite } -var _ = Suite(&UploadPackSuite{}) - -func (s *UploadPackSuite) SetUpSuite(c *C) { - s.CommonSuite.SetUpSuite(c) +func (s *UploadPackSuite) SetupSuite() { + s.CommonSuite.SetupSuite() - s.UploadPackSuite.Client = DefaultClient + s.ups.SetS(s) + s.ups.Client = DefaultClient fixture := fixtures.Basic().One() path := fixture.DotGit().Root() ep, err := transport.NewEndpoint(path) - c.Assert(err, IsNil) - s.Endpoint = ep + s.Nil(err) + s.ups.Endpoint = ep fixture = fixtures.ByTag("empty").One() path = fixture.DotGit().Root() ep, err = transport.NewEndpoint(path) - c.Assert(err, IsNil) - s.EmptyEndpoint = ep + s.Nil(err) + s.ups.EmptyEndpoint = ep ep, err = transport.NewEndpoint("non-existent") - c.Assert(err, IsNil) - s.NonExistentEndpoint = ep + s.Nil(err) + s.ups.NonExistentEndpoint = ep } // TODO: fix test -func (s *UploadPackSuite) TestCommandNoOutput(c *C) { - c.Skip("failing test") +func (s *UploadPackSuite) TestCommandNoOutput() { + s.T().Skip("failing test") if _, err := os.Stat("/bin/true"); os.IsNotExist(err) { - c.Skip("/bin/true not found") + s.T().Skip("/bin/true not found") } client := NewClient("true", "true") - session, err := client.NewUploadPackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) + session, err := client.NewUploadPackSession(s.ups.Endpoint, s.ups.EmptyAuth) + s.Nil(err) ar, err := session.AdvertisedReferences() - c.Assert(err, IsNil) - c.Assert(ar, IsNil) + s.Nil(err) + s.Nil(ar) } -func (s *UploadPackSuite) TestMalformedInputNoErrors(c *C) { +func (s *UploadPackSuite) TestMalformedInputNoErrors() { if _, err := os.Stat("/usr/bin/yes"); os.IsNotExist(err) { - c.Skip("/usr/bin/yes not found") + s.T().Skip("/usr/bin/yes not found") } client := NewClient("yes", "yes") - session, err := client.NewUploadPackSession(s.Endpoint, s.EmptyAuth) - c.Assert(err, IsNil) + session, err := client.NewUploadPackSession(s.ups.Endpoint, s.ups.EmptyAuth) + s.Nil(err) ar, err := session.AdvertisedReferences() - c.Assert(err, NotNil) - c.Assert(ar, IsNil) + s.NotNil(err) + s.Nil(ar) } -func (s *UploadPackSuite) TestNonExistentCommand(c *C) { +func (s *UploadPackSuite) TestNonExistentCommand() { cmd := "/non-existent-git" client := NewClient(cmd, cmd) - session, err := client.NewUploadPackSession(s.Endpoint, s.EmptyAuth) + session, err := client.NewUploadPackSession(s.ups.Endpoint, s.ups.EmptyAuth) // Error message is OS-dependant, so do a broad check - c.Assert(err, ErrorMatches, ".*file.*") - c.Assert(session, IsNil) + s.ErrorContains(err, "file") + s.Nil(session) } -func (s *UploadPackSuite) TestUploadPackWithContextOnRead(c *C) { +func (s *UploadPackSuite) TestUploadPackWithContextOnRead() { // TODO: Fix race condition when Session.Close and the read failed due to a // canceled context when the packfile is being read. - c.Skip("UploadPack has a race condition when we Close the session") + s.T().Skip("UploadPack has a race condition when we Close the session") } diff --git a/plumbing/transport/git/common.go b/plumbing/transport/git/common.go index 2b878b035..28d67cdea 100644 --- a/plumbing/transport/git/common.go +++ b/plumbing/transport/git/common.go @@ -6,21 +6,24 @@ import ( "net" "strconv" - "github.com/go-git/go-git/v5/plumbing/protocol/packp" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/plumbing/transport/internal/common" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/utils/ioutil" ) +func init() { + transport.Register("git", DefaultClient) +} + // DefaultClient is the default git client. -var DefaultClient = common.NewClient(&runner{}) +var DefaultClient = transport.NewClient(&runner{}) const DefaultPort = 9418 type runner struct{} // Command returns a new Command for the given cmd in the given Endpoint -func (r *runner) Command(cmd string, ep *transport.Endpoint, auth transport.AuthMethod) (common.Command, error) { +func (r *runner) Command(cmd string, ep *transport.Endpoint, auth transport.AuthMethod) (transport.Command, error) { // auth not allowed since git protocol doesn't support authentication if auth != nil { return nil, transport.ErrInvalidAuthMethod diff --git a/plumbing/transport/git/common_test.go b/plumbing/transport/git/common_test.go index 3cab93314..07fcda266 100644 --- a/plumbing/transport/git/common_test.go +++ b/plumbing/transport/git/common_test.go @@ -8,45 +8,46 @@ import ( "os/exec" "path/filepath" "runtime" - "testing" "time" - "github.com/go-git/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) -func Test(t *testing.T) { TestingT(t) } - type BaseSuite struct { - fixtures.Suite + suite.Suite base string port int daemon *exec.Cmd } -func (s *BaseSuite) SetUpTest(c *C) { +func (s *BaseSuite) TearDownSuite() { + fixtures.Clean() +} + +func (s *BaseSuite) SetupTest() { if runtime.GOOS == "windows" { - c.Skip(`git for windows has issues with write operations through git:// protocol. + s.T().Skip(`git for windows has issues with write operations through git:// protocol. See https://github.com/git-for-windows/git/issues/907`) } cmd := exec.Command("git", "daemon", "--help") output, err := cmd.CombinedOutput() if err != nil && bytes.Contains(output, []byte("'daemon' is not a git command")) { - c.Fatal("git daemon cannot be found") + s.T().Fatal("git daemon cannot be found") } s.port, err = freePort() - c.Assert(err, IsNil) + s.NoError(err) - s.base, err = os.MkdirTemp(os.TempDir(), fmt.Sprintf("go-git-protocol-%d", s.port)) - c.Assert(err, IsNil) + s.base, err = os.MkdirTemp(s.T().TempDir(), fmt.Sprintf("go-git-protocol-%d", s.port)) + s.NoError(err) } -func (s *BaseSuite) StartDaemon(c *C) { +func (s *BaseSuite) StartDaemon() { s.daemon = exec.Command( "git", "daemon", @@ -64,42 +65,37 @@ func (s *BaseSuite) StartDaemon(c *C) { s.daemon.Env = os.Environ() err := s.daemon.Start() - c.Assert(err, IsNil) + s.NoError(err) // Connections might be refused if we start sending request too early. time.Sleep(time.Millisecond * 500) } -func (s *BaseSuite) newEndpoint(c *C, name string) *transport.Endpoint { +func (s *BaseSuite) newEndpoint(name string) *transport.Endpoint { ep, err := transport.NewEndpoint(fmt.Sprintf("git://localhost:%d/%s", s.port, name)) - c.Assert(err, IsNil) + s.NoError(err) return ep } -func (s *BaseSuite) prepareRepository(c *C, f *fixtures.Fixture, name string) *transport.Endpoint { +func (s *BaseSuite) prepareRepository(f *fixtures.Fixture, name string) *transport.Endpoint { fs := f.DotGit() err := fixtures.EnsureIsBare(fs) - c.Assert(err, IsNil) + s.NoError(err) path := filepath.Join(s.base, name) err = os.Rename(fs.Root(), path) - c.Assert(err, IsNil) + s.NoError(err) - return s.newEndpoint(c, name) + return s.newEndpoint(name) } -func (s *BaseSuite) TearDownTest(c *C) { +func (s *BaseSuite) TearDownTest() { if s.daemon != nil { _ = s.daemon.Process.Signal(os.Kill) _ = s.daemon.Wait() } - - if s.base != "" { - err := os.RemoveAll(s.base) - c.Assert(err, IsNil) - } } func freePort() (int, error) { diff --git a/plumbing/transport/git/receive_pack_test.go b/plumbing/transport/git/receive_pack_test.go index 055add83c..715a541ca 100644 --- a/plumbing/transport/git/receive_pack_test.go +++ b/plumbing/transport/git/receive_pack_test.go @@ -1,30 +1,35 @@ package git import ( - "github.com/go-git/go-git/v5/plumbing/transport/test" + "testing" + + "github.com/jesseduffield/go-git/v5/internal/transport/test" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) +func TestReceivePackSuite(t *testing.T) { + suite.Run(t, new(ReceivePackSuite)) +} + type ReceivePackSuite struct { - test.ReceivePackSuite + rps test.ReceivePackSuite BaseSuite } -var _ = Suite(&ReceivePackSuite{}) - -func (s *ReceivePackSuite) SetUpTest(c *C) { - s.BaseSuite.SetUpTest(c) +func (s *ReceivePackSuite) SetupTest() { + s.BaseSuite.SetupTest() - s.ReceivePackSuite.Client = DefaultClient - s.ReceivePackSuite.Endpoint = s.prepareRepository(c, fixtures.Basic().One(), "basic.git") - s.ReceivePackSuite.EmptyEndpoint = s.prepareRepository(c, fixtures.ByTag("empty").One(), "empty.git") - s.ReceivePackSuite.NonExistentEndpoint = s.newEndpoint(c, "non-existent.git") + s.rps.SetS(s) + s.rps.Client = DefaultClient + s.rps.Endpoint = s.prepareRepository(fixtures.Basic().One(), "basic.git") + s.rps.EmptyEndpoint = s.prepareRepository(fixtures.ByTag("empty").One(), "empty.git") + s.rps.NonExistentEndpoint = s.newEndpoint("non-existent.git") - s.StartDaemon(c) + s.StartDaemon() } -func (s *ReceivePackSuite) TestAdvertisedReferencesEmpty(c *C) { - //This test from BaseSuite is flaky, so it's disabled until we figure out a solution. +func (s *ReceivePackSuite) TestAdvertisedReferencesEmpty() { + // This test from BaseSuite is flaky, so it's disabled until we figure out a solution. } diff --git a/plumbing/transport/git/upload_pack_test.go b/plumbing/transport/git/upload_pack_test.go index 5200953ac..3f7885d4e 100644 --- a/plumbing/transport/git/upload_pack_test.go +++ b/plumbing/transport/git/upload_pack_test.go @@ -1,26 +1,31 @@ package git import ( - "github.com/go-git/go-git/v5/plumbing/transport/test" + "testing" + + "github.com/jesseduffield/go-git/v5/internal/transport/test" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) +func TestUploadPackSuite(t *testing.T) { + suite.Run(t, new(UploadPackSuite)) +} + type UploadPackSuite struct { - test.UploadPackSuite + ups test.UploadPackSuite BaseSuite } -var _ = Suite(&UploadPackSuite{}) - -func (s *UploadPackSuite) SetUpSuite(c *C) { - s.BaseSuite.SetUpTest(c) +func (s *UploadPackSuite) SetupSuite() { + s.BaseSuite.SetupTest() - s.UploadPackSuite.Client = DefaultClient - s.UploadPackSuite.Endpoint = s.prepareRepository(c, fixtures.Basic().One(), "basic.git") - s.UploadPackSuite.EmptyEndpoint = s.prepareRepository(c, fixtures.ByTag("empty").One(), "empty.git") - s.UploadPackSuite.NonExistentEndpoint = s.newEndpoint(c, "non-existent.git") + s.ups.SetS(s) + s.ups.Client = DefaultClient + s.ups.Endpoint = s.prepareRepository(fixtures.Basic().One(), "basic.git") + s.ups.EmptyEndpoint = s.prepareRepository(fixtures.ByTag("empty").One(), "empty.git") + s.ups.NonExistentEndpoint = s.newEndpoint("non-existent.git") - s.StartDaemon(c) + s.StartDaemon() } diff --git a/plumbing/transport/http/common.go b/plumbing/transport/http/common.go index 120008db1..2c5dae6d3 100644 --- a/plumbing/transport/http/common.go +++ b/plumbing/transport/http/common.go @@ -15,13 +15,18 @@ import ( "strings" "sync" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/protocol/packp" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/utils/ioutil" "github.com/golang/groupcache/lru" ) +func init() { + transport.Register("http", DefaultClient) + transport.Register("https", DefaultClient) +} + // it requires a bytes.Buffer, because we need to know the length func applyHeadersToRequest(req *http.Request, content *bytes.Buffer, host string, requestType string) { req.Header.Add("User-Agent", "git/1.0") diff --git a/plumbing/transport/http/common_test.go b/plumbing/transport/http/common_test.go index f0eb68d9b..1268074b6 100644 --- a/plumbing/transport/http/common_test.go +++ b/plumbing/transport/http/common_test.go @@ -15,101 +15,102 @@ import ( "strings" "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) -func Test(t *testing.T) { TestingT(t) } +func TestClientSuite(t *testing.T) { + suite.Run(t, new(ClientSuite)) +} type ClientSuite struct { + suite.Suite Endpoint *transport.Endpoint EmptyAuth transport.AuthMethod } -var _ = Suite(&ClientSuite{}) - -func (s *ClientSuite) SetUpSuite(c *C) { +func (s *ClientSuite) SetupSuite() { var err error s.Endpoint, err = transport.NewEndpoint( "https://github.com/git-fixtures/basic", ) - c.Assert(err, IsNil) + s.Nil(err) } -func (s *UploadPackSuite) TestNewClient(c *C) { +func (s *UploadPackSuite) TestNewClient() { roundTripper := &http.Transport{ TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, } cl := &http.Client{Transport: roundTripper} r, ok := NewClient(cl).(*client) - c.Assert(ok, Equals, true) - c.Assert(r.client, Equals, cl) + s.Equal(true, ok) + s.Equal(cl, r.client) } -func (s *ClientSuite) TestNewBasicAuth(c *C) { +func (s *ClientSuite) TestNewBasicAuth() { a := &BasicAuth{"foo", "qux"} - c.Assert(a.Name(), Equals, "http-basic-auth") - c.Assert(a.String(), Equals, "http-basic-auth - foo:*******") + s.Equal("http-basic-auth", a.Name()) + s.Equal("http-basic-auth - foo:*******", a.String()) } -func (s *ClientSuite) TestNewTokenAuth(c *C) { +func (s *ClientSuite) TestNewTokenAuth() { a := &TokenAuth{"OAUTH-TOKEN-TEXT"} - c.Assert(a.Name(), Equals, "http-token-auth") - c.Assert(a.String(), Equals, "http-token-auth - *******") + s.Equal("http-token-auth", a.Name()) + s.Equal("http-token-auth - *******", a.String()) // Check header is set correctly req, err := http.NewRequest("GET", "https://github.com/git-fixtures/basic", nil) - c.Assert(err, Equals, nil) + s.NoError(err) a.SetAuth(req) - c.Assert(req.Header.Get("Authorization"), Equals, "Bearer OAUTH-TOKEN-TEXT") + s.Equal("Bearer OAUTH-TOKEN-TEXT", req.Header.Get("Authorization")) } -func (s *ClientSuite) TestNewErrOK(c *C) { +func (s *ClientSuite) TestNewErrOK() { res := &http.Response{StatusCode: http.StatusOK} err := NewErr(res) - c.Assert(err, IsNil) + s.Nil(err) } -func (s *ClientSuite) TestNewErrUnauthorized(c *C) { - s.testNewHTTPError(c, http.StatusUnauthorized, ".*authentication required.*") +func (s *ClientSuite) TestNewErrUnauthorized() { + s.testNewHTTPError(http.StatusUnauthorized, ".*authentication required.*") } -func (s *ClientSuite) TestNewErrForbidden(c *C) { - s.testNewHTTPError(c, http.StatusForbidden, ".*authorization failed.*") +func (s *ClientSuite) TestNewErrForbidden() { + s.testNewHTTPError(http.StatusForbidden, ".*authorization failed.*") } -func (s *ClientSuite) TestNewErrNotFound(c *C) { - s.testNewHTTPError(c, http.StatusNotFound, ".*repository not found.*") +func (s *ClientSuite) TestNewErrNotFound() { + s.testNewHTTPError(http.StatusNotFound, ".*repository not found.*") } -func (s *ClientSuite) TestNewHTTPError40x(c *C) { - s.testNewHTTPError(c, http.StatusPaymentRequired, +func (s *ClientSuite) TestNewHTTPError40x() { + s.testNewHTTPError(http.StatusPaymentRequired, "unexpected client error.*") } -func (s *ClientSuite) TestNewUnexpectedError(c *C) { +func (s *ClientSuite) TestNewUnexpectedError() { res := &http.Response{ StatusCode: 500, Body: io.NopCloser(strings.NewReader("Unexpected error")), } err := NewErr(res) - c.Assert(err, NotNil) - c.Assert(err, FitsTypeOf, &plumbing.UnexpectedError{}) + s.Error(err) + s.IsType(&plumbing.UnexpectedError{}, err) unexpectedError, _ := err.(*plumbing.UnexpectedError) - c.Assert(unexpectedError.Err, FitsTypeOf, &Err{}) + s.IsType(&Err{}, unexpectedError.Err) httpError, _ := unexpectedError.Err.(*Err) - c.Assert(httpError.Reason, Equals, "Unexpected error") + s.Equal("Unexpected error", httpError.Reason) } -func (s *ClientSuite) Test_newSession(c *C) { +func (s *ClientSuite) Test_newSession() { cl := NewClientWithOptions(nil, &ClientOptions{ CacheMaxEntries: 2, }).(*client) @@ -117,53 +118,53 @@ func (s *ClientSuite) Test_newSession(c *C) { insecureEP := s.Endpoint insecureEP.InsecureSkipTLS = true session, err := newSession(cl, insecureEP, nil) - c.Assert(err, IsNil) + s.NoError(err) sessionTransport := session.client.Transport.(*http.Transport) - c.Assert(sessionTransport.TLSClientConfig.InsecureSkipVerify, Equals, true) + s.True(sessionTransport.TLSClientConfig.InsecureSkipVerify) t, ok := cl.fetchTransport(transportOptions{ insecureSkipTLS: true, }) // transport should be cached. - c.Assert(ok, Equals, true) + s.True(ok) // cached transport should be the one that's used. - c.Assert(sessionTransport, Equals, t) + s.Equal(sessionTransport, t) caEndpoint := insecureEP caEndpoint.CaBundle = []byte("this is the way") session, err = newSession(cl, caEndpoint, nil) - c.Assert(err, IsNil) + s.NoError(err) sessionTransport = session.client.Transport.(*http.Transport) - c.Assert(sessionTransport.TLSClientConfig.InsecureSkipVerify, Equals, true) - c.Assert(sessionTransport.TLSClientConfig.RootCAs, NotNil) + s.True(sessionTransport.TLSClientConfig.InsecureSkipVerify) + s.NotNil(sessionTransport.TLSClientConfig.RootCAs) t, ok = cl.fetchTransport(transportOptions{ insecureSkipTLS: true, caBundle: "this is the way", }) // transport should be cached. - c.Assert(ok, Equals, true) + s.True(ok) // cached transport should be the one that's used. - c.Assert(sessionTransport, Equals, t) + s.Equal(sessionTransport, t) session, err = newSession(cl, caEndpoint, nil) - c.Assert(err, IsNil) + s.NoError(err) sessionTransport = session.client.Transport.(*http.Transport) // transport that's going to be used should be cached already. - c.Assert(sessionTransport, Equals, t) + s.Equal(sessionTransport, t) // no new transport got cached. - c.Assert(cl.transports.Len(), Equals, 2) + s.Equal(2, cl.transports.Len()) // if the cache does not exist, the transport should still be correctly configured. cl.transports = nil session, err = newSession(cl, insecureEP, nil) - c.Assert(err, IsNil) + s.NoError(err) sessionTransport = session.client.Transport.(*http.Transport) - c.Assert(sessionTransport.TLSClientConfig.InsecureSkipVerify, Equals, true) + s.True(sessionTransport.TLSClientConfig.InsecureSkipVerify) } -func (s *ClientSuite) testNewHTTPError(c *C, code int, msg string) { +func (s *ClientSuite) testNewHTTPError(code int, msg string) { req, _ := http.NewRequest("GET", "foo", nil) res := &http.Response{ StatusCode: code, @@ -171,15 +172,15 @@ func (s *ClientSuite) testNewHTTPError(c *C, code int, msg string) { } err := NewErr(res) - c.Assert(err, NotNil) - c.Assert(err, ErrorMatches, msg) + s.NotNil(err) + s.Regexp(msg, err.Error()) } -func (s *ClientSuite) TestSetAuth(c *C) { +func (s *ClientSuite) TestSetAuth() { auth := &BasicAuth{} r, err := DefaultClient.NewUploadPackSession(s.Endpoint, auth) - c.Assert(err, IsNil) - c.Assert(auth, Equals, r.(*upSession).auth) + s.NoError(err) + s.Equal(auth, r.(*upSession).auth) } type mockAuth struct{} @@ -187,18 +188,18 @@ type mockAuth struct{} func (*mockAuth) Name() string { return "" } func (*mockAuth) String() string { return "" } -func (s *ClientSuite) TestSetAuthWrongType(c *C) { +func (s *ClientSuite) TestSetAuthWrongType() { _, err := DefaultClient.NewUploadPackSession(s.Endpoint, &mockAuth{}) - c.Assert(err, Equals, transport.ErrInvalidAuthMethod) + s.Equal(transport.ErrInvalidAuthMethod, err) } -func (s *ClientSuite) TestModifyEndpointIfRedirect(c *C) { +func (s *ClientSuite) TestModifyEndpointIfRedirect() { sess := &session{endpoint: nil} u, _ := url.Parse("https://example.com/info/refs") res := &http.Response{Request: &http.Request{URL: u}} - c.Assert(func() { + s.PanicsWithError("runtime error: invalid memory address or nil pointer dereference", func() { sess.ModifyEndpointIfRedirect(res) - }, PanicMatches, ".*nil pointer dereference.*") + }) sess = &session{endpoint: nil} // no-op - should return and not panic @@ -210,12 +211,16 @@ func (s *ClientSuite) TestModifyEndpointIfRedirect(c *C) { expected *transport.Endpoint }{ {"https://example.com/foo/bar", nil, nil}, - {"https://example.com/foo.git/info/refs", + { + "https://example.com/foo.git/info/refs", &transport.Endpoint{}, - &transport.Endpoint{Protocol: "https", Host: "example.com", Path: "/foo.git"}}, - {"https://example.com:8080/foo.git/info/refs", + &transport.Endpoint{Protocol: "https", Host: "example.com", Path: "/foo.git"}, + }, + { + "https://example.com:8080/foo.git/info/refs", &transport.Endpoint{}, - &transport.Endpoint{Protocol: "https", Host: "example.com", Port: 8080, Path: "/foo.git"}}, + &transport.Endpoint{Protocol: "https", Host: "example.com", Port: 8080, Path: "/foo.git"}, + }, } for _, d := range data { @@ -224,34 +229,34 @@ func (s *ClientSuite) TestModifyEndpointIfRedirect(c *C) { sess.ModifyEndpointIfRedirect(&http.Response{ Request: &http.Request{URL: u}, }) - c.Assert(d.endpoint, DeepEquals, d.expected) + s.Equal(d.expected, d.endpoint) } } type BaseSuite struct { - fixtures.Suite + suite.Suite base string host string port int } -func (s *BaseSuite) SetUpTest(c *C) { +func (s *BaseSuite) SetupTest() { l, err := net.Listen("tcp", "localhost:0") - c.Assert(err, IsNil) + s.NoError(err) - base, err := os.MkdirTemp(os.TempDir(), fmt.Sprintf("go-git-http-%d", s.port)) - c.Assert(err, IsNil) + base, err := os.MkdirTemp(s.T().TempDir(), fmt.Sprintf("go-git-http-%d", s.port)) + s.NoError(err) s.port = l.Addr().(*net.TCPAddr).Port s.base = filepath.Join(base, s.host) - err = os.MkdirAll(s.base, 0755) - c.Assert(err, IsNil) + err = os.MkdirAll(s.base, 0o755) + s.NoError(err) cmd := exec.Command("git", "--exec-path") out, err := cmd.CombinedOutput() - c.Assert(err, IsNil) + s.NoError(err) server := &http.Server{ Handler: &cgi.Handler{ @@ -264,27 +269,22 @@ func (s *BaseSuite) SetUpTest(c *C) { }() } -func (s *BaseSuite) prepareRepository(c *C, f *fixtures.Fixture, name string) *transport.Endpoint { +func (s *BaseSuite) prepareRepository(f *fixtures.Fixture, name string) *transport.Endpoint { fs := f.DotGit() err := fixtures.EnsureIsBare(fs) - c.Assert(err, IsNil) + s.NoError(err) path := filepath.Join(s.base, name) err = os.Rename(fs.Root(), path) - c.Assert(err, IsNil) + s.NoError(err) - return s.newEndpoint(c, name) + return s.newEndpoint(name) } -func (s *BaseSuite) newEndpoint(c *C, name string) *transport.Endpoint { +func (s *BaseSuite) newEndpoint(name string) *transport.Endpoint { ep, err := transport.NewEndpoint(fmt.Sprintf("http://localhost:%d/%s", s.port, name)) - c.Assert(err, IsNil) + s.NoError(err) return ep } - -func (s *BaseSuite) TearDownTest(c *C) { - err := os.RemoveAll(s.base) - c.Assert(err, IsNil) -} diff --git a/plumbing/transport/http/internal/test/proxy_test.go b/plumbing/transport/http/internal/test/proxy_test.go deleted file mode 100644 index 6ae2943b0..000000000 --- a/plumbing/transport/http/internal/test/proxy_test.go +++ /dev/null @@ -1,72 +0,0 @@ -package test - -import ( - "context" - "crypto/tls" - "fmt" - "net" - nethttp "net/http" - "os" - "sync/atomic" - "testing" - - "github.com/elazarl/goproxy" - - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/plumbing/transport/http" - - . "gopkg.in/check.v1" -) - -// Hook up gocheck into the "go test" runner. -func Test(t *testing.T) { TestingT(t) } - -type ProxySuite struct{} - -var _ = Suite(&ProxySuite{}) - -var proxiedRequests int32 - -// This test tests proxy support via an env var, i.e. `HTTPS_PROXY`. -// Its located in a separate package because golang caches the value -// of proxy env vars leading to misleading/unexpected test results. -func (s *ProxySuite) TestAdvertisedReferences(c *C) { - proxy := goproxy.NewProxyHttpServer() - proxy.Verbose = true - SetupHTTPSProxy(proxy, &proxiedRequests) - httpsListener, err := net.Listen("tcp", ":0") - c.Assert(err, IsNil) - defer httpsListener.Close() - httpProxyAddr := fmt.Sprintf("localhost:%d", httpsListener.Addr().(*net.TCPAddr).Port) - - proxyServer := nethttp.Server{ - Addr: httpProxyAddr, - Handler: proxy, - // Due to how golang manages http/2 when provided with custom TLS config, - // servers and clients running in the same process leads to issues. - // Ref: https://github.com/golang/go/issues/21336 - TLSConfig: &tls.Config{ - NextProtos: []string{"http/1.1"}, - }, - } - go proxyServer.ServeTLS(httpsListener, "../../testdata/certs/server.crt", "../../testdata/certs/server.key") - defer proxyServer.Close() - os.Setenv("HTTPS_PROXY", fmt.Sprintf("https://user:pass@%s", httpProxyAddr)) - defer os.Unsetenv("HTTPS_PROXY") - - endpoint, err := transport.NewEndpoint("https://github.com/git-fixtures/basic.git") - c.Assert(err, IsNil) - endpoint.InsecureSkipTLS = true - - client := http.DefaultClient - session, err := client.NewUploadPackSession(endpoint, nil) - c.Assert(err, IsNil) - - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - info, err := session.AdvertisedReferencesContext(ctx) - c.Assert(err, IsNil) - c.Assert(info, NotNil) - proxyUsed := atomic.LoadInt32(&proxiedRequests) > 0 - c.Assert(proxyUsed, Equals, true) -} diff --git a/plumbing/transport/http/internal/test/test_utils.go b/plumbing/transport/http/internal/test/test_utils.go deleted file mode 100644 index 6665fb3c6..000000000 --- a/plumbing/transport/http/internal/test/test_utils.go +++ /dev/null @@ -1,43 +0,0 @@ -package test - -import ( - "encoding/base64" - "strings" - "sync/atomic" - - "github.com/elazarl/goproxy" -) - -func SetupHTTPSProxy(proxy *goproxy.ProxyHttpServer, proxiedRequests *int32) { - var proxyHandler goproxy.FuncHttpsHandler = func(host string, ctx *goproxy.ProxyCtx) (*goproxy.ConnectAction, string) { - if strings.Contains(host, "github.com") { - user, pass, _ := ParseBasicAuth(ctx.Req.Header.Get("Proxy-Authorization")) - if user != "user" || pass != "pass" { - return goproxy.RejectConnect, host - } - atomic.AddInt32(proxiedRequests, 1) - return goproxy.OkConnect, host - } - // Reject if it isn't our request. - return goproxy.RejectConnect, host - } - proxy.OnRequest().HandleConnect(proxyHandler) -} - -// adapted from https://github.com/golang/go/blob/2ef70d9d0f98832c8103a7968b195e560a8bb262/src/net/http/request.go#L959 -func ParseBasicAuth(auth string) (username, password string, ok bool) { - const prefix = "Basic " - if len(auth) < len(prefix) || !strings.EqualFold(auth[:len(prefix)], prefix) { - return "", "", false - } - c, err := base64.StdEncoding.DecodeString(auth[len(prefix):]) - if err != nil { - return "", "", false - } - cs := string(c) - username, password, ok = strings.Cut(cs, ":") - if !ok { - return "", "", false - } - return username, password, true -} diff --git a/plumbing/transport/http/proxy_test.go b/plumbing/transport/http/proxy_test.go index f3024da92..5ea33cb8d 100644 --- a/plumbing/transport/http/proxy_test.go +++ b/plumbing/transport/http/proxy_test.go @@ -2,88 +2,64 @@ package http import ( "context" - "crypto/tls" - "fmt" - "net" - "net/http" - "strings" "sync/atomic" + "testing" "github.com/elazarl/goproxy" fixtures "github.com/go-git/go-git-fixtures/v4" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/plumbing/transport/http/internal/test" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/internal/transport/http/test" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/stretchr/testify/suite" ) -type ProxySuite struct { - u UploadPackSuite - fixtures.Suite +func TestProxySuite(t *testing.T) { + suite.Run(t, new(ProxySuite)) } -var _ = Suite(&ProxySuite{}) +type ProxySuite struct { + UploadPackSuite +} -var proxiedRequests int32 +func (s *ProxySuite) TestAdvertisedReferences() { + var proxiedRequests int32 -func (s *ProxySuite) TestAdvertisedReferences(c *C) { - s.u.SetUpTest(c) + s.SetupTest() proxy := goproxy.NewProxyHttpServer() proxy.Verbose = true - setupHTTPProxy(proxy, &proxiedRequests) - httpListener, err := net.Listen("tcp", ":0") - c.Assert(err, IsNil) - defer httpListener.Close() + test.SetupHTTPProxy(proxy, &proxiedRequests) - httpProxyAddr := fmt.Sprintf("http://localhost:%d", httpListener.Addr().(*net.TCPAddr).Port) - proxyServer := http.Server{ - Addr: httpProxyAddr, - Handler: proxy, - } - go proxyServer.Serve(httpListener) + httpProxyAddr, proxyServer, httpListener := test.SetupProxyServer(s.T(), proxy, false, true) + defer httpListener.Close() defer proxyServer.Close() - endpoint := s.u.prepareRepository(c, fixtures.Basic().One(), "basic.git") + endpoint := s.prepareRepository(fixtures.Basic().One(), "basic.git") endpoint.Proxy = transport.ProxyOptions{ URL: httpProxyAddr, Username: "user", Password: "pass", } - s.u.Client = NewClient(nil) - session, err := s.u.Client.NewUploadPackSession(endpoint, nil) - c.Assert(err, IsNil) + s.ups.Client = NewClient(nil) + session, err := s.ups.Client.NewUploadPackSession(endpoint, nil) + s.Nil(err) ctx, cancel := context.WithCancel(context.Background()) defer cancel() info, err := session.AdvertisedReferencesContext(ctx) - c.Assert(err, IsNil) - c.Assert(info, NotNil) + s.Nil(err) + s.NotNil(info) proxyUsed := atomic.LoadInt32(&proxiedRequests) > 0 - c.Assert(proxyUsed, Equals, true) + s.Equal(true, proxyUsed) atomic.StoreInt32(&proxiedRequests, 0) test.SetupHTTPSProxy(proxy, &proxiedRequests) - httpsListener, err := net.Listen("tcp", ":0") - c.Assert(err, IsNil) - defer httpsListener.Close() - httpsProxyAddr := fmt.Sprintf("https://localhost:%d", httpsListener.Addr().(*net.TCPAddr).Port) - tlsProxyServer := http.Server{ - Addr: httpsProxyAddr, - Handler: proxy, - // Due to how golang manages http/2 when provided with custom TLS config, - // servers and clients running in the same process leads to issues. - // Ref: https://github.com/golang/go/issues/21336 - TLSConfig: &tls.Config{ - NextProtos: []string{"http/1.1"}, - }, - } - go tlsProxyServer.ServeTLS(httpsListener, "testdata/certs/server.crt", "testdata/certs/server.key") + httpsProxyAddr, tlsProxyServer, httpsListener := test.SetupProxyServer(s.T(), proxy, true, true) + defer httpsListener.Close() defer tlsProxyServer.Close() endpoint, err = transport.NewEndpoint("https://github.com/git-fixtures/basic.git") - c.Assert(err, IsNil) + s.Nil(err) endpoint.Proxy = transport.ProxyOptions{ URL: httpsProxyAddr, Username: "user", @@ -91,29 +67,12 @@ func (s *ProxySuite) TestAdvertisedReferences(c *C) { } endpoint.InsecureSkipTLS = true - session, err = s.u.Client.NewUploadPackSession(endpoint, nil) - c.Assert(err, IsNil) + session, err = s.ups.Client.NewUploadPackSession(endpoint, nil) + s.Nil(err) info, err = session.AdvertisedReferencesContext(ctx) - c.Assert(err, IsNil) - c.Assert(info, NotNil) + s.Nil(err) + s.NotNil(info) proxyUsed = atomic.LoadInt32(&proxiedRequests) > 0 - c.Assert(proxyUsed, Equals, true) -} - -func setupHTTPProxy(proxy *goproxy.ProxyHttpServer, proxiedRequests *int32) { - // The request is being forwarded to the local test git server in this handler. - var proxyHandler goproxy.FuncReqHandler = func(req *http.Request, ctx *goproxy.ProxyCtx) (*http.Request, *http.Response) { - if strings.Contains(req.Host, "localhost") { - user, pass, _ := test.ParseBasicAuth(req.Header.Get("Proxy-Authorization")) - if user != "user" || pass != "pass" { - return req, goproxy.NewResponse(req, goproxy.ContentTypeText, http.StatusUnauthorized, "") - } - atomic.AddInt32(proxiedRequests, 1) - return req, nil - } - // Reject if it isn't our request. - return req, goproxy.NewResponse(req, goproxy.ContentTypeText, http.StatusForbidden, "") - } - proxy.OnRequest().Do(proxyHandler) + s.Equal(true, proxyUsed) } diff --git a/plumbing/transport/http/receive_pack.go b/plumbing/transport/http/receive_pack.go index 3e736cd95..5a7211cd7 100644 --- a/plumbing/transport/http/receive_pack.go +++ b/plumbing/transport/http/receive_pack.go @@ -7,12 +7,12 @@ import ( "io" "net/http" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/protocol/packp" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/sideband" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/utils/ioutil" ) type rpSession struct { diff --git a/plumbing/transport/http/receive_pack_test.go b/plumbing/transport/http/receive_pack_test.go index 7e70986a5..6369582d1 100644 --- a/plumbing/transport/http/receive_pack_test.go +++ b/plumbing/transport/http/receive_pack_test.go @@ -1,24 +1,29 @@ package http import ( - "github.com/go-git/go-git/v5/plumbing/transport/test" + "testing" + + "github.com/jesseduffield/go-git/v5/internal/transport/test" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) +func TestReceivePackSuite(t *testing.T) { + suite.Run(t, new(ReceivePackSuite)) +} + type ReceivePackSuite struct { - test.ReceivePackSuite + rps test.ReceivePackSuite BaseSuite } -var _ = Suite(&ReceivePackSuite{}) - -func (s *ReceivePackSuite) SetUpTest(c *C) { - s.BaseSuite.SetUpTest(c) +func (s *ReceivePackSuite) SetupTest() { + s.BaseSuite.SetupTest() - s.ReceivePackSuite.Client = DefaultClient - s.ReceivePackSuite.Endpoint = s.prepareRepository(c, fixtures.Basic().One(), "basic.git") - s.ReceivePackSuite.EmptyEndpoint = s.prepareRepository(c, fixtures.ByTag("empty").One(), "empty.git") - s.ReceivePackSuite.NonExistentEndpoint = s.newEndpoint(c, "non-existent.git") + s.rps.SetS(s) + s.rps.Client = DefaultClient + s.rps.Endpoint = s.prepareRepository(fixtures.Basic().One(), "basic.git") + s.rps.EmptyEndpoint = s.prepareRepository(fixtures.ByTag("empty").One(), "empty.git") + s.rps.NonExistentEndpoint = s.newEndpoint("non-existent.git") } diff --git a/plumbing/transport/http/upload_pack.go b/plumbing/transport/http/upload_pack.go index 3432618ab..abd474005 100644 --- a/plumbing/transport/http/upload_pack.go +++ b/plumbing/transport/http/upload_pack.go @@ -6,13 +6,14 @@ import ( "fmt" "io" "net/http" - - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/pktline" - "github.com/go-git/go-git/v5/plumbing/protocol/packp" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/plumbing/transport/internal/common" - "github.com/go-git/go-git/v5/utils/ioutil" + "time" + + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/utils/trace" ) type upSession struct { @@ -35,6 +36,10 @@ func (s *upSession) AdvertisedReferencesContext(ctx context.Context) (*packp.Adv func (s *upSession) UploadPack( ctx context.Context, req *packp.UploadPackRequest, ) (*packp.UploadPackResponse, error) { + start := time.Now() + defer func() { + trace.Performance.Printf("performance: %.9f s: upload_pack", time.Since(start).Seconds()) + }() if req.IsEmpty() { return nil, transport.ErrEmptyUploadPackRequest @@ -69,7 +74,7 @@ func (s *upSession) UploadPack( } rc := ioutil.NewReadCloser(r, res.Body) - return common.DecodeUploadPackResponse(rc, req) + return transport.DecodeUploadPackResponse(rc, req) } // Close does nothing. @@ -80,7 +85,6 @@ func (s *upSession) Close() error { func (s *upSession) doRequest( ctx context.Context, method, url string, content *bytes.Buffer, ) (*http.Response, error) { - var body io.Reader if content != nil { body = content @@ -108,8 +112,6 @@ func (s *upSession) doRequest( func uploadPackRequestToReader(req *packp.UploadPackRequest) (*bytes.Buffer, error) { buf := bytes.NewBuffer(nil) - e := pktline.NewEncoder(buf) - if err := req.UploadRequest.Encode(buf); err != nil { return nil, fmt.Errorf("sending upload-req message: %s", err) } @@ -118,7 +120,7 @@ func uploadPackRequestToReader(req *packp.UploadPackRequest) (*bytes.Buffer, err return nil, fmt.Errorf("sending haves message: %s", err) } - if err := e.EncodeString("done\n"); err != nil { + if _, err := pktline.Writef(buf, "done\n"); err != nil { return nil, err } diff --git a/plumbing/transport/http/upload_pack_test.go b/plumbing/transport/http/upload_pack_test.go index 3a1610a3f..4b4f1591d 100644 --- a/plumbing/transport/http/upload_pack_test.go +++ b/plumbing/transport/http/upload_pack_test.go @@ -7,51 +7,54 @@ import ( "net/url" "os" "path/filepath" + "testing" - . "github.com/go-git/go-git/v5/internal/test" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/protocol/packp" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/plumbing/transport/test" + "github.com/jesseduffield/go-git/v5/internal/transport/test" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) +func TestUploadPackSuite(t *testing.T) { + suite.Run(t, new(UploadPackSuite)) +} + type UploadPackSuite struct { - test.UploadPackSuite + ups test.UploadPackSuite BaseSuite } -var _ = Suite(&UploadPackSuite{}) - -func (s *UploadPackSuite) SetUpSuite(c *C) { - s.BaseSuite.SetUpTest(c) - s.UploadPackSuite.Client = DefaultClient - s.UploadPackSuite.Endpoint = s.prepareRepository(c, fixtures.Basic().One(), "basic.git") - s.UploadPackSuite.EmptyEndpoint = s.prepareRepository(c, fixtures.ByTag("empty").One(), "empty.git") - s.UploadPackSuite.NonExistentEndpoint = s.newEndpoint(c, "non-existent.git") +func (s *UploadPackSuite) SetupSuite() { + s.BaseSuite.SetupTest() + s.ups.SetS(s) + s.ups.Client = DefaultClient + s.ups.Endpoint = s.prepareRepository(fixtures.Basic().One(), "basic.git") + s.ups.EmptyEndpoint = s.prepareRepository(fixtures.ByTag("empty").One(), "empty.git") + s.ups.NonExistentEndpoint = s.newEndpoint("non-existent.git") } // Overwritten, different behaviour for HTTP. -func (s *UploadPackSuite) TestAdvertisedReferencesNotExists(c *C) { - r, err := s.Client.NewUploadPackSession(s.NonExistentEndpoint, s.EmptyAuth) - c.Assert(err, IsNil) +func (s *UploadPackSuite) TestAdvertisedReferencesNotExists() { + r, err := s.ups.Client.NewUploadPackSession(s.ups.NonExistentEndpoint, s.ups.EmptyAuth) + s.Nil(err) info, err := r.AdvertisedReferences() - c.Assert(err, ErrorIs, transport.ErrRepositoryNotFound) - c.Assert(info, IsNil) + s.ErrorIs(err, transport.ErrRepositoryNotFound) + s.Nil(info) } -func (s *UploadPackSuite) TestuploadPackRequestToReader(c *C) { +func (s *UploadPackSuite) TestuploadPackRequestToReader() { r := packp.NewUploadPackRequest() r.Wants = append(r.Wants, plumbing.NewHash("d82f291cde9987322c8a0c81a325e1ba6159684c")) r.Wants = append(r.Wants, plumbing.NewHash("2b41ef280fdb67a9b250678686a0c3e03b0a9989")) r.Haves = append(r.Haves, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) sr, err := uploadPackRequestToReader(r) - c.Assert(err, IsNil) + s.Nil(err) b, _ := io.ReadAll(sr) - c.Assert(string(b), Equals, + s.Equal(string(b), "0032want 2b41ef280fdb67a9b250678686a0c3e03b0a9989\n"+ "0032want d82f291cde9987322c8a0c81a325e1ba6159684c\n0000"+ "0032have 6ecf0ef2c2dffb796033e5a02219af86ec6584e5\n"+ @@ -59,83 +62,83 @@ func (s *UploadPackSuite) TestuploadPackRequestToReader(c *C) { ) } -func (s *UploadPackSuite) prepareRepository(c *C, f *fixtures.Fixture, name string) *transport.Endpoint { +func (s *UploadPackSuite) prepareRepository(f *fixtures.Fixture, name string) *transport.Endpoint { fs := f.DotGit() err := fixtures.EnsureIsBare(fs) - c.Assert(err, IsNil) + s.Nil(err) path := filepath.Join(s.base, name) err = os.Rename(fs.Root(), path) - c.Assert(err, IsNil) + s.Nil(err) - return s.newEndpoint(c, name) + return s.newEndpoint(name) } -func (s *UploadPackSuite) newEndpoint(c *C, name string) *transport.Endpoint { +func (s *UploadPackSuite) newEndpoint(name string) *transport.Endpoint { ep, err := transport.NewEndpoint(fmt.Sprintf("http://localhost:%d/%s", s.port, name)) - c.Assert(err, IsNil) + s.Nil(err) return ep } -func (s *UploadPackSuite) TestAdvertisedReferencesRedirectPath(c *C) { +func (s *UploadPackSuite) TestAdvertisedReferencesRedirectPath() { endpoint, _ := transport.NewEndpoint("https://gitlab.com/gitlab-org/gitter/webapp") - session, err := s.Client.NewUploadPackSession(endpoint, s.EmptyAuth) - c.Assert(err, IsNil) + session, err := s.ups.Client.NewUploadPackSession(endpoint, s.ups.EmptyAuth) + s.Require().NoError(err) info, err := session.AdvertisedReferences() - c.Assert(err, IsNil) - c.Assert(info, NotNil) + s.Require().NoError(err) + s.Require().NotNil(info) url := session.(*upSession).endpoint.String() - c.Assert(url, Equals, "https://gitlab.com/gitlab-org/gitter/webapp.git") + s.Equal("https://gitlab.com/gitlab-org/gitter/webapp.git", url) } -func (s *UploadPackSuite) TestAdvertisedReferencesRedirectSchema(c *C) { +func (s *UploadPackSuite) TestAdvertisedReferencesRedirectSchema() { endpoint, _ := transport.NewEndpoint("http://github.com/git-fixtures/basic") - session, err := s.Client.NewUploadPackSession(endpoint, s.EmptyAuth) - c.Assert(err, IsNil) + session, err := s.ups.Client.NewUploadPackSession(endpoint, s.ups.EmptyAuth) + s.Require().NoError(err) info, err := session.AdvertisedReferences() - c.Assert(err, IsNil) - c.Assert(info, NotNil) + s.Require().NoError(err) + s.Require().NotNil(info) url := session.(*upSession).endpoint.String() - c.Assert(url, Equals, "https://github.com/git-fixtures/basic") + s.Equal("https://github.com/git-fixtures/basic", url) } -func (s *UploadPackSuite) TestAdvertisedReferencesContext(c *C) { +func (s *UploadPackSuite) TestAdvertisedReferencesContext() { ctx, cancel := context.WithCancel(context.Background()) defer cancel() endpoint, _ := transport.NewEndpoint("http://github.com/git-fixtures/basic") - session, err := s.Client.NewUploadPackSession(endpoint, s.EmptyAuth) - c.Assert(err, IsNil) + session, err := s.ups.Client.NewUploadPackSession(endpoint, s.ups.EmptyAuth) + s.Require().NoError(err) info, err := session.AdvertisedReferencesContext(ctx) - c.Assert(err, IsNil) - c.Assert(info, NotNil) + s.Require().NoError(err) + s.Require().NotNil(info) url := session.(*upSession).endpoint.String() - c.Assert(url, Equals, "https://github.com/git-fixtures/basic") + s.Equal("https://github.com/git-fixtures/basic", url) } -func (s *UploadPackSuite) TestAdvertisedReferencesContextCanceled(c *C) { +func (s *UploadPackSuite) TestAdvertisedReferencesContextCanceled() { ctx, cancel := context.WithCancel(context.Background()) cancel() endpoint, _ := transport.NewEndpoint("http://github.com/git-fixtures/basic") - session, err := s.Client.NewUploadPackSession(endpoint, s.EmptyAuth) - c.Assert(err, IsNil) + session, err := s.ups.Client.NewUploadPackSession(endpoint, s.ups.EmptyAuth) + s.Require().NoError(err) info, err := session.AdvertisedReferencesContext(ctx) - c.Assert(err, DeepEquals, &url.Error{Op: "Get", URL: "http://github.com/git-fixtures/basic/info/refs?service=git-upload-pack", Err: context.Canceled}) - c.Assert(info, IsNil) + s.Equal(&url.Error{Op: "Get", URL: "http://github.com/git-fixtures/basic/info/refs?service=git-upload-pack", Err: context.Canceled}, err) + s.Nil(info) } -func (s *UploadPackSuite) TestUploadPackWithContextOnRead(c *C) { - c.Skip("flaky tests, looks like sometimes the request body is cached, so doesn't fail on context cancel") +func (s *UploadPackSuite) TestUploadPackWithContextOnRead() { + s.T().Skip("flaky tests, looks like sometimes the request body is cached, so doesn't fail on context cancel") } diff --git a/plumbing/transport/internal/common/common.go b/plumbing/transport/internal/common/common.go deleted file mode 100644 index 9e1d02357..000000000 --- a/plumbing/transport/internal/common/common.go +++ /dev/null @@ -1,492 +0,0 @@ -// Package common implements the git pack protocol with a pluggable transport. -// This is a low-level package to implement new transports. Use a concrete -// implementation instead (e.g. http, file, ssh). -// -// A simple example of usage can be found in the file package. -package common - -import ( - "bufio" - "context" - "errors" - "fmt" - "io" - "regexp" - "strings" - "time" - - "github.com/go-git/go-git/v5/plumbing/format/pktline" - "github.com/go-git/go-git/v5/plumbing/protocol/packp" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/utils/ioutil" -) - -const ( - readErrorSecondsTimeout = 10 -) - -var ( - ErrTimeoutExceeded = errors.New("timeout exceeded") - // stdErrSkipPattern is used for skipping lines from a command's stderr output. - // Any line matching this pattern will be skipped from further - // processing and not be returned to calling code. - stdErrSkipPattern = regexp.MustCompile("^remote:( =*){0,1}$") -) - -// Commander creates Command instances. This is the main entry point for -// transport implementations. -type Commander interface { - // Command creates a new Command for the given git command and - // endpoint. cmd can be git-upload-pack or git-receive-pack. An - // error should be returned if the endpoint is not supported or the - // command cannot be created (e.g. binary does not exist, connection - // cannot be established). - Command(cmd string, ep *transport.Endpoint, auth transport.AuthMethod) (Command, error) -} - -// Command is used for a single command execution. -// This interface is modeled after exec.Cmd and ssh.Session in the standard -// library. -type Command interface { - // StderrPipe returns a pipe that will be connected to the command's - // standard error when the command starts. It should not be called after - // Start. - StderrPipe() (io.Reader, error) - // StdinPipe returns a pipe that will be connected to the command's - // standard input when the command starts. It should not be called after - // Start. The pipe should be closed when no more input is expected. - StdinPipe() (io.WriteCloser, error) - // StdoutPipe returns a pipe that will be connected to the command's - // standard output when the command starts. It should not be called after - // Start. - StdoutPipe() (io.Reader, error) - // Start starts the specified command. It does not wait for it to - // complete. - Start() error - // Close closes the command and releases any resources used by it. It - // will block until the command exits. - Close() error -} - -// CommandKiller expands the Command interface, enabling it for being killed. -type CommandKiller interface { - // Kill and close the session whatever the state it is. It will block until - // the command is terminated. - Kill() error -} - -type client struct { - cmdr Commander -} - -// NewClient creates a new client using the given Commander. -func NewClient(runner Commander) transport.Transport { - return &client{runner} -} - -// NewUploadPackSession creates a new UploadPackSession. -func (c *client) NewUploadPackSession(ep *transport.Endpoint, auth transport.AuthMethod) ( - transport.UploadPackSession, error) { - - return c.newSession(transport.UploadPackServiceName, ep, auth) -} - -// NewReceivePackSession creates a new ReceivePackSession. -func (c *client) NewReceivePackSession(ep *transport.Endpoint, auth transport.AuthMethod) ( - transport.ReceivePackSession, error) { - - return c.newSession(transport.ReceivePackServiceName, ep, auth) -} - -type session struct { - Stdin io.WriteCloser - Stdout io.Reader - Command Command - - isReceivePack bool - advRefs *packp.AdvRefs - packRun bool - finished bool - firstErrLine chan string -} - -func (c *client) newSession(s string, ep *transport.Endpoint, auth transport.AuthMethod) (*session, error) { - cmd, err := c.cmdr.Command(s, ep, auth) - if err != nil { - return nil, err - } - - stdin, err := cmd.StdinPipe() - if err != nil { - return nil, err - } - - stdout, err := cmd.StdoutPipe() - if err != nil { - return nil, err - } - - stderr, err := cmd.StderrPipe() - if err != nil { - return nil, err - } - - if err := cmd.Start(); err != nil { - return nil, err - } - - return &session{ - Stdin: stdin, - Stdout: stdout, - Command: cmd, - firstErrLine: c.listenFirstError(stderr), - isReceivePack: s == transport.ReceivePackServiceName, - }, nil -} - -func (c *client) listenFirstError(r io.Reader) chan string { - if r == nil { - return nil - } - - errLine := make(chan string, 1) - go func() { - s := bufio.NewScanner(r) - for { - if s.Scan() { - line := s.Text() - if !stdErrSkipPattern.MatchString(line) { - errLine <- line - break - } - } else { - close(errLine) - break - } - } - - _, _ = io.Copy(io.Discard, r) - }() - - return errLine -} - -func (s *session) AdvertisedReferences() (*packp.AdvRefs, error) { - return s.AdvertisedReferencesContext(context.TODO()) -} - -// AdvertisedReferences retrieves the advertised references from the server. -func (s *session) AdvertisedReferencesContext(ctx context.Context) (*packp.AdvRefs, error) { - if s.advRefs != nil { - return s.advRefs, nil - } - - ar := packp.NewAdvRefs() - if err := ar.Decode(s.StdoutContext(ctx)); err != nil { - if err := s.handleAdvRefDecodeError(err); err != nil { - return nil, err - } - } - - // Some servers like jGit, announce capabilities instead of returning an - // packp message with a flush. This verifies that we received a empty - // adv-refs, even it contains capabilities. - if !s.isReceivePack && ar.IsEmpty() { - return nil, transport.ErrEmptyRemoteRepository - } - - transport.FilterUnsupportedCapabilities(ar.Capabilities) - s.advRefs = ar - return ar, nil -} - -func (s *session) handleAdvRefDecodeError(err error) error { - var errLine *pktline.ErrorLine - if errors.As(err, &errLine) { - if isRepoNotFoundError(errLine.Text) { - return transport.ErrRepositoryNotFound - } - - return errLine - } - - // If repository is not found, we get empty stdout and server writes an - // error to stderr. - if errors.Is(err, packp.ErrEmptyInput) { - // TODO:(v6): handle this error in a better way. - // Instead of checking the stderr output for a specific error message, - // define an ExitError and embed the stderr output and exit (if one - // exists) in the error struct. Just like exec.ExitError. - s.finished = true - if err := s.checkNotFoundError(); err != nil { - return err - } - - return io.ErrUnexpectedEOF - } - - // For empty (but existing) repositories, we get empty advertised-references - // message. But valid. That is, it includes at least a flush. - if err == packp.ErrEmptyAdvRefs { - // Empty repositories are valid for git-receive-pack. - if s.isReceivePack { - return nil - } - - if err := s.finish(); err != nil { - return err - } - - return transport.ErrEmptyRemoteRepository - } - - // Some server sends the errors as normal content (git protocol), so when - // we try to decode it fails, we need to check the content of it, to detect - // not found errors - if uerr, ok := err.(*packp.ErrUnexpectedData); ok { - if isRepoNotFoundError(string(uerr.Data)) { - return transport.ErrRepositoryNotFound - } - } - - return err -} - -// UploadPack performs a request to the server to fetch a packfile. A reader is -// returned with the packfile content. The reader must be closed after reading. -func (s *session) UploadPack(ctx context.Context, req *packp.UploadPackRequest) (*packp.UploadPackResponse, error) { - if req.IsEmpty() { - // XXX: IsEmpty means haves are a subset of wants, in that case we have - // everything we asked for. Close the connection and return nil. - if err := s.finish(); err != nil { - return nil, err - } - // TODO:(v6) return nil here - return nil, transport.ErrEmptyUploadPackRequest - } - - if err := req.Validate(); err != nil { - return nil, err - } - - if _, err := s.AdvertisedReferencesContext(ctx); err != nil { - return nil, err - } - - s.packRun = true - - in := s.StdinContext(ctx) - out := s.StdoutContext(ctx) - - if err := uploadPack(in, out, req); err != nil { - return nil, err - } - - r, err := ioutil.NonEmptyReader(out) - if err == ioutil.ErrEmptyReader { - if c, ok := s.Stdout.(io.Closer); ok { - _ = c.Close() - } - - return nil, transport.ErrEmptyUploadPackRequest - } - - if err != nil { - return nil, err - } - - rc := ioutil.NewReadCloser(r, s) - return DecodeUploadPackResponse(rc, req) -} - -func (s *session) StdinContext(ctx context.Context) io.WriteCloser { - return ioutil.NewWriteCloserOnError( - ioutil.NewContextWriteCloser(ctx, s.Stdin), - s.onError, - ) -} - -func (s *session) StdoutContext(ctx context.Context) io.Reader { - return ioutil.NewReaderOnError( - ioutil.NewContextReader(ctx, s.Stdout), - s.onError, - ) -} - -func (s *session) onError(err error) { - if k, ok := s.Command.(CommandKiller); ok { - _ = k.Kill() - } - - _ = s.Close() -} - -func (s *session) ReceivePack(ctx context.Context, req *packp.ReferenceUpdateRequest) (*packp.ReportStatus, error) { - if _, err := s.AdvertisedReferences(); err != nil { - return nil, err - } - - s.packRun = true - - w := s.StdinContext(ctx) - if err := req.Encode(w); err != nil { - return nil, err - } - - if err := w.Close(); err != nil { - return nil, err - } - - if !req.Capabilities.Supports(capability.ReportStatus) { - // If we don't have report-status, we can only - // check return value error. - return nil, s.Command.Close() - } - - r := s.StdoutContext(ctx) - - var d *sideband.Demuxer - if req.Capabilities.Supports(capability.Sideband64k) { - d = sideband.NewDemuxer(sideband.Sideband64k, r) - } else if req.Capabilities.Supports(capability.Sideband) { - d = sideband.NewDemuxer(sideband.Sideband, r) - } - if d != nil { - d.Progress = req.Progress - r = d - } - - report := packp.NewReportStatus() - if err := report.Decode(r); err != nil { - return nil, err - } - - if err := report.Error(); err != nil { - defer s.Close() - return report, err - } - - return report, s.Command.Close() -} - -func (s *session) finish() error { - if s.finished { - return nil - } - - s.finished = true - - // If we did not run a upload/receive-pack, we close the connection - // gracefully by sending a flush packet to the server. If the server - // operates correctly, it will exit with status 0. - if !s.packRun { - _, err := s.Stdin.Write(pktline.FlushPkt) - return err - } - - return nil -} - -func (s *session) Close() (err error) { - err = s.finish() - - defer ioutil.CheckClose(s.Command, &err) - return -} - -func (s *session) checkNotFoundError() error { - t := time.NewTicker(time.Second * readErrorSecondsTimeout) - defer t.Stop() - - select { - case <-t.C: - return ErrTimeoutExceeded - case line, ok := <-s.firstErrLine: - if !ok || len(line) == 0 { - return nil - } - - if isRepoNotFoundError(line) { - return transport.ErrRepositoryNotFound - } - - // TODO:(v6): return server error just as it is without a prefix - return fmt.Errorf("unknown error: %s", line) - } -} - -const ( - githubRepoNotFoundErr = "Repository not found." - bitbucketRepoNotFoundErr = "repository does not exist." - localRepoNotFoundErr = "does not appear to be a git repository" - gitProtocolNotFoundErr = "Repository not found." - gitProtocolNoSuchErr = "no such repository" - gitProtocolAccessDeniedErr = "access denied" - gogsAccessDeniedErr = "Repository does not exist or you do not have access" - gitlabRepoNotFoundErr = "The project you were looking for could not be found" -) - -func isRepoNotFoundError(s string) bool { - for _, err := range []string{ - githubRepoNotFoundErr, - bitbucketRepoNotFoundErr, - localRepoNotFoundErr, - gitProtocolNotFoundErr, - gitProtocolNoSuchErr, - gitProtocolAccessDeniedErr, - gogsAccessDeniedErr, - gitlabRepoNotFoundErr, - } { - if strings.Contains(s, err) { - return true - } - } - - return false -} - -// uploadPack implements the git-upload-pack protocol. -func uploadPack(w io.WriteCloser, _ io.Reader, req *packp.UploadPackRequest) error { - // TODO support multi_ack mode - // TODO support multi_ack_detailed mode - // TODO support acks for common objects - // TODO build a proper state machine for all these processing options - - if err := req.UploadRequest.Encode(w); err != nil { - return fmt.Errorf("sending upload-req message: %s", err) - } - - if err := req.UploadHaves.Encode(w, true); err != nil { - return fmt.Errorf("sending haves message: %s", err) - } - - if err := sendDone(w); err != nil { - return fmt.Errorf("sending done message: %s", err) - } - - if err := w.Close(); err != nil { - return fmt.Errorf("closing input: %s", err) - } - - return nil -} - -func sendDone(w io.Writer) error { - e := pktline.NewEncoder(w) - - return e.Encodef("done\n") -} - -// DecodeUploadPackResponse decodes r into a new packp.UploadPackResponse -func DecodeUploadPackResponse(r io.ReadCloser, req *packp.UploadPackRequest) ( - *packp.UploadPackResponse, error, -) { - res := packp.NewUploadPackResponse(req) - if err := res.Decode(r); err != nil { - return nil, fmt.Errorf("error decoding upload-pack response: %s", err) - } - - return res, nil -} diff --git a/plumbing/transport/internal/common/common_test.go b/plumbing/transport/internal/common/common_test.go deleted file mode 100644 index 9344bb62b..000000000 --- a/plumbing/transport/internal/common/common_test.go +++ /dev/null @@ -1,93 +0,0 @@ -package common - -import ( - "fmt" - "testing" - - "github.com/go-git/go-git/v5/plumbing/transport" - . "gopkg.in/check.v1" -) - -func Test(t *testing.T) { TestingT(t) } - -type CommonSuite struct{} - -var _ = Suite(&CommonSuite{}) - -func (s *CommonSuite) TestIsRepoNotFoundErrorForUnknownSource(c *C) { - msg := "unknown system is complaining of something very sad :(" - - isRepoNotFound := isRepoNotFoundError(msg) - - c.Assert(isRepoNotFound, Equals, false) -} - -func (s *CommonSuite) TestIsRepoNotFoundError(c *C) { - msg := "no such repository : some error stuf" - - isRepoNotFound := isRepoNotFoundError(msg) - - c.Assert(isRepoNotFound, Equals, true) -} - -func (s *CommonSuite) TestCheckNotFoundError(c *C) { - firstErrLine := make(chan string, 1) - - session := session{ - firstErrLine: firstErrLine, - } - - firstErrLine <- "" - - err := session.checkNotFoundError() - - c.Assert(err, IsNil) -} - -func TestAdvertisedReferencesWithRemoteError(t *testing.T) { - tests := []struct { - name string - stderr string - wantErr error - }{ - { - name: "unknown error", - stderr: "something", - wantErr: fmt.Errorf("unknown error: something"), - }, - { - name: "GitLab: repository not found", - stderr: `remote: -remote: ======================================================================== -remote: -remote: ERROR: The project you were looking for could not be found or you don't have permission to view it. - -remote: -remote: ======================================================================== -remote:`, - wantErr: transport.ErrRepositoryNotFound, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - client := NewClient(MockCommander{stderr: tt.stderr}) - sess, err := client.NewUploadPackSession(nil, nil) - if err != nil { - t.Fatalf("unexpected error: %s", err) - } - - _, err = sess.AdvertisedReferences() - - if tt.wantErr != nil { - if tt.wantErr != err { - if tt.wantErr.Error() != err.Error() { - t.Fatalf("expected a different error: got '%s', expected '%s'", err, tt.wantErr) - } - } - } else if err != nil { - t.Fatalf("unexpected error: %s", err) - } - }) - } -} diff --git a/plumbing/transport/internal/common/mocks.go b/plumbing/transport/internal/common/mocks.go deleted file mode 100644 index bc18b27e8..000000000 --- a/plumbing/transport/internal/common/mocks.go +++ /dev/null @@ -1,46 +0,0 @@ -package common - -import ( - "bytes" - "io" - - gogitioutil "github.com/go-git/go-git/v5/utils/ioutil" - - "github.com/go-git/go-git/v5/plumbing/transport" -) - -type MockCommand struct { - stdin bytes.Buffer - stdout bytes.Buffer - stderr bytes.Buffer -} - -func (c MockCommand) StderrPipe() (io.Reader, error) { - return &c.stderr, nil -} - -func (c MockCommand) StdinPipe() (io.WriteCloser, error) { - return gogitioutil.WriteNopCloser(&c.stdin), nil -} - -func (c MockCommand) StdoutPipe() (io.Reader, error) { - return &c.stdout, nil -} - -func (c MockCommand) Start() error { - return nil -} - -func (c MockCommand) Close() error { - panic("not implemented") -} - -type MockCommander struct { - stderr string -} - -func (c MockCommander) Command(cmd string, ep *transport.Endpoint, auth transport.AuthMethod) (Command, error) { - return &MockCommand{ - stderr: *bytes.NewBufferString(c.stderr), - }, nil -} diff --git a/plumbing/transport/mocks.go b/plumbing/transport/mocks.go new file mode 100644 index 000000000..557eb9d31 --- /dev/null +++ b/plumbing/transport/mocks.go @@ -0,0 +1,44 @@ +package transport + +import ( + "bytes" + "io" + + "github.com/jesseduffield/go-git/v5/utils/ioutil" +) + +type mockCommand struct { + stdin bytes.Buffer + stdout bytes.Buffer + stderr bytes.Buffer +} + +func (c mockCommand) StderrPipe() (io.Reader, error) { + return &c.stderr, nil +} + +func (c mockCommand) StdinPipe() (io.WriteCloser, error) { + return ioutil.WriteNopCloser(&c.stdin), nil +} + +func (c mockCommand) StdoutPipe() (io.Reader, error) { + return &c.stdout, nil +} + +func (c mockCommand) Start() error { + return nil +} + +func (c mockCommand) Close() error { + panic("not implemented") +} + +type mockCommander struct { + stderr string +} + +func (c mockCommander) Command(cmd string, ep *Endpoint, auth AuthMethod) (Command, error) { + return &mockCommand{ + stderr: *bytes.NewBufferString(c.stderr), + }, nil +} diff --git a/plumbing/transport/registry.go b/plumbing/transport/registry.go new file mode 100644 index 000000000..934830371 --- /dev/null +++ b/plumbing/transport/registry.go @@ -0,0 +1,40 @@ +package transport + +import ( + "fmt" + "sync" +) + +// registry are the protocols supported by default. +var ( + registry = map[string]Transport{} + mtx sync.Mutex +) + +// Register adds or modifies an existing protocol. +// Equivalent to client.InstallProtocol in go-git before V6. +func Register(protocol string, c Transport) { + mtx.Lock() + registry[protocol] = c + mtx.Unlock() +} + +// Unregister removes a protocol from the list of supported protocols. +func Unregister(scheme string) { + mtx.Lock() + delete(registry, scheme) + mtx.Unlock() +} + +// Get returns the appropriate client for the given protocol. +func Get(p string) (Transport, error) { + f, ok := registry[p] + if !ok { + return nil, fmt.Errorf("unsupported scheme %q", p) + } + + if f == nil { + return nil, fmt.Errorf("malformed client for scheme %q, client is defined as nil", p) + } + return f, nil +} diff --git a/plumbing/transport/registry_test.go b/plumbing/transport/registry_test.go new file mode 100644 index 000000000..27149ca2a --- /dev/null +++ b/plumbing/transport/registry_test.go @@ -0,0 +1,76 @@ +package transport_test + +import ( + "net/http" + "testing" + + _ "github.com/jesseduffield/go-git/v5/plumbing/transport/ssh" // ssh transport + "github.com/stretchr/testify/suite" + + "github.com/jesseduffield/go-git/v5/plumbing/transport" +) + +func TestSuiteCommon(t *testing.T) { + suite.Run(t, new(ClientSuite)) +} + +type ClientSuite struct { + suite.Suite +} + +func (s *ClientSuite) TestNewClientSSH() { + e, err := transport.NewEndpoint("ssh://github.com/src-d/go-git") + s.Require().NoError(err) + + output, err := transport.Get(e.Protocol) + s.Require().NoError(err) + s.NotNil(output) +} + +func (s *ClientSuite) TestNewClientUnknown() { + e, err := transport.NewEndpoint("unknown://github.com/src-d/go-git") + s.Require().NoError(err) + + _, err = transport.Get(e.Protocol) + s.Error(err) +} + +func (s *ClientSuite) TestNewClientNil() { + transport.Register("newscheme", nil) + e, err := transport.NewEndpoint("newscheme://github.com/src-d/go-git") + s.Require().NoError(err) + + _, err = transport.Get(e.Protocol) + s.Error(err) +} + +func (s *ClientSuite) TestInstallProtocol() { + transport.Register("newscheme", &dummyClient{}) + p, err := transport.Get("newscheme") + s.Require().NoError(err) + s.NotNil(p) +} + +func (s *ClientSuite) TestInstallProtocolNilValue() { + transport.Register("newscheme", &dummyClient{}) + transport.Unregister("newscheme") + + _, err := transport.Get("newscheme") + s.Error(err) +} + +type dummyClient struct { + *http.Client +} + +func (*dummyClient) NewUploadPackSession(*transport.Endpoint, transport.AuthMethod) ( + transport.UploadPackSession, error, +) { + return nil, nil +} + +func (*dummyClient) NewReceivePackSession(*transport.Endpoint, transport.AuthMethod) ( + transport.ReceivePackSession, error, +) { + return nil, nil +} diff --git a/plumbing/transport/server/loader_test.go b/plumbing/transport/server/loader_test.go deleted file mode 100644 index 88f040348..000000000 --- a/plumbing/transport/server/loader_test.go +++ /dev/null @@ -1,72 +0,0 @@ -package server - -import ( - "os/exec" - "path/filepath" - - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/storage/memory" - - . "gopkg.in/check.v1" -) - -type LoaderSuite struct { - RepoPath string -} - -var _ = Suite(&LoaderSuite{}) - -func (s *LoaderSuite) SetUpSuite(c *C) { - if err := exec.Command("git", "--version").Run(); err != nil { - c.Skip("git command not found") - } - - dir := c.MkDir() - s.RepoPath = filepath.Join(dir, "repo.git") - c.Assert(exec.Command("git", "init", "--bare", s.RepoPath).Run(), IsNil) -} - -func (s *LoaderSuite) endpoint(c *C, url string) *transport.Endpoint { - ep, err := transport.NewEndpoint(url) - c.Assert(err, IsNil) - return ep -} - -func (s *LoaderSuite) TestLoadNonExistent(c *C) { - sto, err := DefaultLoader.Load(s.endpoint(c, "does-not-exist")) - c.Assert(err, Equals, transport.ErrRepositoryNotFound) - c.Assert(sto, IsNil) -} - -func (s *LoaderSuite) TestLoadNonExistentIgnoreHost(c *C) { - sto, err := DefaultLoader.Load(s.endpoint(c, "https://github.com/does-not-exist")) - c.Assert(err, Equals, transport.ErrRepositoryNotFound) - c.Assert(sto, IsNil) -} - -func (s *LoaderSuite) TestLoad(c *C) { - sto, err := DefaultLoader.Load(s.endpoint(c, s.RepoPath)) - c.Assert(err, IsNil) - c.Assert(sto, NotNil) -} - -func (s *LoaderSuite) TestLoadIgnoreHost(c *C) { - sto, err := DefaultLoader.Load(s.endpoint(c, s.RepoPath)) - c.Assert(err, IsNil) - c.Assert(sto, NotNil) -} - -func (s *LoaderSuite) TestMapLoader(c *C) { - ep, err := transport.NewEndpoint("file://test") - sto := memory.NewStorage() - c.Assert(err, IsNil) - - loader := MapLoader{ep.String(): sto} - - ep, err = transport.NewEndpoint("file://test") - c.Assert(err, IsNil) - - loaderSto, err := loader.Load(ep) - c.Assert(err, IsNil) - c.Assert(sto, Equals, loaderSto) -} diff --git a/plumbing/transport/server/upload_pack_test.go b/plumbing/transport/server/upload_pack_test.go deleted file mode 100644 index cf91ffab5..000000000 --- a/plumbing/transport/server/upload_pack_test.go +++ /dev/null @@ -1,50 +0,0 @@ -package server_test - -import ( - "github.com/go-git/go-git/v5/plumbing/transport" - - . "gopkg.in/check.v1" -) - -type UploadPackSuite struct { - BaseSuite -} - -var _ = Suite(&UploadPackSuite{}) - -func (s *UploadPackSuite) SetUpSuite(c *C) { - s.BaseSuite.SetUpSuite(c) - s.Client = s.client -} - -func (s *UploadPackSuite) SetUpTest(c *C) { - s.prepareRepositories(c) -} - -// Overwritten, server returns error earlier. -func (s *UploadPackSuite) TestAdvertisedReferencesNotExists(c *C) { - r, err := s.Client.NewUploadPackSession(s.NonExistentEndpoint, s.EmptyAuth) - c.Assert(err, Equals, transport.ErrRepositoryNotFound) - c.Assert(r, IsNil) -} - -func (s *UploadPackSuite) TestUploadPackWithContext(c *C) { - c.Skip("UploadPack cannot be canceled on server") -} - -// Tests server with `asClient = true`. This is recommended when using a server -// registered directly with `client.InstallProtocol`. -type ClientLikeUploadPackSuite struct { - UploadPackSuite -} - -var _ = Suite(&ClientLikeUploadPackSuite{}) - -func (s *ClientLikeUploadPackSuite) SetUpSuite(c *C) { - s.asClient = true - s.UploadPackSuite.SetUpSuite(c) -} - -func (s *ClientLikeUploadPackSuite) TestAdvertisedReferencesEmpty(c *C) { - s.UploadPackSuite.TestAdvertisedReferencesEmpty(c) -} diff --git a/plumbing/transport/ssh/auth_method.go b/plumbing/transport/ssh/auth_method.go index f9c598e6f..ff0b8cf12 100644 --- a/plumbing/transport/ssh/auth_method.go +++ b/plumbing/transport/ssh/auth_method.go @@ -3,14 +3,16 @@ package ssh import ( "errors" "fmt" + "net" "os" "os/user" "path/filepath" - "github.com/go-git/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/plumbing/transport/ssh/knownhosts" + "github.com/jesseduffield/go-git/v5/plumbing/transport/ssh/sshagent" + "github.com/jesseduffield/go-git/v5/utils/trace" - "github.com/skeema/knownhosts" - sshagent "github.com/xanzy/ssh-agent" "golang.org/x/crypto/ssh" ) @@ -54,6 +56,7 @@ func (a *KeyboardInteractive) String() string { } func (a *KeyboardInteractive) ClientConfig() (*ssh.ClientConfig, error) { + trace.SSH.Printf("ssh: %s user=%s", KeyboardInteractiveName, a.User) return a.SetHostKeyCallback(&ssh.ClientConfig{ User: a.User, Auth: []ssh.AuthMethod{ @@ -78,6 +81,7 @@ func (a *Password) String() string { } func (a *Password) ClientConfig() (*ssh.ClientConfig, error) { + trace.SSH.Printf("ssh: %s user=%s", PasswordName, a.User) return a.SetHostKeyCallback(&ssh.ClientConfig{ User: a.User, Auth: []ssh.AuthMethod{ssh.Password(a.Password)}, @@ -101,6 +105,7 @@ func (a *PasswordCallback) String() string { } func (a *PasswordCallback) ClientConfig() (*ssh.ClientConfig, error) { + trace.SSH.Printf("ssh: %s user=%s", PasswordCallbackName, a.User) return a.SetHostKeyCallback(&ssh.ClientConfig{ User: a.User, Auth: []ssh.AuthMethod{ssh.PasswordCallback(a.Callback)}, @@ -150,6 +155,9 @@ func (a *PublicKeys) String() string { } func (a *PublicKeys) ClientConfig() (*ssh.ClientConfig, error) { + trace.SSH.Printf("ssh: %s user=%s signer=\"%s %s\"", PublicKeysName, a.User, + a.Signer.PublicKey().Type(), + ssh.FingerprintSHA256(a.Signer.PublicKey())) return a.SetHostKeyCallback(&ssh.ClientConfig{ User: a.User, Auth: []ssh.AuthMethod{ssh.PublicKeys(a.Signer)}, @@ -160,8 +168,10 @@ func username() (string, error) { var username string if user, err := user.Current(); err == nil { username = user.Username + trace.SSH.Printf("ssh: Falling back to current user name %q", username) } else { username = os.Getenv("USER") + trace.SSH.Printf("ssh: Falling back to environment variable USER %q", username) } if username == "" { @@ -211,9 +221,10 @@ func (a *PublicKeysCallback) String() string { } func (a *PublicKeysCallback) ClientConfig() (*ssh.ClientConfig, error) { + trace.SSH.Printf("ssh: %s user=%s", PublicKeysCallbackName, a.User) return a.SetHostKeyCallback(&ssh.ClientConfig{ User: a.User, - Auth: []ssh.AuthMethod{ssh.PublicKeysCallback(a.Callback)}, + Auth: []ssh.AuthMethod{tracePublicKeysCallback(a.Callback)}, }) } @@ -236,16 +247,17 @@ func NewKnownHostsCallback(files ...string) (ssh.HostKeyCallback, error) { func newKnownHostsDb(files ...string) (*knownhosts.HostKeyDB, error) { var err error - if len(files) == 0 { if files, err = getDefaultKnownHostsFiles(); err != nil { return nil, err } } + trace.SSH.Printf("ssh: known_hosts sources %s", files) if files, err = filterKnownHostsFiles(files...); err != nil { return nil, err } + trace.SSH.Printf("ssh: filtered known_hosts sources %s", files) return knownhosts.NewDB(files...) } @@ -253,6 +265,7 @@ func newKnownHostsDb(files ...string) (*knownhosts.HostKeyDB, error) { func getDefaultKnownHostsFiles() ([]string, error) { files := filepath.SplitList(os.Getenv("SSH_KNOWN_HOSTS")) if len(files) != 0 { + trace.SSH.Printf("ssh: loading known_hosts from SSH_KNOWN_HOSTS") return files, nil } @@ -309,6 +322,32 @@ func (m *HostKeyCallbackHelper) SetHostKeyCallback(cfg *ssh.ClientConfig) (*ssh. m.HostKeyCallback = db.HostKeyCallback() } - cfg.HostKeyCallback = m.HostKeyCallback + cfg.HostKeyCallback = m.traceHostKeyCallback return cfg, nil } + +func (m *HostKeyCallbackHelper) traceHostKeyCallback(hostname string, remote net.Addr, key ssh.PublicKey) error { + trace.SSH.Printf( + `ssh: hostkey callback hostname=%s remote=%s pubkey="%s %s"`, + hostname, remote, key.Type(), ssh.FingerprintSHA256(key)) + return m.HostKeyCallback(hostname, remote, key) +} + +func tracePublicKeysCallback(getSigners func() ([]ssh.Signer, error)) ssh.AuthMethod { + signers, err := getSigners() + if err != nil { + trace.SSH.Printf("ssh: error calling getSigners: %v", err) + } + if len(signers) == 0 { + trace.SSH.Printf("ssh: no signers found") + } + for _, s := range signers { + trace.SSH.Printf("ssh: found key: %s %s", s.PublicKey().Type(), + ssh.FingerprintSHA256(s.PublicKey())) + } + + cb := func() ([]ssh.Signer, error) { + return signers, err + } + return ssh.PublicKeysCallback(cb) +} diff --git a/plumbing/transport/ssh/auth_method_test.go b/plumbing/transport/ssh/auth_method_test.go index e3f652e35..8cdd1a521 100644 --- a/plumbing/transport/ssh/auth_method_test.go +++ b/plumbing/transport/ssh/auth_method_test.go @@ -6,17 +6,23 @@ import ( "os" "runtime" "strings" + "testing" "github.com/go-git/go-billy/v5/osfs" "github.com/go-git/go-billy/v5/util" + "github.com/stretchr/testify/suite" "golang.org/x/crypto/ssh" "golang.org/x/crypto/ssh/testdata" - - . "gopkg.in/check.v1" ) +func TestSuiteCommon(t *testing.T) { + suite.Run(t, new(SuiteCommon)) +} + type ( - SuiteCommon struct{} + SuiteCommon struct { + suite.Suite + } mockKnownHosts struct{} mockKnownHostsWithCert struct{} @@ -42,179 +48,178 @@ func (mockKnownHostsWithCert) Algorithms() []string { return []string{ssh.CertAlgoRSASHA512v01, ssh.CertAlgoRSASHA256v01, ssh.CertAlgoRSAv01} } -var _ = Suite(&SuiteCommon{}) - -func (s *SuiteCommon) TestKeyboardInteractiveName(c *C) { +func (s *SuiteCommon) TestKeyboardInteractiveName() { a := &KeyboardInteractive{ User: "test", Challenge: nil, } - c.Assert(a.Name(), Equals, KeyboardInteractiveName) + s.Equal(KeyboardInteractiveName, a.Name()) } -func (s *SuiteCommon) TestKeyboardInteractiveString(c *C) { +func (s *SuiteCommon) TestKeyboardInteractiveString() { a := &KeyboardInteractive{ User: "test", Challenge: nil, } - c.Assert(a.String(), Equals, fmt.Sprintf("user: test, name: %s", KeyboardInteractiveName)) + s.Equal(fmt.Sprintf("user: test, name: %s", KeyboardInteractiveName), a.String()) } -func (s *SuiteCommon) TestPasswordName(c *C) { +func (s *SuiteCommon) TestPasswordName() { a := &Password{ User: "test", Password: "", } - c.Assert(a.Name(), Equals, PasswordName) + s.Equal(PasswordName, a.Name()) } -func (s *SuiteCommon) TestPasswordString(c *C) { +func (s *SuiteCommon) TestPasswordString() { a := &Password{ User: "test", Password: "", } - c.Assert(a.String(), Equals, fmt.Sprintf("user: test, name: %s", PasswordName)) + s.Equal(fmt.Sprintf("user: test, name: %s", PasswordName), a.String()) } -func (s *SuiteCommon) TestPasswordCallbackName(c *C) { +func (s *SuiteCommon) TestPasswordCallbackName() { a := &PasswordCallback{ User: "test", Callback: nil, } - c.Assert(a.Name(), Equals, PasswordCallbackName) + s.Equal(PasswordCallbackName, a.Name()) } -func (s *SuiteCommon) TestPasswordCallbackString(c *C) { +func (s *SuiteCommon) TestPasswordCallbackString() { a := &PasswordCallback{ User: "test", Callback: nil, } - c.Assert(a.String(), Equals, fmt.Sprintf("user: test, name: %s", PasswordCallbackName)) + s.Equal(fmt.Sprintf("user: test, name: %s", PasswordCallbackName), a.String()) } -func (s *SuiteCommon) TestPublicKeysName(c *C) { +func (s *SuiteCommon) TestPublicKeysName() { a := &PublicKeys{ User: "test", Signer: nil, } - c.Assert(a.Name(), Equals, PublicKeysName) + s.Equal(PublicKeysName, a.Name()) } -func (s *SuiteCommon) TestPublicKeysString(c *C) { +func (s *SuiteCommon) TestPublicKeysString() { a := &PublicKeys{ User: "test", Signer: nil, } - c.Assert(a.String(), Equals, fmt.Sprintf("user: test, name: %s", PublicKeysName)) + s.Equal(fmt.Sprintf("user: test, name: %s", PublicKeysName), a.String()) } -func (s *SuiteCommon) TestPublicKeysCallbackName(c *C) { +func (s *SuiteCommon) TestPublicKeysCallbackName() { a := &PublicKeysCallback{ User: "test", Callback: nil, } - c.Assert(a.Name(), Equals, PublicKeysCallbackName) + s.Equal(PublicKeysCallbackName, a.Name()) } -func (s *SuiteCommon) TestPublicKeysCallbackString(c *C) { +func (s *SuiteCommon) TestPublicKeysCallbackString() { a := &PublicKeysCallback{ User: "test", Callback: nil, } - c.Assert(a.String(), Equals, fmt.Sprintf("user: test, name: %s", PublicKeysCallbackName)) + s.Equal(fmt.Sprintf("user: test, name: %s", PublicKeysCallbackName), a.String()) } -func (s *SuiteCommon) TestNewSSHAgentAuth(c *C) { + +func (s *SuiteCommon) TestNewSSHAgentAuth() { if runtime.GOOS == "js" { - c.Skip("tcp connections are not available in wasm") + s.T().Skip("tcp connections are not available in wasm") } if os.Getenv("SSH_AUTH_SOCK") == "" { - c.Skip("SSH_AUTH_SOCK or SSH_TEST_PRIVATE_KEY are required") + s.T().Skip("SSH_AUTH_SOCK or SSH_TEST_PRIVATE_KEY are required") } auth, err := NewSSHAgentAuth("foo") - c.Assert(err, IsNil) - c.Assert(auth, NotNil) + s.NoError(err) + s.NotNil(auth) } -func (s *SuiteCommon) TestNewSSHAgentAuthNoAgent(c *C) { +func (s *SuiteCommon) TestNewSSHAgentAuthNoAgent() { addr := os.Getenv("SSH_AUTH_SOCK") err := os.Unsetenv("SSH_AUTH_SOCK") - c.Assert(err, IsNil) + s.NoError(err) defer func() { err := os.Setenv("SSH_AUTH_SOCK", addr) - c.Assert(err, IsNil) + s.NoError(err) }() k, err := NewSSHAgentAuth("foo") - c.Assert(k, IsNil) - c.Assert(err, ErrorMatches, ".*SSH_AUTH_SOCK.*|.*SSH agent .* not detect.*") + s.Nil(k) + s.Regexp(".*SSH_AUTH_SOCK.*|.*SSH agent .* not detect.*", err.Error()) } -func (*SuiteCommon) TestNewPublicKeys(c *C) { +func (s *SuiteCommon) TestNewPublicKeys() { auth, err := NewPublicKeys("foo", testdata.PEMBytes["rsa"], "") - c.Assert(err, IsNil) - c.Assert(auth, NotNil) + s.NoError(err) + s.NotNil(auth) } -func (*SuiteCommon) TestNewPublicKeysWithEncryptedPEM(c *C) { +func (s *SuiteCommon) TestNewPublicKeysWithEncryptedPEM() { f := testdata.PEMEncryptedKeys[0] auth, err := NewPublicKeys("foo", f.PEMBytes, f.EncryptionKey) - c.Assert(err, IsNil) - c.Assert(auth, NotNil) + s.NoError(err) + s.NotNil(auth) } -func (*SuiteCommon) TestNewPublicKeysWithEncryptedEd25519PEM(c *C) { +func (s *SuiteCommon) TestNewPublicKeysWithEncryptedEd25519PEM() { f := testdata.PEMEncryptedKeys[2] auth, err := NewPublicKeys("foo", f.PEMBytes, f.EncryptionKey) - c.Assert(err, IsNil) - c.Assert(auth, NotNil) + s.NoError(err) + s.NotNil(auth) } -func (*SuiteCommon) TestNewPublicKeysFromFile(c *C) { +func (s *SuiteCommon) TestNewPublicKeysFromFile() { if runtime.GOOS == "js" { - c.Skip("not available in wasm") + s.T().Skip("not available in wasm") } f, err := util.TempFile(osfs.Default, "", "ssh-test") - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write(testdata.PEMBytes["rsa"]) - c.Assert(err, IsNil) - c.Assert(f.Close(), IsNil) + s.NoError(err) + s.NoError(f.Close()) defer osfs.Default.Remove(f.Name()) auth, err := NewPublicKeysFromFile("foo", f.Name(), "") - c.Assert(err, IsNil) - c.Assert(auth, NotNil) + s.NoError(err) + s.NotNil(auth) } -func (*SuiteCommon) TestNewPublicKeysWithInvalidPEM(c *C) { +func (s *SuiteCommon) TestNewPublicKeysWithInvalidPEM() { auth, err := NewPublicKeys("foo", []byte("bar"), "") - c.Assert(err, NotNil) - c.Assert(auth, IsNil) + s.Error(err) + s.Nil(auth) } -func (*SuiteCommon) TestNewKnownHostsCallback(c *C) { +func (s *SuiteCommon) TestNewKnownHostsCallback() { if runtime.GOOS == "js" { - c.Skip("not available in wasm") + s.T().Skip("not available in wasm") } - var mock = mockKnownHosts{} + mock := mockKnownHosts{} f, err := util.TempFile(osfs.Default, "", "known-hosts") - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write(mock.knownHosts()) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) defer util.RemoveAll(osfs.Default, f.Name()) f, err = osfs.Default.Open(f.Name()) - c.Assert(err, IsNil) + s.NoError(err) defer f.Close() @@ -229,50 +234,50 @@ func (*SuiteCommon) TestNewKnownHostsCallback(c *C) { var err error hostKey, _, _, _, err = ssh.ParseAuthorizedKey(scanner.Bytes()) if err != nil { - c.Fatalf("error parsing %q: %v", fields[2], err) + s.T().Fatalf("error parsing %q: %v", fields[2], err) } break } } if hostKey == nil { - c.Fatalf("no hostkey for %s", mock.host()) + s.T().Fatalf("no hostkey for %s", mock.host()) } clb, err := NewKnownHostsCallback(f.Name()) - c.Assert(err, IsNil) + s.NoError(err) err = clb(mock.String(), mock, hostKey) - c.Assert(err, IsNil) + s.NoError(err) } -func (*SuiteCommon) TestNewKnownHostsDbWithoutCert(c *C) { +func (s *SuiteCommon) TestNewKnownHostsDbWithoutCert() { if runtime.GOOS == "js" { - c.Skip("not available in wasm") + s.T().Skip("not available in wasm") } - var mock = mockKnownHosts{} + mock := mockKnownHosts{} f, err := util.TempFile(osfs.Default, "", "known-hosts") - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write(mock.knownHosts()) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) defer util.RemoveAll(osfs.Default, f.Name()) f, err = osfs.Default.Open(f.Name()) - c.Assert(err, IsNil) + s.NoError(err) defer f.Close() db, err := newKnownHostsDb(f.Name()) - c.Assert(err, IsNil) + s.NoError(err) algos := db.HostKeyAlgorithms(mock.String()) - c.Assert(algos, HasLen, len(mock.Algorithms())) + s.Len(algos, len(mock.Algorithms())) contains := func(container []string, value string) bool { for _, inner := range container { @@ -285,39 +290,39 @@ func (*SuiteCommon) TestNewKnownHostsDbWithoutCert(c *C) { for _, algorithm := range mock.Algorithms() { if !contains(algos, algorithm) { - c.Error("algos does not contain ", algorithm) + s.T().Error("algos does not contain ", algorithm) } } } -func (*SuiteCommon) TestNewKnownHostsDbWithCert(c *C) { +func (s *SuiteCommon) TestNewKnownHostsDbWithCert() { if runtime.GOOS == "js" { - c.Skip("not available in wasm") + s.T().Skip("not available in wasm") } - var mock = mockKnownHostsWithCert{} + mock := mockKnownHostsWithCert{} f, err := util.TempFile(osfs.Default, "", "known-hosts") - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write(mock.knownHosts()) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) defer util.RemoveAll(osfs.Default, f.Name()) f, err = osfs.Default.Open(f.Name()) - c.Assert(err, IsNil) + s.NoError(err) defer f.Close() db, err := newKnownHostsDb(f.Name()) - c.Assert(err, IsNil) + s.NoError(err) algos := db.HostKeyAlgorithms(mock.String()) - c.Assert(algos, HasLen, len(mock.Algorithms())) + s.Len(algos, len(mock.Algorithms())) contains := func(container []string, value string) bool { for _, inner := range container { @@ -330,7 +335,7 @@ func (*SuiteCommon) TestNewKnownHostsDbWithCert(c *C) { for _, algorithm := range mock.Algorithms() { if !contains(algos, algorithm) { - c.Error("algos does not contain ", algorithm) + s.T().Error("algos does not contain ", algorithm) } } } diff --git a/plumbing/transport/ssh/common.go b/plumbing/transport/ssh/common.go index a37024f0e..d0709e1ae 100644 --- a/plumbing/transport/ssh/common.go +++ b/plumbing/transport/ssh/common.go @@ -9,14 +9,18 @@ import ( "strconv" "strings" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/plumbing/transport/internal/common" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/utils/trace" "github.com/kevinburke/ssh_config" "golang.org/x/crypto/ssh" "golang.org/x/net/proxy" ) +func init() { + transport.Register("ssh", DefaultClient) +} + // DefaultClient is the default SSH client. var DefaultClient = NewClient(nil) @@ -30,12 +34,13 @@ type sshConfig interface { // NewClient creates a new SSH client with an optional *ssh.ClientConfig. func NewClient(config *ssh.ClientConfig) transport.Transport { - return common.NewClient(&runner{config: config}) + return transport.NewClient(&runner{config: config}) } // DefaultAuthBuilder is the function used to create a default AuthMethod, when // the user doesn't provide any. var DefaultAuthBuilder = func(user string) (AuthMethod, error) { + trace.SSH.Printf("ssh: Using default auth builder (user: %s)", user) return NewSSHAgentAuth(user) } @@ -45,7 +50,7 @@ type runner struct { config *ssh.ClientConfig } -func (r *runner) Command(cmd string, ep *transport.Endpoint, auth transport.AuthMethod) (common.Command, error) { +func (r *runner) Command(cmd string, ep *transport.Endpoint, auth transport.AuthMethod) (transport.Command, error) { c := &command{command: cmd, endpoint: ep, config: r.config} if auth != nil { if err := c.setAuth(auth); err != nil { @@ -147,6 +152,8 @@ func (c *command) connect() error { config.HostKeyAlgorithms = db.HostKeyAlgorithms(hostWithPort) } + trace.SSH.Printf("ssh: host key algorithms %s", config.HostKeyAlgorithms) + overrideConfig(c.config, config) c.client, err = dial("tcp", hostWithPort, c.endpoint.Proxy, config) @@ -184,6 +191,8 @@ func dial(network, addr string, proxyOpts transport.ProxyOptions, config *ssh.Cl if err != nil { return nil, err } + + trace.SSH.Printf("ssh: using proxyURL=%s", proxyUrl) dialer, err := proxy.FromURL(proxyUrl, proxy.Direct) if err != nil { return nil, err diff --git a/plumbing/transport/ssh/common_test.go b/plumbing/transport/ssh/common_test.go index a72493686..7d352dc17 100644 --- a/plumbing/transport/ssh/common_test.go +++ b/plumbing/transport/ssh/common_test.go @@ -1,20 +1,15 @@ package ssh import ( - "testing" - - "github.com/go-git/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/plumbing/transport" "github.com/gliderlabs/ssh" "github.com/kevinburke/ssh_config" stdssh "golang.org/x/crypto/ssh" "golang.org/x/crypto/ssh/testdata" - . "gopkg.in/check.v1" ) -func Test(t *testing.T) { TestingT(t) } - -func (s *SuiteCommon) TestOverrideConfig(c *C) { +func (s *SuiteCommon) TestOverrideConfig() { config := &stdssh.ClientConfig{ User: "foo", Auth: []stdssh.AuthMethod{ @@ -26,12 +21,12 @@ func (s *SuiteCommon) TestOverrideConfig(c *C) { target := &stdssh.ClientConfig{} overrideConfig(config, target) - c.Assert(target.User, Equals, "foo") - c.Assert(target.Auth, HasLen, 1) - c.Assert(target.HostKeyCallback, NotNil) + s.Equal("foo", target.User) + s.Len(target.Auth, 1) + s.NotNil(target.HostKeyCallback) } -func (s *SuiteCommon) TestOverrideConfigKeep(c *C) { +func (s *SuiteCommon) TestOverrideConfigKeep() { config := &stdssh.ClientConfig{ User: "foo", } @@ -41,10 +36,10 @@ func (s *SuiteCommon) TestOverrideConfigKeep(c *C) { } overrideConfig(config, target) - c.Assert(target.User, Equals, "foo") + s.Equal("foo", target.User) } -func (s *SuiteCommon) TestDefaultSSHConfig(c *C) { +func (s *SuiteCommon) TestDefaultSSHConfig() { defer func() { DefaultSSHConfig = ssh_config.DefaultUserSettings }() @@ -57,13 +52,13 @@ func (s *SuiteCommon) TestDefaultSSHConfig(c *C) { }} ep, err := transport.NewEndpoint("git@github.com:foo/bar.git") - c.Assert(err, IsNil) + s.NoError(err) cmd := &command{endpoint: ep} - c.Assert(cmd.getHostWithPort(), Equals, "foo.local:42") + s.Equal("foo.local:42", cmd.getHostWithPort()) } -func (s *SuiteCommon) TestDefaultSSHConfigNil(c *C) { +func (s *SuiteCommon) TestDefaultSSHConfigNil() { defer func() { DefaultSSHConfig = ssh_config.DefaultUserSettings }() @@ -71,13 +66,13 @@ func (s *SuiteCommon) TestDefaultSSHConfigNil(c *C) { DefaultSSHConfig = nil ep, err := transport.NewEndpoint("git@github.com:foo/bar.git") - c.Assert(err, IsNil) + s.NoError(err) cmd := &command{endpoint: ep} - c.Assert(cmd.getHostWithPort(), Equals, "github.com:22") + s.Equal("github.com:22", cmd.getHostWithPort()) } -func (s *SuiteCommon) TestDefaultSSHConfigWildcard(c *C) { +func (s *SuiteCommon) TestDefaultSSHConfigWildcard() { defer func() { DefaultSSHConfig = ssh_config.DefaultUserSettings }() @@ -89,72 +84,76 @@ func (s *SuiteCommon) TestDefaultSSHConfigWildcard(c *C) { }} ep, err := transport.NewEndpoint("git@github.com:foo/bar.git") - c.Assert(err, IsNil) + s.NoError(err) cmd := &command{endpoint: ep} - c.Assert(cmd.getHostWithPort(), Equals, "github.com:22") + s.Equal("github.com:22", cmd.getHostWithPort()) } -func (s *SuiteCommon) TestIgnoreHostKeyCallback(c *C) { +func (s *SuiteCommon) TestIgnoreHostKeyCallback() { uploadPack := &UploadPackSuite{ opts: []ssh.Option{ ssh.HostKeyPEM(testdata.PEMBytes["ed25519"]), }, } - uploadPack.SetUpSuite(c) + uploadPack.Suite = s.Suite + uploadPack.SetupSuite() // Use the default client, which does not have a host key callback uploadPack.Client = DefaultClient auth, err := NewPublicKeys("foo", testdata.PEMBytes["rsa"], "") - c.Assert(err, IsNil) - c.Assert(auth, NotNil) + s.Nil(err) + s.NotNil(auth) auth.HostKeyCallback = stdssh.InsecureIgnoreHostKey() - ep := uploadPack.newEndpoint(c, "bar.git") + ep := uploadPack.newEndpoint("bar.git") ps, err := uploadPack.Client.NewUploadPackSession(ep, auth) - c.Assert(err, IsNil) - c.Assert(ps, NotNil) + s.Nil(err) + s.NotNil(ps) } -func (s *SuiteCommon) TestFixedHostKeyCallback(c *C) { +func (s *SuiteCommon) TestFixedHostKeyCallback() { hostKey, err := stdssh.ParsePrivateKey(testdata.PEMBytes["ed25519"]) - c.Assert(err, IsNil) + s.Nil(err) uploadPack := &UploadPackSuite{ opts: []ssh.Option{ ssh.HostKeyPEM(testdata.PEMBytes["ed25519"]), }, } - uploadPack.SetUpSuite(c) + uploadPack.Suite = s.Suite + uploadPack.SetupSuite() // Use the default client, which does not have a host key callback uploadPack.Client = DefaultClient auth, err := NewPublicKeys("foo", testdata.PEMBytes["rsa"], "") - c.Assert(err, IsNil) - c.Assert(auth, NotNil) + s.Nil(err) + s.NotNil(auth) auth.HostKeyCallback = stdssh.FixedHostKey(hostKey.PublicKey()) - ep := uploadPack.newEndpoint(c, "bar.git") + ep := uploadPack.newEndpoint("bar.git") ps, err := uploadPack.Client.NewUploadPackSession(ep, auth) - c.Assert(err, IsNil) - c.Assert(ps, NotNil) + s.Nil(err) + s.NotNil(ps) } -func (s *SuiteCommon) TestFailHostKeyCallback(c *C) { +func (s *SuiteCommon) TestFailHostKeyCallback() { uploadPack := &UploadPackSuite{ opts: []ssh.Option{ ssh.HostKeyPEM(testdata.PEMBytes["ed25519"]), }, } - uploadPack.SetUpSuite(c) + uploadPack.Suite = s.Suite + uploadPack.SetupSuite() // Use the default client, which does not have a host key callback uploadPack.Client = DefaultClient auth, err := NewPublicKeys("foo", testdata.PEMBytes["rsa"], "") - c.Assert(err, IsNil) - c.Assert(auth, NotNil) - ep := uploadPack.newEndpoint(c, "bar.git") + s.Nil(err) + s.NotNil(auth) + ep := uploadPack.newEndpoint("bar.git") _, err = uploadPack.Client.NewUploadPackSession(ep, auth) - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *SuiteCommon) TestIssue70(c *C) { +func (s *SuiteCommon) TestIssue70() { uploadPack := &UploadPackSuite{} - uploadPack.SetUpSuite(c) + uploadPack.Suite = s.Suite + uploadPack.SetupSuite() config := &stdssh.ClientConfig{ HostKeyCallback: stdssh.InsecureIgnoreHostKey(), @@ -163,35 +162,29 @@ func (s *SuiteCommon) TestIssue70(c *C) { config: config, } - cmd, err := r.Command("command", uploadPack.newEndpoint(c, "endpoint"), uploadPack.EmptyAuth) - c.Assert(err, IsNil) + cmd, err := r.Command("command", uploadPack.newEndpoint("endpoint"), uploadPack.EmptyAuth) + s.NoError(err) - c.Assert(cmd.(*command).client.Close(), IsNil) + s.NoError(cmd.(*command).client.Close()) err = cmd.Close() - c.Assert(err, IsNil) + s.NoError(err) } -/* -Given, an endpoint to a git server with a socks5 proxy URL, -When, the socks5 proxy server is not reachable, -Then, there should not be any panic and an error with appropriate message should be returned. -Related issue : https://github.com/go-git/go-git/pull/900 -*/ -func (s *SuiteCommon) TestInvalidSocks5Proxy(c *C) { +func (s *SuiteCommon) TestInvalidSocks5Proxy() { ep, err := transport.NewEndpoint("git@github.com:foo/bar.git") - c.Assert(err, IsNil) + s.NoError(err) ep.Proxy.URL = "socks5://127.0.0.1:1080" auth, err := NewPublicKeys("foo", testdata.PEMBytes["rsa"], "") - c.Assert(err, IsNil) - c.Assert(auth, NotNil) + s.NoError(err) + s.NotNil(auth) ps, err := DefaultClient.NewUploadPackSession(ep, auth) - //Since the proxy server is not running, we expect an error. - c.Assert(ps, IsNil) - c.Assert(err, NotNil) - c.Assert(err, ErrorMatches, "socks connect .* dial tcp 127.0.0.1:1080: .*") + // Since the proxy server is not running, we expect an error. + s.Nil(ps) + s.Error(err) + s.Regexp("socks connect .* dial tcp 127.0.0.1:1080: .*", err.Error()) } type mockSSHConfig struct { @@ -207,8 +200,7 @@ func (c *mockSSHConfig) Get(alias, key string) string { return a[key] } -type invalidAuthMethod struct { -} +type invalidAuthMethod struct{} func (a *invalidAuthMethod) Name() string { return "invalid" @@ -218,14 +210,12 @@ func (a *invalidAuthMethod) String() string { return "invalid" } -func (s *SuiteCommon) TestCommandWithInvalidAuthMethod(c *C) { - uploadPack := &UploadPackSuite{} - uploadPack.SetUpSuite(c) +func (s *UploadPackSuite) TestCommandWithInvalidAuthMethod() { r := &runner{} auth := &invalidAuthMethod{} - _, err := r.Command("command", uploadPack.newEndpoint(c, "endpoint"), auth) + _, err := r.Command("command", s.newEndpoint("endpoint"), auth) - c.Assert(err, NotNil) - c.Assert(err, ErrorMatches, "invalid auth method") + s.Error(err) + s.Equal("invalid auth method", err.Error()) } diff --git a/plumbing/transport/ssh/knownhosts/knownhosts.go b/plumbing/transport/ssh/knownhosts/knownhosts.go new file mode 100644 index 000000000..7602ef11f --- /dev/null +++ b/plumbing/transport/ssh/knownhosts/knownhosts.go @@ -0,0 +1,468 @@ +// Copyright 2024 Skeema LLC and the Skeema Knownhosts authors + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 + +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Originally from: https://github.com/skeema/knownhosts/blob/main/knownhosts.go + +// Package knownhosts is a thin wrapper around golang.org/x/crypto/ssh/knownhosts, +// adding the ability to obtain the list of host key algorithms for a known host. +package knownhosts + +import ( + "bufio" + "bytes" + "encoding/base64" + "errors" + "fmt" + "io" + "net" + "os" + "sort" + "strings" + + "github.com/jesseduffield/go-git/v5/utils/trace" + "golang.org/x/crypto/ssh" + xknownhosts "golang.org/x/crypto/ssh/knownhosts" +) + +// HostKeyDB wraps logic in golang.org/x/crypto/ssh/knownhosts with additional +// behaviors, such as the ability to perform host key/algorithm lookups from +// known_hosts entries. +type HostKeyDB struct { + callback ssh.HostKeyCallback + isCert map[string]bool // keyed by "filename:line" + isWildcard map[string]bool // keyed by "filename:line" +} + +// NewDB creates a HostKeyDB from the given OpenSSH known_hosts file(s). It +// reads and parses the provided files one additional time (beyond logic in +// golang.org/x/crypto/ssh/knownhosts) in order to: +// +// - Handle CA lines properly and return ssh.CertAlgo* values when calling the +// HostKeyAlgorithms method, for use in ssh.ClientConfig.HostKeyAlgorithms +// - Allow * wildcards in hostnames to match on non-standard ports, providing +// a workaround for https://github.com/golang/go/issues/52056 in order to +// align with OpenSSH's wildcard behavior +// +// When supplying multiple files, their order does not matter. +func NewDB(files ...string) (*HostKeyDB, error) { + cb, err := xknownhosts.New(files...) + if err != nil { + return nil, err + } + hkdb := &HostKeyDB{ + callback: cb, + isCert: make(map[string]bool), + isWildcard: make(map[string]bool), + } + + // Re-read each file a single time, looking for @cert-authority lines. The + // logic for reading the file is designed to mimic hostKeyDB.Read from + // golang.org/x/crypto/ssh/knownhosts + for _, filename := range files { + f, err := os.Open(filename) + if err != nil { + return nil, err + } + defer f.Close() + scanner := bufio.NewScanner(f) + lineNum := 0 + for scanner.Scan() { + lineNum++ + line := scanner.Bytes() + line = bytes.TrimSpace(line) + // Does the line start with "@cert-authority" followed by whitespace? + if len(line) > 15 && bytes.HasPrefix(line, []byte("@cert-authority")) && (line[15] == ' ' || line[15] == '\t') { + mapKey := fmt.Sprintf("%s:%d", filename, lineNum) + hkdb.isCert[mapKey] = true + line = bytes.TrimSpace(line[16:]) + } + // truncate line to just the host pattern field + if i := bytes.IndexAny(line, "\t "); i >= 0 { + line = line[:i] + } + // Does the host pattern contain a * wildcard and no specific port? + if i := bytes.IndexRune(line, '*'); i >= 0 && !bytes.Contains(line[i:], []byte("]:")) { + mapKey := fmt.Sprintf("%s:%d", filename, lineNum) + hkdb.isWildcard[mapKey] = true + } + } + if err := scanner.Err(); err != nil { + return nil, fmt.Errorf("knownhosts: %s:%d: %w", filename, lineNum, err) + } + } + return hkdb, nil +} + +// HostKeyCallback returns an ssh.HostKeyCallback. This can be used directly in +// ssh.ClientConfig.HostKeyCallback, as shown in the example for NewDB. +// Alternatively, you can wrap it with an outer callback to potentially handle +// appending a new entry to the known_hosts file; see example in WriteKnownHost. +func (hkdb *HostKeyDB) HostKeyCallback() ssh.HostKeyCallback { + // Either NewDB found no wildcard host patterns, or hkdb was created from + // HostKeyCallback.ToDB in which case we didn't scan known_hosts for them: + // return the callback (which came from x/crypto/ssh/knownhosts) as-is + if len(hkdb.isWildcard) == 0 { + return hkdb.callback + } + + // If we scanned for wildcards and found at least one, return a wrapped + // callback with extra behavior: if the host lookup found no matches, and the + // host arg had a non-standard port, re-do the lookup on standard port 22. If + // that second call returns a *xknownhosts.KeyError, filter down any resulting + // Want keys to known wildcard entries. + f := func(hostname string, remote net.Addr, key ssh.PublicKey) error { + trace.SSH.Printf( + `ssh: wildcard knownhosts for hostname=%s pubkey="%s %s"`, + hostname, key.Type(), ssh.FingerprintSHA256(key)) + + callbackErr := hkdb.callback(hostname, remote, key) + if callbackErr == nil || IsHostKeyChanged(callbackErr) { // hostname has known_host entries as-is + return callbackErr + } + justHost, port, splitErr := net.SplitHostPort(hostname) + if splitErr != nil || port == "" || port == "22" { // hostname already using standard port + return callbackErr + } + // If we reach here, the port was non-standard and no known_host entries + // were found for the non-standard port. Try again with standard port. + if tcpAddr, ok := remote.(*net.TCPAddr); ok && tcpAddr.Port != 22 { + remote = &net.TCPAddr{ + IP: tcpAddr.IP, + Port: 22, + Zone: tcpAddr.Zone, + } + } + callbackErr = hkdb.callback(justHost+":22", remote, key) + var keyErr *xknownhosts.KeyError + if errors.As(callbackErr, &keyErr) && len(keyErr.Want) > 0 { + wildcardKeys := make([]xknownhosts.KnownKey, 0, len(keyErr.Want)) + for _, wantKey := range keyErr.Want { + if hkdb.isWildcard[fmt.Sprintf("%s:%d", wantKey.Filename, wantKey.Line)] { + wildcardKeys = append(wildcardKeys, wantKey) + } + } + callbackErr = &xknownhosts.KeyError{ + Want: wildcardKeys, + } + } + return callbackErr + } + return ssh.HostKeyCallback(f) +} + +// PublicKey wraps ssh.PublicKey with an additional field, to identify +// whether the key corresponds to a certificate authority. +type PublicKey struct { + ssh.PublicKey + Cert bool +} + +// HostKeys returns a slice of known host public keys for the supplied host:port +// found in the known_hosts file(s), or an empty slice if the host is not +// already known. For hosts that have multiple known_hosts entries (for +// different key types), the result will be sorted by known_hosts filename and +// line number. +// If hkdb was originally created by calling NewDB, the Cert boolean field of +// each result entry reports whether the key corresponded to a @cert-authority +// line. If hkdb was NOT obtained from NewDB, then Cert will always be false. +func (hkdb *HostKeyDB) HostKeys(hostWithPort string) (keys []PublicKey) { + var keyErr *xknownhosts.KeyError + placeholderAddr := &net.TCPAddr{IP: []byte{0, 0, 0, 0}} + placeholderPubKey := &fakePublicKey{} + var kkeys []xknownhosts.KnownKey + callback := hkdb.HostKeyCallback() + if hkcbErr := callback(hostWithPort, placeholderAddr, placeholderPubKey); errors.As(hkcbErr, &keyErr) { + kkeys = append(kkeys, keyErr.Want...) + knownKeyLess := func(i, j int) bool { + if kkeys[i].Filename < kkeys[j].Filename { + return true + } + return (kkeys[i].Filename == kkeys[j].Filename && kkeys[i].Line < kkeys[j].Line) + } + sort.Slice(kkeys, knownKeyLess) + keys = make([]PublicKey, len(kkeys)) + for n := range kkeys { + keys[n] = PublicKey{ + PublicKey: kkeys[n].Key, + } + if len(hkdb.isCert) > 0 { + keys[n].Cert = hkdb.isCert[fmt.Sprintf("%s:%d", kkeys[n].Filename, kkeys[n].Line)] + } + } + } + return keys +} + +// HostKeyAlgorithms returns a slice of host key algorithms for the supplied +// host:port found in the known_hosts file(s), or an empty slice if the host +// is not already known. The result may be used in ssh.ClientConfig's +// HostKeyAlgorithms field, either as-is or after filtering (if you wish to +// ignore or prefer particular algorithms). For hosts that have multiple +// known_hosts entries (of different key types), the result will be sorted by +// known_hosts filename and line number. +// If hkdb was originally created by calling NewDB, any @cert-authority lines +// in the known_hosts file will properly be converted to the corresponding +// ssh.CertAlgo* values. +func (hkdb *HostKeyDB) HostKeyAlgorithms(hostWithPort string) (algos []string) { + // We ensure that algos never contains duplicates. This is done for robustness + // even though currently golang.org/x/crypto/ssh/knownhosts never exposes + // multiple keys of the same type. This way our behavior here is unaffected + // even if https://github.com/golang/go/issues/28870 is implemented, for + // example by https://github.com/golang/crypto/pull/254. + hostKeys := hkdb.HostKeys(hostWithPort) + seen := make(map[string]struct{}, len(hostKeys)) + addAlgo := func(typ string, cert bool) { + if cert { + typ = keyTypeToCertAlgo(typ) + } + if _, already := seen[typ]; !already { + algos = append(algos, typ) + seen[typ] = struct{}{} + } + } + for _, key := range hostKeys { + typ := key.Type() + if typ == ssh.KeyAlgoRSA { + // KeyAlgoRSASHA256 and KeyAlgoRSASHA512 are only public key algorithms, + // not public key formats, so they can't appear as a PublicKey.Type. + // The corresponding PublicKey.Type is KeyAlgoRSA. See RFC 8332, Section 2. + addAlgo(ssh.KeyAlgoRSASHA512, key.Cert) + addAlgo(ssh.KeyAlgoRSASHA256, key.Cert) + } + addAlgo(typ, key.Cert) + } + return algos +} + +func keyTypeToCertAlgo(keyType string) string { + switch keyType { + case ssh.KeyAlgoRSA: + return ssh.CertAlgoRSAv01 + case ssh.KeyAlgoRSASHA256: + return ssh.CertAlgoRSASHA256v01 + case ssh.KeyAlgoRSASHA512: + return ssh.CertAlgoRSASHA512v01 + case ssh.KeyAlgoDSA: + return ssh.CertAlgoDSAv01 + case ssh.KeyAlgoECDSA256: + return ssh.CertAlgoECDSA256v01 + case ssh.KeyAlgoSKECDSA256: + return ssh.CertAlgoSKECDSA256v01 + case ssh.KeyAlgoECDSA384: + return ssh.CertAlgoECDSA384v01 + case ssh.KeyAlgoECDSA521: + return ssh.CertAlgoECDSA521v01 + case ssh.KeyAlgoED25519: + return ssh.CertAlgoED25519v01 + case ssh.KeyAlgoSKED25519: + return ssh.CertAlgoSKED25519v01 + } + return "" +} + +// HostKeyCallback wraps ssh.HostKeyCallback with additional methods to +// perform host key and algorithm lookups from the known_hosts entries. It is +// otherwise identical to ssh.HostKeyCallback, and does not introduce any file- +// parsing behavior beyond what is in golang.org/x/crypto/ssh/knownhosts. +// +// In most situations, use HostKeyDB and its constructor NewDB instead of using +// the HostKeyCallback type. The HostKeyCallback type is only provided for +// backwards compatibility with older versions of this package, as well as for +// very strict situations where any extra known_hosts file-parsing is +// undesirable. +// +// Methods of HostKeyCallback do not provide any special treatment for +// @cert-authority lines, which will (incorrectly) look like normal non-CA host +// keys. Additionally, HostKeyCallback lacks the fix for applying * wildcard +// known_host entries to all ports, like OpenSSH's behavior. +type HostKeyCallback ssh.HostKeyCallback + +// New creates a HostKeyCallback from the given OpenSSH known_hosts file(s). The +// returned value may be used in ssh.ClientConfig.HostKeyCallback by casting it +// to ssh.HostKeyCallback, or using its HostKeyCallback method. Otherwise, it +// operates the same as the New function in golang.org/x/crypto/ssh/knownhosts. +// When supplying multiple files, their order does not matter. +// +// In most situations, you should avoid this function, as the returned value +// lacks several enhanced behaviors. See doc comment for HostKeyCallback for +// more information. Instead, most callers should use NewDB to create a +// HostKeyDB, which includes these enhancements. +func New(files ...string) (HostKeyCallback, error) { + cb, err := xknownhosts.New(files...) + return HostKeyCallback(cb), err +} + +// HostKeyCallback simply casts the receiver back to ssh.HostKeyCallback, for +// use in ssh.ClientConfig.HostKeyCallback. +func (hkcb HostKeyCallback) HostKeyCallback() ssh.HostKeyCallback { + return ssh.HostKeyCallback(hkcb) +} + +// ToDB converts the receiver into a HostKeyDB. However, the returned HostKeyDB +// lacks the enhanced behaviors described in the doc comment for NewDB: proper +// CA support, and wildcard matching on nonstandard ports. +// +// It is generally preferable to create a HostKeyDB by using NewDB. The ToDB +// method is only provided for situations in which the calling code needs to +// make the extra NewDB behaviors optional / user-configurable, perhaps for +// reasons of performance or code trust (since NewDB reads the known_host file +// an extra time, which may be undesirable in some strict situations). This way, +// callers can conditionally create a non-enhanced HostKeyDB by using New and +// ToDB. See code example. +func (hkcb HostKeyCallback) ToDB() *HostKeyDB { + // This intentionally leaves the isCert and isWildcard map fields as nil, as + // there is no way to retroactively populate them from just a HostKeyCallback. + // Methods of HostKeyDB will skip any related enhanced behaviors accordingly. + return &HostKeyDB{callback: ssh.HostKeyCallback(hkcb)} +} + +// HostKeys returns a slice of known host public keys for the supplied host:port +// found in the known_hosts file(s), or an empty slice if the host is not +// already known. For hosts that have multiple known_hosts entries (for +// different key types), the result will be sorted by known_hosts filename and +// line number. +// In the returned values, there is no way to distinguish between CA keys +// (known_hosts lines beginning with @cert-authority) and regular keys. To do +// so, see NewDB and HostKeyDB.HostKeys instead. +func (hkcb HostKeyCallback) HostKeys(hostWithPort string) []ssh.PublicKey { + annotatedKeys := hkcb.ToDB().HostKeys(hostWithPort) + rawKeys := make([]ssh.PublicKey, len(annotatedKeys)) + for n, ak := range annotatedKeys { + rawKeys[n] = ak.PublicKey + } + return rawKeys +} + +// HostKeyAlgorithms returns a slice of host key algorithms for the supplied +// host:port found in the known_hosts file(s), or an empty slice if the host +// is not already known. The result may be used in ssh.ClientConfig's +// HostKeyAlgorithms field, either as-is or after filtering (if you wish to +// ignore or prefer particular algorithms). For hosts that have multiple +// known_hosts entries (for different key types), the result will be sorted by +// known_hosts filename and line number. +// The returned values will not include ssh.CertAlgo* values. If any +// known_hosts lines had @cert-authority prefixes, their original key algo will +// be returned instead. For proper CA support, see NewDB and +// HostKeyDB.HostKeyAlgorithms instead. +func (hkcb HostKeyCallback) HostKeyAlgorithms(hostWithPort string) (algos []string) { + return hkcb.ToDB().HostKeyAlgorithms(hostWithPort) +} + +// HostKeyAlgorithms is a convenience function for performing host key algorithm +// lookups on an ssh.HostKeyCallback directly. It is intended for use in code +// paths that stay with the New method of golang.org/x/crypto/ssh/knownhosts +// rather than this package's New or NewDB methods. +// The returned values will not include ssh.CertAlgo* values. If any +// known_hosts lines had @cert-authority prefixes, their original key algo will +// be returned instead. For proper CA support, see NewDB and +// HostKeyDB.HostKeyAlgorithms instead. +func HostKeyAlgorithms(cb ssh.HostKeyCallback, hostWithPort string) []string { + return HostKeyCallback(cb).HostKeyAlgorithms(hostWithPort) +} + +// IsHostKeyChanged returns a boolean indicating whether the error indicates +// the host key has changed. It is intended to be called on the error returned +// from invoking a host key callback, to check whether an SSH host is known. +func IsHostKeyChanged(err error) bool { + var keyErr *xknownhosts.KeyError + return errors.As(err, &keyErr) && len(keyErr.Want) > 0 +} + +// IsHostUnknown returns a boolean indicating whether the error represents an +// unknown host. It is intended to be called on the error returned from invoking +// a host key callback to check whether an SSH host is known. +func IsHostUnknown(err error) bool { + var keyErr *xknownhosts.KeyError + return errors.As(err, &keyErr) && len(keyErr.Want) == 0 +} + +// Normalize normalizes an address into the form used in known_hosts. This +// implementation includes a fix for https://github.com/golang/go/issues/53463 +// and will omit brackets around ipv6 addresses on standard port 22. +func Normalize(address string) string { + host, port, err := net.SplitHostPort(address) + if err != nil { + host = address + port = "22" + } + entry := host + if port != "22" { + entry = "[" + entry + "]:" + port + } else if strings.HasPrefix(host, "[") && strings.HasSuffix(host, "]") { + entry = entry[1 : len(entry)-1] + } + return entry +} + +// Line returns a line to append to the known_hosts files. This implementation +// uses the local patched implementation of Normalize in order to solve +// https://github.com/golang/go/issues/53463. +func Line(addresses []string, key ssh.PublicKey) string { + var trimmed []string + for _, a := range addresses { + trimmed = append(trimmed, Normalize(a)) + } + + return strings.Join([]string{ + strings.Join(trimmed, ","), + key.Type(), + base64.StdEncoding.EncodeToString(key.Marshal()), + }, " ") +} + +// WriteKnownHost writes a known_hosts line to w for the supplied hostname, +// remote, and key. This is useful when writing a custom hostkey callback which +// wraps a callback obtained from this package to provide additional known_hosts +// management functionality. The hostname, remote, and key typically correspond +// to the callback's args. This function does not support writing +// @cert-authority lines. +func WriteKnownHost(w io.Writer, hostname string, remote net.Addr, key ssh.PublicKey) error { + // Always include hostname; only also include remote if it isn't a zero value + // and doesn't normalize to the same string as hostname. + hostnameNormalized := Normalize(hostname) + if strings.ContainsAny(hostnameNormalized, "\t ") { + return fmt.Errorf("knownhosts: hostname '%s' contains spaces", hostnameNormalized) + } + addresses := []string{hostnameNormalized} + remoteStrNormalized := Normalize(remote.String()) + if remoteStrNormalized != "[0.0.0.0]:0" && remoteStrNormalized != hostnameNormalized && + !strings.ContainsAny(remoteStrNormalized, "\t ") { + addresses = append(addresses, remoteStrNormalized) + } + line := Line(addresses, key) + "\n" + _, err := w.Write([]byte(line)) + return err +} + +// WriteKnownHostCA writes a @cert-authority line to w for the supplied host +// name/pattern and key. +func WriteKnownHostCA(w io.Writer, hostPattern string, key ssh.PublicKey) error { + encodedKey := base64.StdEncoding.EncodeToString(key.Marshal()) + _, err := fmt.Fprintf(w, "@cert-authority %s %s %s\n", hostPattern, key.Type(), encodedKey) + return err +} + +// fakePublicKey is used as part of the work-around for +// https://github.com/golang/go/issues/29286 +type fakePublicKey struct{} + +func (fakePublicKey) Type() string { + return "fake-public-key" +} +func (fakePublicKey) Marshal() []byte { + return []byte("fake public key") +} +func (fakePublicKey) Verify(_ []byte, _ *ssh.Signature) error { + return errors.New("Verify called on placeholder key") +} diff --git a/plumbing/transport/ssh/knownhosts/knownhosts_test.go b/plumbing/transport/ssh/knownhosts/knownhosts_test.go new file mode 100644 index 000000000..99ca9aff2 --- /dev/null +++ b/plumbing/transport/ssh/knownhosts/knownhosts_test.go @@ -0,0 +1,558 @@ +// Copyright 2024 Skeema LLC and the Skeema Knownhosts authors + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 + +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Originally from: https://github.com/skeema/knownhosts/blob/main/knownhosts_test.go + +package knownhosts + +import ( + "bytes" + "crypto/ecdsa" + "crypto/ed25519" + "crypto/elliptic" + "crypto/rand" + "crypto/rsa" + "net" + "os" + "path/filepath" + "testing" + + "golang.org/x/crypto/ssh" +) + +func TestNewDB(t *testing.T) { + khPath := getTestKnownHosts(t) + + // Valid path should return a non-nil HostKeyDB and no error + if kh, err := NewDB(khPath); kh == nil || err != nil { + t.Errorf("Unexpected return from NewDB on valid known_hosts path: %v, %v", kh, err) + } else { + // Confirm return value of HostKeyCallback is an ssh.HostKeyCallback + _ = ssh.ClientConfig{ + HostKeyCallback: kh.HostKeyCallback(), + } + } + + // Append a @cert-authority line to the valid known_hosts file + // Valid path should still return a non-nil HostKeyDB and no error + appendCertTestKnownHosts(t, khPath, "*", ssh.KeyAlgoECDSA256) + if kh, err := NewDB(khPath); kh == nil || err != nil { + t.Errorf("Unexpected return from NewDB on valid known_hosts path containing a cert: %v, %v", kh, err) + } + + // Write a second valid known_hosts file + // Supplying both valid paths should still return a non-nil HostKeyDB and no + // error + appendCertTestKnownHosts(t, khPath+"2", "*.certy.test", ssh.KeyAlgoED25519) + if kh, err := NewDB(khPath+"2", khPath); kh == nil || err != nil { + t.Errorf("Unexpected return from NewDB on two valid known_hosts paths: %v, %v", kh, err) + } + + // Invalid path should return an error, with or without other valid paths + if _, err := NewDB(khPath + "_does_not_exist"); err == nil { + t.Error("Expected error from NewDB with invalid path, but error was nil") + } + if _, err := NewDB(khPath, khPath+"_does_not_exist"); err == nil { + t.Error("Expected error from NewDB with mix of valid and invalid paths, but error was nil") + } +} + +func TestNew(t *testing.T) { + khPath := getTestKnownHosts(t) + + // Valid path should return a callback and no error; callback should be usable + // in ssh.ClientConfig.HostKeyCallback + if kh, err := New(khPath); err != nil { + t.Errorf("Unexpected error from New on valid known_hosts path: %v", err) + } else { + // Confirm kh can be converted to an ssh.HostKeyCallback + _ = ssh.ClientConfig{ + HostKeyCallback: ssh.HostKeyCallback(kh), + } + // Confirm return value of HostKeyCallback is an ssh.HostKeyCallback + _ = ssh.ClientConfig{ + HostKeyCallback: kh.HostKeyCallback(), + } + } + + // Invalid path should return an error, with or without other valid paths + if _, err := New(khPath + "_does_not_exist"); err == nil { + t.Error("Expected error from New with invalid path, but error was nil") + } + if _, err := New(khPath, khPath+"_does_not_exist"); err == nil { + t.Error("Expected error from New with mix of valid and invalid paths, but error was nil") + } +} + +func TestHostKeys(t *testing.T) { + khPath := getTestKnownHosts(t) + kh, err := New(khPath) + if err != nil { + t.Fatalf("Unexpected error from New: %v", err) + } + + expectedKeyTypes := map[string][]string{ + "only-rsa.example.test:22": {"ssh-rsa"}, + "only-ecdsa.example.test:22": {"ecdsa-sha2-nistp256"}, + "only-ed25519.example.test:22": {"ssh-ed25519"}, + "multi.example.test:2233": {"ssh-rsa", "ecdsa-sha2-nistp256", "ssh-ed25519"}, + "192.168.1.102:2222": {"ecdsa-sha2-nistp256", "ssh-ed25519"}, + "unknown-host.example.test": {}, // host not in file + "multi.example.test:22": {}, // different port than entry in file + "192.168.1.102": {}, // different port than entry in file + } + for host, expected := range expectedKeyTypes { + actual := kh.HostKeys(host) + if len(actual) != len(expected) { + t.Errorf("Unexpected number of keys returned by HostKeys(%q): expected %d, found %d", host, len(expected), len(actual)) + continue + } + for n := range expected { + if actualType := actual[n].Type(); expected[n] != actualType { + t.Errorf("Unexpected key returned by HostKeys(%q): expected key[%d] to be type %v, found %v", host, n, expected, actualType) + break + } + } + } +} + +func TestHostKeyAlgorithms(t *testing.T) { + khPath := getTestKnownHosts(t) + kh, err := New(khPath) + if err != nil { + t.Fatalf("Unexpected error from New: %v", err) + } + + expectedAlgorithms := map[string][]string{ + "only-rsa.example.test:22": {"rsa-sha2-512", "rsa-sha2-256", "ssh-rsa"}, + "only-ecdsa.example.test:22": {"ecdsa-sha2-nistp256"}, + "only-ed25519.example.test:22": {"ssh-ed25519"}, + "multi.example.test:2233": {"rsa-sha2-512", "rsa-sha2-256", "ssh-rsa", "ecdsa-sha2-nistp256", "ssh-ed25519"}, + "192.168.1.102:2222": {"ecdsa-sha2-nistp256", "ssh-ed25519"}, + "unknown-host.example.test": {}, // host not in file + "multi.example.test:22": {}, // different port than entry in file + "192.168.1.102": {}, // different port than entry in file + } + for host, expected := range expectedAlgorithms { + actual := kh.HostKeyAlgorithms(host) + actual2 := HostKeyAlgorithms(kh.HostKeyCallback(), host) + if len(actual) != len(expected) || len(actual2) != len(expected) { + t.Errorf("Unexpected number of algorithms returned by HostKeyAlgorithms(%q): expected %d, found %d", host, len(expected), len(actual)) + continue + } + for n := range expected { + if expected[n] != actual[n] || expected[n] != actual2[n] { + t.Errorf("Unexpected algorithms returned by HostKeyAlgorithms(%q): expected %v, found %v", host, expected, actual) + break + } + } + } +} + +func TestWithCertLines(t *testing.T) { + khPath := getTestKnownHosts(t) + khPath2 := khPath + "2" + appendCertTestKnownHosts(t, khPath, "*.certy.test", ssh.KeyAlgoRSA) + appendCertTestKnownHosts(t, khPath2, "*", ssh.KeyAlgoECDSA256) + appendCertTestKnownHosts(t, khPath2, "*.certy.test", ssh.KeyAlgoED25519) + + // Test behavior of HostKeyCallback type, which doesn't properly handle + // @cert-authority lines but shouldn't error on them. It should just return + // them as regular keys / algorithms. + cbOnly, err := New(khPath2, khPath) + if err != nil { + t.Fatalf("Unexpected error from New: %v", err) + } + algos := cbOnly.HostKeyAlgorithms("only-ed25519.example.test:22") + // algos should return ssh.KeyAlgoED25519 (as per previous test) but now also + // ssh.KeyAlgoECDSA256 due to the cert entry on *. They should always be in + // that order due to matching the file and line order from NewDB. + if len(algos) != 2 || algos[0] != ssh.KeyAlgoED25519 || algos[1] != ssh.KeyAlgoECDSA256 { + t.Errorf("Unexpected return from HostKeyCallback.HostKeyAlgorithms: %v", algos) + } + + // Now test behavior of HostKeyDB type, which should properly support + // @cert-authority lines as being different from other lines + kh, err := NewDB(khPath2, khPath) + if err != nil { + t.Fatalf("Unexpected error from NewDB: %v", err) + } + testCases := []struct { + host string + expectedKeyTypes []string + expectedIsCert []bool + expectedAlgos []string + }{ + { + host: "only-ed25519.example.test:22", + expectedKeyTypes: []string{ssh.KeyAlgoED25519, ssh.KeyAlgoECDSA256}, + expectedIsCert: []bool{false, true}, + expectedAlgos: []string{ssh.KeyAlgoED25519, ssh.CertAlgoECDSA256v01}, + }, + { + host: "only-rsa.example.test:22", + expectedKeyTypes: []string{ssh.KeyAlgoRSA, ssh.KeyAlgoECDSA256}, + expectedIsCert: []bool{false, true}, + expectedAlgos: []string{ssh.KeyAlgoRSASHA512, ssh.KeyAlgoRSASHA256, ssh.KeyAlgoRSA, ssh.CertAlgoECDSA256v01}, + }, + { + host: "whatever.test:22", // only matches the * entry + expectedKeyTypes: []string{ssh.KeyAlgoECDSA256}, + expectedIsCert: []bool{true}, + expectedAlgos: []string{ssh.CertAlgoECDSA256v01}, + }, + { + host: "whatever.test:22022", // only matches the * entry + expectedKeyTypes: []string{ssh.KeyAlgoECDSA256}, + expectedIsCert: []bool{true}, + expectedAlgos: []string{ssh.CertAlgoECDSA256v01}, + }, + { + host: "asdf.certy.test:22", + expectedKeyTypes: []string{ssh.KeyAlgoRSA, ssh.KeyAlgoECDSA256, ssh.KeyAlgoED25519}, + expectedIsCert: []bool{true, true, true}, + expectedAlgos: []string{ssh.CertAlgoRSASHA512v01, ssh.CertAlgoRSASHA256v01, ssh.CertAlgoRSAv01, ssh.CertAlgoECDSA256v01, ssh.CertAlgoED25519v01}, + }, + { + host: "oddport.certy.test:2345", + expectedKeyTypes: []string{ssh.KeyAlgoRSA, ssh.KeyAlgoECDSA256, ssh.KeyAlgoED25519}, + expectedIsCert: []bool{true, true, true}, + expectedAlgos: []string{ssh.CertAlgoRSASHA512v01, ssh.CertAlgoRSASHA256v01, ssh.CertAlgoRSAv01, ssh.CertAlgoECDSA256v01, ssh.CertAlgoED25519v01}, + }, + } + for _, tc := range testCases { + annotatedKeys := kh.HostKeys(tc.host) + if len(annotatedKeys) != len(tc.expectedKeyTypes) { + t.Errorf("Unexpected return from HostKeys(%q): %v", tc.host, annotatedKeys) + } else { + for n := range annotatedKeys { + if annotatedKeys[n].Type() != tc.expectedKeyTypes[n] || annotatedKeys[n].Cert != tc.expectedIsCert[n] { + t.Errorf("Unexpected return from HostKeys(%q) at index %d: %v", tc.host, n, annotatedKeys) + break + } + } + } + algos := kh.HostKeyAlgorithms(tc.host) + if len(algos) != len(tc.expectedAlgos) { + t.Errorf("Unexpected return from HostKeyAlgorithms(%q): %v", tc.host, algos) + } else { + for n := range algos { + if algos[n] != tc.expectedAlgos[n] { + t.Errorf("Unexpected return from HostKeyAlgorithms(%q) at index %d: %v", tc.host, n, algos) + break + } + } + } + } +} + +func TestIsHostKeyChanged(t *testing.T) { + khPath := getTestKnownHosts(t) + kh, err := New(khPath) + if err != nil { + t.Fatalf("Unexpected error from New: %v", err) + } + noAddr, _ := net.ResolveTCPAddr("tcp", "0.0.0.0:0") + pubKey := generatePubKeyEd25519(t) + + // Unknown host: should return false + if err := kh("unknown.example.test:22", noAddr, pubKey); IsHostKeyChanged(err) { + t.Error("IsHostKeyChanged unexpectedly returned true for unknown host") + } + + // Known host, wrong key: should return true + if err := kh("multi.example.test:2233", noAddr, pubKey); !IsHostKeyChanged(err) { + t.Error("IsHostKeyChanged unexpectedly returned false for known host with different host key") + } + + // Append the key for a known host that doesn't already have that key type, + // re-init the known_hosts, and check again: should return false + f, err := os.OpenFile(khPath, os.O_APPEND|os.O_WRONLY, 0600) + if err != nil { + t.Fatalf("Unable to open %s for writing: %v", khPath, err) + } + if err := WriteKnownHost(f, "only-ecdsa.example.test:22", noAddr, pubKey); err != nil { + t.Fatalf("Unable to write known host line: %v", err) + } + f.Close() + if kh, err = New(khPath); err != nil { + t.Fatalf("Unexpected error from New: %v", err) + } + if err := kh("only-ecdsa.example.test:22", noAddr, pubKey); IsHostKeyChanged(err) { + t.Error("IsHostKeyChanged unexpectedly returned true for valid known host") + } +} + +func TestIsHostUnknown(t *testing.T) { + khPath := getTestKnownHosts(t) + kh, err := New(khPath) + if err != nil { + t.Fatalf("Unexpected error from New: %v", err) + } + noAddr, _ := net.ResolveTCPAddr("tcp", "0.0.0.0:0") + pubKey := generatePubKeyEd25519(t) + + // Unknown host: should return true + if err := kh("unknown.example.test:22", noAddr, pubKey); !IsHostUnknown(err) { + t.Error("IsHostUnknown unexpectedly returned false for unknown host") + } + + // Known host, wrong key: should return false + if err := kh("multi.example.test:2233", noAddr, pubKey); IsHostUnknown(err) { + t.Error("IsHostUnknown unexpectedly returned true for known host with different host key") + } + + // Append the key for an unknown host, re-init the known_hosts, and check + // again: should return false + f, err := os.OpenFile(khPath, os.O_APPEND|os.O_WRONLY, 0600) + if err != nil { + t.Fatalf("Unable to open %s for writing: %v", khPath, err) + } + if err := WriteKnownHost(f, "newhost.example.test:22", noAddr, pubKey); err != nil { + t.Fatalf("Unable to write known host line: %v", err) + } + f.Close() + if kh, err = New(khPath); err != nil { + t.Fatalf("Unexpected error from New: %v", err) + } + if err := kh("newhost.example.test:22", noAddr, pubKey); IsHostUnknown(err) { + t.Error("IsHostUnknown unexpectedly returned true for valid known host") + } +} + +func TestNormalize(t *testing.T) { + for in, want := range map[string]string{ + "127.0.0.1": "127.0.0.1", + "127.0.0.1:22": "127.0.0.1", + "[127.0.0.1]:22": "127.0.0.1", + "[127.0.0.1]:23": "[127.0.0.1]:23", + "127.0.0.1:23": "[127.0.0.1]:23", + "[a.b.c]:22": "a.b.c", + "abcd::abcd:abcd:abcd": "abcd::abcd:abcd:abcd", + "[abcd::abcd:abcd:abcd]": "abcd::abcd:abcd:abcd", + "[abcd::abcd:abcd:abcd]:22": "abcd::abcd:abcd:abcd", + "[abcd::abcd:abcd:abcd]:23": "[abcd::abcd:abcd:abcd]:23", + } { + got := Normalize(in) + if got != want { + t.Errorf("Normalize(%q) = %q, want %q", in, got, want) + } + } +} + +func TestLine(t *testing.T) { + edKeyStr := "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIF9Wn63tLEhSWl9Ye+4x2GnruH8cq0LIh2vum/fUHrFQ" + edKey, _, _, _, err := ssh.ParseAuthorizedKey([]byte(edKeyStr)) + if err != nil { + t.Fatalf("Unable to parse authorized key: %v", err) + } + for in, want := range map[string]string{ + "server.org": "server.org " + edKeyStr, + "server.org:22": "server.org " + edKeyStr, + "server.org:23": "[server.org]:23 " + edKeyStr, + "[c629:1ec4:102:304:102:304:102:304]:22": "c629:1ec4:102:304:102:304:102:304 " + edKeyStr, + "[c629:1ec4:102:304:102:304:102:304]:23": "[c629:1ec4:102:304:102:304:102:304]:23 " + edKeyStr, + } { + if got := Line([]string{in}, edKey); got != want { + t.Errorf("Line(%q) = %q, want %q", in, got, want) + } + } +} + +func TestWriteKnownHost(t *testing.T) { + edKeyStr := "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIF9Wn63tLEhSWl9Ye+4x2GnruH8cq0LIh2vum/fUHrFQ" + edKey, _, _, _, err := ssh.ParseAuthorizedKey([]byte(edKeyStr)) + if err != nil { + t.Fatalf("Unable to parse authorized key: %v", err) + } + for _, m := range []struct { + hostname string + remoteAddr string + want string + err string + }{ + {hostname: "::1", remoteAddr: "[::1]:22", want: "::1 " + edKeyStr + "\n"}, + {hostname: "127.0.0.1", remoteAddr: "127.0.0.1:22", want: "127.0.0.1 " + edKeyStr + "\n"}, + {hostname: "ipv4.test", remoteAddr: "192.168.0.1:23", want: "ipv4.test,[192.168.0.1]:23 " + edKeyStr + "\n"}, + {hostname: "ipv6.test", remoteAddr: "[ff01::1234]:23", want: "ipv6.test,[ff01::1234]:23 " + edKeyStr + "\n"}, + {hostname: "normal.zone", remoteAddr: "[fe80::1%en0]:22", want: "normal.zone,fe80::1%en0 " + edKeyStr + "\n"}, + {hostname: "spaces.zone", remoteAddr: "[fe80::1%Ethernet 1]:22", want: "spaces.zone " + edKeyStr + "\n"}, + {hostname: "spaces.zone", remoteAddr: "[fe80::1%Ethernet\t2]:23", want: "spaces.zone " + edKeyStr + "\n"}, + {hostname: "[fe80::1%Ethernet 1]:22", err: "knownhosts: hostname 'fe80::1%Ethernet 1' contains spaces"}, + {hostname: "[fe80::1%Ethernet\t2]:23", err: "knownhosts: hostname '[fe80::1%Ethernet\t2]:23' contains spaces"}, + } { + remote, err := net.ResolveTCPAddr("tcp", m.remoteAddr) + if err != nil { + t.Fatalf("Unable to resolve tcp addr: %v", err) + } + var got bytes.Buffer + err = WriteKnownHost(&got, m.hostname, remote, edKey) + if m.err != "" { + if err == nil || err.Error() != m.err { + t.Errorf("WriteKnownHost(%q) expected error %v, found %v", m.hostname, m.err, err) + } + continue + } + if err != nil { + t.Fatalf("Unable to write known host: %v", err) + } + if got.String() != m.want { + t.Errorf("WriteKnownHost(%q) = %q, want %q", m.hostname, got.String(), m.want) + } + } +} + +func TestFakePublicKey(t *testing.T) { + fpk := fakePublicKey{} + if err := fpk.Verify(nil, nil); err == nil { + t.Error("Expected fakePublicKey.Verify() to always return an error, but it did not") + } + if certAlgo := keyTypeToCertAlgo(fpk.Type()); certAlgo != "" { + t.Errorf("Expected keyTypeToCertAlgo on a fakePublicKey to return an empty string, but instead found %q", certAlgo) + } +} + +var testKnownHostsContents []byte + +// getTestKnownHosts returns a path to a test known_hosts file. The file path +// will differ between test functions, but the contents are always the same, +// containing keys generated upon the first invocation. The file is removed +// upon test completion. +func getTestKnownHosts(t *testing.T) string { + // Re-use previously memoized result + if len(testKnownHostsContents) > 0 { + dir := t.TempDir() + khPath := filepath.Join(dir, "known_hosts") + if err := os.WriteFile(khPath, testKnownHostsContents, 0600); err != nil { + t.Fatalf("Unable to write to %s: %v", khPath, err) + } + return khPath + } + + khPath := writeTestKnownHosts(t) + if contents, err := os.ReadFile(khPath); err == nil { + testKnownHostsContents = contents + } + return khPath +} + +// writeTestKnownHosts generates the test known_hosts file and returns the +// file path to it. The generated file contains several hosts with a mix of +// key types; each known host has between 1 and 4 different known host keys. +// If generating or writing the file fails, the test fails. +func writeTestKnownHosts(t *testing.T) string { + t.Helper() + hosts := map[string][]ssh.PublicKey{ + "only-rsa.example.test:22": {generatePubKeyRSA(t)}, + "only-ecdsa.example.test:22": {generatePubKeyECDSA(t)}, + "only-ed25519.example.test:22": {generatePubKeyEd25519(t)}, + "multi.example.test:2233": {generatePubKeyRSA(t), generatePubKeyECDSA(t), generatePubKeyEd25519(t), generatePubKeyEd25519(t)}, + "192.168.1.102:2222": {generatePubKeyECDSA(t), generatePubKeyEd25519(t)}, + "[fe80::abc:abc:abcd:abcd]:22": {generatePubKeyEd25519(t), generatePubKeyRSA(t)}, + } + + dir := t.TempDir() + khPath := filepath.Join(dir, "known_hosts") + f, err := os.OpenFile(khPath, os.O_WRONLY|os.O_CREATE, 0600) + if err != nil { + t.Fatalf("Unable to open %s for writing: %v", khPath, err) + } + defer f.Close() + noAddr, _ := net.ResolveTCPAddr("tcp", "0.0.0.0:0") + for host, keys := range hosts { + for _, k := range keys { + if err := WriteKnownHost(f, host, noAddr, k); err != nil { + t.Fatalf("Unable to write known host line: %v", err) + } + } + } + return khPath +} + +var testCertKeys = make(map[string]ssh.PublicKey) // key string format is "hostpattern keytype" + +// appendCertTestKnownHosts adds a @cert-authority line to the file at the +// supplied path, creating it if it does not exist yet. The keyType must be one +// of ssh.KeyAlgoRSA, ssh.KeyAlgoECDSA256, or ssh.KeyAlgoED25519; while all +// valid algos are supported by this package, the test logic hasn't been +// written for other algos here yet. Generated keys are memoized to avoid +// slow test performance. +func appendCertTestKnownHosts(t *testing.T, filePath, hostPattern, keyType string) { + t.Helper() + + var pubKey ssh.PublicKey + var ok bool + cacheKey := hostPattern + " " + keyType + if pubKey, ok = testCertKeys[cacheKey]; !ok { + switch keyType { + case ssh.KeyAlgoRSA: + pubKey = generatePubKeyRSA(t) + case ssh.KeyAlgoECDSA256: + pubKey = generatePubKeyECDSA(t) + case ssh.KeyAlgoED25519: + pubKey = generatePubKeyEd25519(t) + default: + t.Fatalf("test logic does not support generating key of type %s yet", keyType) + } + testCertKeys[cacheKey] = pubKey + } + + f, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0600) + if err != nil { + t.Fatalf("Unable to open %s for writing: %v", filePath, err) + } + defer f.Close() + if err := WriteKnownHostCA(f, hostPattern, pubKey); err != nil { + t.Fatalf("Unable to append @cert-authority line to %s: %v", filePath, err) + } +} + +func generatePubKeyRSA(t *testing.T) ssh.PublicKey { + t.Helper() + privKey, err := rsa.GenerateKey(rand.Reader, 4096) + if err != nil { + t.Fatalf("Unable to generate RSA key: %v", err) + } + pub, err := ssh.NewPublicKey(&privKey.PublicKey) + if err != nil { + t.Fatalf("Unable to convert public key: %v", err) + } + return pub +} + +func generatePubKeyECDSA(t *testing.T) ssh.PublicKey { + t.Helper() + privKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader) + if err != nil { + t.Fatalf("Unable to generate ECDSA key: %v", err) + } + pub, err := ssh.NewPublicKey(privKey.Public()) + if err != nil { + t.Fatalf("Unable to convert public key: %v", err) + } + return pub +} + +func generatePubKeyEd25519(t *testing.T) ssh.PublicKey { + t.Helper() + rawPub, _, err := ed25519.GenerateKey(nil) + if err != nil { + t.Fatalf("Unable to generate ed25519 key: %v", err) + } + pub, err := ssh.NewPublicKey(rawPub) + if err != nil { + t.Fatalf("Unable to convert public key: %v", err) + } + return pub +} diff --git a/plumbing/transport/ssh/proxy_test.go b/plumbing/transport/ssh/proxy_test.go index 2ba98e823..d3e77c42c 100644 --- a/plumbing/transport/ssh/proxy_test.go +++ b/plumbing/transport/ssh/proxy_test.go @@ -10,26 +10,22 @@ import ( "github.com/armon/go-socks5" "github.com/gliderlabs/ssh" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/plumbing/transport/ssh/internal/test" + "github.com/jesseduffield/go-git/v5/internal/transport/ssh/test" + "github.com/jesseduffield/go-git/v5/plumbing/transport" fixtures "github.com/go-git/go-git-fixtures/v4" stdssh "golang.org/x/crypto/ssh" - . "gopkg.in/check.v1" ) type ProxySuite struct { - u UploadPackSuite - fixtures.Suite + UploadPackSuite } -var _ = Suite(&ProxySuite{}) - var socksProxiedRequests int32 -func (s *ProxySuite) TestCommand(c *C) { +func (s *ProxySuite) TestCommand() { socksListener, err := net.Listen("tcp", "localhost:0") - c.Assert(err, IsNil) + s.NoError(err) socksServer, err := socks5.New(&socks5.Config{ AuthMethods: []socks5.Authenticator{socks5.UserPassAuthenticator{ @@ -39,29 +35,29 @@ func (s *ProxySuite) TestCommand(c *C) { }}, Rules: TestProxyRule{}, }) - c.Assert(err, IsNil) + s.NoError(err) go func() { socksServer.Serve(socksListener) }() socksProxyAddr := fmt.Sprintf("socks5://localhost:%d", socksListener.Addr().(*net.TCPAddr).Port) sshListener, err := net.Listen("tcp", "localhost:0") - c.Assert(err, IsNil) + s.NoError(err) sshServer := &ssh.Server{Handler: test.HandlerSSH} go func() { log.Fatal(sshServer.Serve(sshListener)) }() - s.u.port = sshListener.Addr().(*net.TCPAddr).Port - s.u.base, err = os.MkdirTemp(os.TempDir(), fmt.Sprintf("go-git-ssh-%d", s.u.port)) - c.Assert(err, IsNil) + s.port = sshListener.Addr().(*net.TCPAddr).Port + s.base, err = os.MkdirTemp(s.T().TempDir(), fmt.Sprintf("go-git-ssh-%d", s.port)) + s.NoError(err) DefaultAuthBuilder = func(user string) (AuthMethod, error) { return &Password{User: user}, nil } - ep := s.u.prepareRepository(c, fixtures.Basic().One(), "basic.git") - c.Assert(err, IsNil) + ep := s.prepareRepository(fixtures.Basic().One(), "basic.git") + s.NoError(err) ep.Proxy = transport.ProxyOptions{ URL: socksProxyAddr, Username: "user", @@ -74,9 +70,9 @@ func (s *ProxySuite) TestCommand(c *C) { }, } _, err = runner.Command(transport.UploadPackServiceName, ep, nil) - c.Assert(err, IsNil) + s.NoError(err) proxyUsed := atomic.LoadInt32(&socksProxiedRequests) > 0 - c.Assert(proxyUsed, Equals, true) + s.True(proxyUsed) } type TestProxyRule struct{} diff --git a/plumbing/transport/ssh/sshagent/pageant_windows.go b/plumbing/transport/ssh/sshagent/pageant_windows.go new file mode 100644 index 000000000..a05a2d116 --- /dev/null +++ b/plumbing/transport/ssh/sshagent/pageant_windows.go @@ -0,0 +1,152 @@ +// +// Copyright (c) 2014 David Mzareulyan +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software +// and associated documentation files (the "Software"), to deal in the Software without restriction, +// including without limitation the rights to use, copy, modify, merge, publish, distribute, +// sublicense, and/or sell copies of the Software, and to permit persons to whom the Software +// is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or substantial +// portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +// BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// + +// Originally from: https://github.com/xanzy/ssh-agent/blob/main/pageant_windows.go +// MIT LICENSE: https://github.com/davidmz/go-pageant/blob/master/LICENSE.txt + +//go:build windows +// +build windows + +package sshagent + +// see https://github.com/Yasushi/putty/blob/master/windows/winpgntc.c#L155 +// see https://github.com/paramiko/paramiko/blob/master/paramiko/win_pageant.py + +import ( + "encoding/binary" + "errors" + "fmt" + "sync" + "syscall" + "unsafe" + + "golang.org/x/sys/windows" +) + +// Maximum size of message can be sent to pageant +const MaxMessageLen = 8192 + +var ( + ErrPageantNotFound = errors.New("pageant process not found") + ErrSendMessage = errors.New("error sending message") + + ErrMessageTooLong = errors.New("message too long") + ErrInvalidMessageFormat = errors.New("invalid message format") + ErrResponseTooLong = errors.New("response too long") +) + +const ( + agentCopydataID = 0x804e50ba + wmCopydata = 74 +) + +type copyData struct { + dwData uintptr + cbData uint32 + lpData unsafe.Pointer +} + +var ( + lock sync.Mutex + + user32dll = windows.NewLazySystemDLL("user32.dll") + winFindWindow = winAPI(user32dll, "FindWindowW") + winSendMessage = winAPI(user32dll, "SendMessageW") + + kernel32dll = windows.NewLazySystemDLL("kernel32.dll") + winGetCurrentThreadID = winAPI(kernel32dll, "GetCurrentThreadId") +) + +func winAPI(dll *windows.LazyDLL, funcName string) func(...uintptr) (uintptr, uintptr, error) { + proc := dll.NewProc(funcName) + return func(a ...uintptr) (uintptr, uintptr, error) { return proc.Call(a...) } +} + +// Query sends message msg to Pageant and returns response or error. +// 'msg' is raw agent request with length prefix +// Response is raw agent response with length prefix +func query(msg []byte) ([]byte, error) { + if len(msg) > MaxMessageLen { + return nil, ErrMessageTooLong + } + + msgLen := binary.BigEndian.Uint32(msg[:4]) + if len(msg) != int(msgLen)+4 { + return nil, ErrInvalidMessageFormat + } + + lock.Lock() + defer lock.Unlock() + + paWin := pageantWindow() + + if paWin == 0 { + return nil, ErrPageantNotFound + } + + thID, _, _ := winGetCurrentThreadID() + mapName := fmt.Sprintf("PageantRequest%08x", thID) + pMapName, _ := syscall.UTF16PtrFromString(mapName) + + mmap, err := syscall.CreateFileMapping(syscall.InvalidHandle, nil, syscall.PAGE_READWRITE, 0, MaxMessageLen+4, pMapName) + if err != nil { + return nil, err + } + defer syscall.CloseHandle(mmap) + + ptr, err := syscall.MapViewOfFile(mmap, syscall.FILE_MAP_WRITE, 0, 0, 0) + if err != nil { + return nil, err + } + defer syscall.UnmapViewOfFile(ptr) + + mmSlice := (*(*[MaxMessageLen]byte)(unsafe.Pointer(ptr)))[:] + + copy(mmSlice, msg) + + mapNameBytesZ := append([]byte(mapName), 0) + + cds := copyData{ + dwData: agentCopydataID, + cbData: uint32(len(mapNameBytesZ)), + lpData: unsafe.Pointer(&(mapNameBytesZ[0])), + } + + resp, _, _ := winSendMessage(paWin, wmCopydata, 0, uintptr(unsafe.Pointer(&cds))) + + if resp == 0 { + return nil, ErrSendMessage + } + + respLen := binary.BigEndian.Uint32(mmSlice[:4]) + if respLen > MaxMessageLen-4 { + return nil, ErrResponseTooLong + } + + respData := make([]byte, respLen+4) + copy(respData, mmSlice) + + return respData, nil +} + +func pageantWindow() uintptr { + nameP, _ := syscall.UTF16PtrFromString("Pageant") + h, _, _ := winFindWindow(uintptr(unsafe.Pointer(nameP)), uintptr(unsafe.Pointer(nameP))) + return h +} diff --git a/plumbing/transport/ssh/sshagent/sshagent.go b/plumbing/transport/ssh/sshagent/sshagent.go new file mode 100644 index 000000000..3f68c0d30 --- /dev/null +++ b/plumbing/transport/ssh/sshagent/sshagent.go @@ -0,0 +1,54 @@ +// +// Copyright 2015, Sander van Harmelen +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +// Originally from: https://github.com/xanzy/ssh-agent/blob/main/sshagent.go + +//go:build !windows +// +build !windows + +package sshagent + +import ( + "errors" + "fmt" + "net" + "os" + + "github.com/jesseduffield/go-git/v5/utils/trace" + "golang.org/x/crypto/ssh/agent" +) + +// New returns a new agent.Agent that uses a unix socket +func New() (agent.Agent, net.Conn, error) { + if !Available() { + return nil, nil, errors.New("SSH agent requested but SSH_AUTH_SOCK not-specified") + } + + sshAuthSock := os.Getenv("SSH_AUTH_SOCK") + + trace.SSH.Printf("ssh: net.Dial unix sock %s", sshAuthSock) + conn, err := net.Dial("unix", sshAuthSock) + if err != nil { + return nil, nil, fmt.Errorf("error connecting to SSH_AUTH_SOCK: %v", err) + } + + return agent.NewClient(conn), conn, nil +} + +// Available returns true is a auth socket is defined +func Available() bool { + return os.Getenv("SSH_AUTH_SOCK") != "" +} diff --git a/plumbing/transport/ssh/sshagent/sshagent_windows.go b/plumbing/transport/ssh/sshagent/sshagent_windows.go new file mode 100644 index 000000000..502d98cb5 --- /dev/null +++ b/plumbing/transport/ssh/sshagent/sshagent_windows.go @@ -0,0 +1,110 @@ +// +// Copyright (c) 2014 David Mzareulyan +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software +// and associated documentation files (the "Software"), to deal in the Software without restriction, +// including without limitation the rights to use, copy, modify, merge, publish, distribute, +// sublicense, and/or sell copies of the Software, and to permit persons to whom the Software +// is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or substantial +// portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +// BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// + +// Originally from: https://github.com/xanzy/ssh-agent/blob/main/sshagent_windows.go +// MIT LICENSE: https://github.com/davidmz/go-pageant/blob/master/LICENSE.txt + +//go:build windows +// +build windows + +package sshagent + +import ( + "errors" + "io" + "net" + "sync" + + "github.com/Microsoft/go-winio" + "github.com/jesseduffield/go-git/v5/utils/trace" + "golang.org/x/crypto/ssh/agent" +) + +const ( + sshAgentPipe = `\\.\pipe\openssh-ssh-agent` +) + +// Available returns true if Pageant is running +func Available() bool { + if pageantWindow() != 0 { + return true + } + + conn, err := winio.DialPipe(sshAgentPipe, nil) + if err != nil { + return false + } + conn.Close() + return true +} + +// New returns a new agent.Agent and the (custom) connection it uses +// to communicate with a running pagent.exe instance (see README.md) +func New() (agent.Agent, net.Conn, error) { + if pageantWindow() != 0 { + return agent.NewClient(&conn{}), nil, nil + } + trace.SSH.Printf("ssh: winio.DialPipe %s", sshAgentPipe) + conn, err := winio.DialPipe(sshAgentPipe, nil) + if err != nil { + return nil, nil, errors.New( + "SSH agent requested, but could not detect Pageant or Windows native SSH agent", + ) + } + return agent.NewClient(conn), nil, nil +} + +type conn struct { + sync.Mutex + buf []byte +} + +func (c *conn) Close() { + c.Lock() + defer c.Unlock() + c.buf = nil +} + +func (c *conn) Write(p []byte) (int, error) { + c.Lock() + defer c.Unlock() + + resp, err := query(p) + if err != nil { + return 0, err + } + + c.buf = append(c.buf, resp...) + + return len(p), nil +} + +func (c *conn) Read(p []byte) (int, error) { + c.Lock() + defer c.Unlock() + + if len(c.buf) == 0 { + return 0, io.EOF + } + + n := copy(p, c.buf) + c.buf = c.buf[n:] + + return n, nil +} diff --git a/plumbing/transport/ssh/upload_pack_test.go b/plumbing/transport/ssh/upload_pack_test.go index 67af566e6..4098def28 100644 --- a/plumbing/transport/ssh/upload_pack_test.go +++ b/plumbing/transport/ssh/upload_pack_test.go @@ -12,38 +12,37 @@ import ( "strings" "sync" - "github.com/go-git/go-git/v5/plumbing/transport" - testutils "github.com/go-git/go-git/v5/plumbing/transport/ssh/internal/test" - "github.com/go-git/go-git/v5/plumbing/transport/test" + testutils "github.com/jesseduffield/go-git/v5/internal/transport/ssh/test" + "github.com/jesseduffield/go-git/v5/internal/transport/test" + "github.com/jesseduffield/go-git/v5/plumbing/transport" "github.com/gliderlabs/ssh" fixtures "github.com/go-git/go-git-fixtures/v4" stdssh "golang.org/x/crypto/ssh" - . "gopkg.in/check.v1" ) type UploadPackSuite struct { test.UploadPackSuite - fixtures.Suite opts []ssh.Option port int base string } -var _ = Suite(&UploadPackSuite{}) +func (s *UploadPackSuite) TearDownSuite() { + fixtures.Clean() +} -func (s *UploadPackSuite) SetUpSuite(c *C) { +func (s *UploadPackSuite) SetupSuite() { if runtime.GOOS == "js" { - c.Skip("tcp connections are not available in wasm") + s.T().Skip("tcp connections are not available in wasm") } l, err := net.Listen("tcp", "localhost:0") - c.Assert(err, IsNil) + s.NoError(err) s.port = l.Addr().(*net.TCPAddr).Port - s.base, err = os.MkdirTemp(os.TempDir(), fmt.Sprintf("go-git-ssh-%d", s.port)) - c.Assert(err, IsNil) + s.base = s.T().TempDir() DefaultAuthBuilder = func(user string) (AuthMethod, error) { return &Password{User: user}, nil @@ -53,9 +52,9 @@ func (s *UploadPackSuite) SetUpSuite(c *C) { HostKeyCallback: stdssh.InsecureIgnoreHostKey(), }) - s.UploadPackSuite.Endpoint = s.prepareRepository(c, fixtures.Basic().One(), "basic.git") - s.UploadPackSuite.EmptyEndpoint = s.prepareRepository(c, fixtures.ByTag("empty").One(), "empty.git") - s.UploadPackSuite.NonExistentEndpoint = s.newEndpoint(c, "non-existent.git") + s.UploadPackSuite.Endpoint = s.prepareRepository(fixtures.Basic().One(), "basic.git") + s.UploadPackSuite.EmptyEndpoint = s.prepareRepository(fixtures.ByTag("empty").One(), "empty.git") + s.UploadPackSuite.NonExistentEndpoint = s.newEndpoint("non-existent.git") server := &ssh.Server{Handler: testutils.HandlerSSH} for _, opt := range s.opts { @@ -66,25 +65,25 @@ func (s *UploadPackSuite) SetUpSuite(c *C) { }() } -func (s *UploadPackSuite) prepareRepository(c *C, f *fixtures.Fixture, name string) *transport.Endpoint { +func (s *UploadPackSuite) prepareRepository(f *fixtures.Fixture, name string) *transport.Endpoint { fs := f.DotGit() err := fixtures.EnsureIsBare(fs) - c.Assert(err, IsNil) + s.NoError(err) path := filepath.Join(s.base, name) err = os.Rename(fs.Root(), path) - c.Assert(err, IsNil) + s.NoError(err) - return s.newEndpoint(c, name) + return s.newEndpoint(name) } -func (s *UploadPackSuite) newEndpoint(c *C, name string) *transport.Endpoint { +func (s *UploadPackSuite) newEndpoint(name string) *transport.Endpoint { ep, err := transport.NewEndpoint(fmt.Sprintf( "ssh://git@localhost:%d/%s/%s", s.port, filepath.ToSlash(s.base), name, )) - c.Assert(err, IsNil) + s.NoError(err) return ep } diff --git a/plumbing/transport/transport.go b/plumbing/transport/transport.go new file mode 100644 index 000000000..a18e49d12 --- /dev/null +++ b/plumbing/transport/transport.go @@ -0,0 +1,322 @@ +// Package transport includes the implementation for different transport +// protocols. +// +// `Client` can be used to fetch and send packfiles to a git server. +// The `client` package provides higher level functions to instantiate the +// appropriate `Client` based on the repository URL. +// +// go-git supports HTTP and SSH (see `Protocols`), but you can also install +// your own protocols (see the `client` package). +// +// Each protocol has its own implementation of `Client`, but you should +// generally not use them directly, use `client.NewClient` instead. +package transport + +import ( + "bytes" + "context" + "errors" + "fmt" + "io" + "net/url" + "path/filepath" + "strconv" + "strings" + + giturl "github.com/jesseduffield/go-git/v5/internal/url" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" +) + +var ( + ErrRepositoryNotFound = errors.New("repository not found") + ErrEmptyRemoteRepository = errors.New("remote repository is empty") + ErrAuthenticationRequired = errors.New("authentication required") + ErrAuthorizationFailed = errors.New("authorization failed") + ErrEmptyUploadPackRequest = errors.New("empty git-upload-pack given") + ErrInvalidAuthMethod = errors.New("invalid auth method") + ErrAlreadyConnected = errors.New("session already established") +) + +const ( + UploadPackServiceName = "git-upload-pack" + ReceivePackServiceName = "git-receive-pack" +) + +// Transport can initiate git-upload-pack and git-receive-pack processes. +// It is implemented both by the client and the server, making this a RPC. +type Transport interface { + // NewUploadPackSession starts a git-upload-pack session for an endpoint. + NewUploadPackSession(*Endpoint, AuthMethod) (UploadPackSession, error) + // NewReceivePackSession starts a git-receive-pack session for an endpoint. + NewReceivePackSession(*Endpoint, AuthMethod) (ReceivePackSession, error) +} + +type Session interface { + // AdvertisedReferences retrieves the advertised references for a + // repository. + // If the repository does not exist, returns ErrRepositoryNotFound. + // If the repository exists, but is empty, returns ErrEmptyRemoteRepository. + AdvertisedReferences() (*packp.AdvRefs, error) + // AdvertisedReferencesContext retrieves the advertised references for a + // repository. + // If the repository does not exist, returns ErrRepositoryNotFound. + // If the repository exists, but is empty, returns ErrEmptyRemoteRepository. + AdvertisedReferencesContext(context.Context) (*packp.AdvRefs, error) + io.Closer +} + +type AuthMethod interface { + fmt.Stringer + Name() string +} + +// UploadPackSession represents a git-upload-pack session. +// A git-upload-pack session has two steps: reference discovery +// (AdvertisedReferences) and uploading pack (UploadPack). +type UploadPackSession interface { + Session + // UploadPack takes a git-upload-pack request and returns a response, + // including a packfile. Don't be confused by terminology, the client + // side of a git-upload-pack is called git-fetch-pack, although here + // the same interface is used to make it RPC-like. + UploadPack(context.Context, *packp.UploadPackRequest) (*packp.UploadPackResponse, error) +} + +// ReceivePackSession represents a git-receive-pack session. +// A git-receive-pack session has two steps: reference discovery +// (AdvertisedReferences) and receiving pack (ReceivePack). +// In that order. +type ReceivePackSession interface { + Session + // ReceivePack sends an update references request and a packfile + // reader and returns a ReportStatus and error. Don't be confused by + // terminology, the client side of a git-receive-pack is called + // git-send-pack, although here the same interface is used to make it + // RPC-like. + ReceivePack(context.Context, *packp.ReferenceUpdateRequest) (*packp.ReportStatus, error) +} + +// Endpoint represents a Git URL in any supported protocol. +type Endpoint struct { + // Protocol is the protocol of the endpoint (e.g. git, https, file). + Protocol string + // User is the user. + User string + // Password is the password. + Password string + // Host is the host. + Host string + // Port is the port to connect, if 0 the default port for the given protocol + // will be used. + Port int + // Path is the repository path. + Path string + // InsecureSkipTLS skips ssl verify if protocol is https + InsecureSkipTLS bool + // CaBundle specify additional ca bundle with system cert pool + CaBundle []byte + // Proxy provides info required for connecting to a proxy. + Proxy ProxyOptions +} + +type ProxyOptions struct { + URL string + Username string + Password string +} + +func (o *ProxyOptions) Validate() error { + if o.URL != "" { + _, err := url.Parse(o.URL) + return err + } + return nil +} + +func (o *ProxyOptions) FullURL() (*url.URL, error) { + proxyURL, err := url.Parse(o.URL) + if err != nil { + return nil, err + } + if o.Username != "" { + if o.Password != "" { + proxyURL.User = url.UserPassword(o.Username, o.Password) + } else { + proxyURL.User = url.User(o.Username) + } + } + return proxyURL, nil +} + +var defaultPorts = map[string]int{ + "http": 80, + "https": 443, + "git": 9418, + "ssh": 22, +} + +// String returns a string representation of the Git URL. +func (u *Endpoint) String() string { + var buf bytes.Buffer + if u.Protocol != "" { + buf.WriteString(u.Protocol) + buf.WriteByte(':') + } + + if u.Protocol != "" || u.Host != "" || u.User != "" || u.Password != "" { + buf.WriteString("//") + + if u.User != "" || u.Password != "" { + buf.WriteString(url.PathEscape(u.User)) + if u.Password != "" { + buf.WriteByte(':') + buf.WriteString(url.PathEscape(u.Password)) + } + + buf.WriteByte('@') + } + + if u.Host != "" { + buf.WriteString(u.Host) + + if u.Port != 0 { + port, ok := defaultPorts[strings.ToLower(u.Protocol)] + if !ok || ok && port != u.Port { + fmt.Fprintf(&buf, ":%d", u.Port) + } + } + } + } + + if u.Path != "" && u.Path[0] != '/' && u.Host != "" { + buf.WriteByte('/') + } + + buf.WriteString(u.Path) + return buf.String() +} + +func NewEndpoint(endpoint string) (*Endpoint, error) { + if e, ok := parseSCPLike(endpoint); ok { + return e, nil + } + + if e, ok := parseFile(endpoint); ok { + return e, nil + } + + return parseURL(endpoint) +} + +func parseURL(endpoint string) (*Endpoint, error) { + u, err := url.Parse(endpoint) + if err != nil { + return nil, err + } + + if !u.IsAbs() { + return nil, plumbing.NewPermanentError(fmt.Errorf( + "invalid endpoint: %s", endpoint, + )) + } + + var user, pass string + if u.User != nil { + user = u.User.Username() + pass, _ = u.User.Password() + } + + host := u.Hostname() + if strings.Contains(host, ":") { + // IPv6 address + host = "[" + host + "]" + } + + return &Endpoint{ + Protocol: u.Scheme, + User: user, + Password: pass, + Host: host, + Port: getPort(u), + Path: getPath(u), + }, nil +} + +func getPort(u *url.URL) int { + p := u.Port() + if p == "" { + return 0 + } + + i, err := strconv.Atoi(p) + if err != nil { + return 0 + } + + return i +} + +func getPath(u *url.URL) string { + var res string = u.Path + if u.RawQuery != "" { + res += "?" + u.RawQuery + } + + if u.Fragment != "" { + res += "#" + u.Fragment + } + + return res +} + +func parseSCPLike(endpoint string) (*Endpoint, bool) { + if giturl.MatchesScheme(endpoint) || !giturl.MatchesScpLike(endpoint) { + return nil, false + } + + user, host, portStr, path := giturl.FindScpLikeComponents(endpoint) + port, err := strconv.Atoi(portStr) + if err != nil { + port = 22 + } + + return &Endpoint{ + Protocol: "ssh", + User: user, + Host: host, + Port: port, + Path: path, + }, true +} + +func parseFile(endpoint string) (*Endpoint, bool) { + if giturl.MatchesScheme(endpoint) { + return nil, false + } + + path, err := filepath.Abs(endpoint) + if err != nil { + return nil, false + } + return &Endpoint{ + Protocol: "file", + Path: path, + }, true +} + +// UnsupportedCapabilities are the capabilities not supported by any client +// implementation +var UnsupportedCapabilities = []capability.Capability{ + capability.ThinPack, +} + +// FilterUnsupportedCapabilities it filter out all the UnsupportedCapabilities +// from a capability.List, the intended usage is on the client implementation +// to filter the capabilities from an AdvRefs message. +func FilterUnsupportedCapabilities(list *capability.List) { + for _, c := range UnsupportedCapabilities { + list.Delete(c) + } +} diff --git a/plumbing/transport/transport_test.go b/plumbing/transport/transport_test.go new file mode 100644 index 000000000..a4764b40c --- /dev/null +++ b/plumbing/transport/transport_test.go @@ -0,0 +1,243 @@ +package transport + +import ( + "fmt" + "net/url" + "os" + "path/filepath" + "runtime" + "testing" + + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/stretchr/testify/suite" +) + +func TestSuiteCommon(t *testing.T) { + suite.Run(t, new(SuiteCommon)) +} + +type SuiteCommon struct { + suite.Suite +} + +func (s *SuiteCommon) TestNewEndpointHTTP() { + e, err := NewEndpoint("http://git:pass@github.com/user/repository.git?foo#bar") + s.Nil(err) + s.Equal("http", e.Protocol) + s.Equal("git", e.User) + s.Equal("pass", e.Password) + s.Equal("github.com", e.Host) + s.Equal(0, e.Port) + s.Equal("/user/repository.git?foo#bar", e.Path) + s.Equal("http://git:pass@github.com/user/repository.git?foo#bar", e.String()) +} + +func (s *SuiteCommon) TestNewEndpointPorts() { + e, err := NewEndpoint("http://git:pass@github.com:8080/user/repository.git?foo#bar") + s.Nil(err) + s.Equal("http://git:pass@github.com:8080/user/repository.git?foo#bar", e.String()) + + e, err = NewEndpoint("https://git:pass@github.com:443/user/repository.git?foo#bar") + s.Nil(err) + s.Equal("https://git:pass@github.com/user/repository.git?foo#bar", e.String()) + + e, err = NewEndpoint("ssh://git:pass@github.com:22/user/repository.git?foo#bar") + s.Nil(err) + s.Equal("ssh://git:pass@github.com/user/repository.git?foo#bar", e.String()) + + e, err = NewEndpoint("git://github.com:9418/user/repository.git?foo#bar") + s.Nil(err) + s.Equal("git://github.com/user/repository.git?foo#bar", e.String()) +} + +func (s *SuiteCommon) TestNewEndpointSSH() { + e, err := NewEndpoint("ssh://git@github.com/user/repository.git") + s.Nil(err) + s.Equal("ssh", e.Protocol) + s.Equal("git", e.User) + s.Equal("", e.Password) + s.Equal("github.com", e.Host) + s.Equal(0, e.Port) + s.Equal("/user/repository.git", e.Path) + s.Equal("ssh://git@github.com/user/repository.git", e.String()) +} + +func (s *SuiteCommon) TestNewEndpointSSHNoUser() { + e, err := NewEndpoint("ssh://github.com/user/repository.git") + s.Nil(err) + s.Equal("ssh", e.Protocol) + s.Equal("", e.User) + s.Equal("", e.Password) + s.Equal("github.com", e.Host) + s.Equal(0, e.Port) + s.Equal("/user/repository.git", e.Path) + s.Equal("ssh://github.com/user/repository.git", e.String()) +} + +func (s *SuiteCommon) TestNewEndpointSSHWithPort() { + e, err := NewEndpoint("ssh://git@github.com:777/user/repository.git") + s.Nil(err) + s.Equal("ssh", e.Protocol) + s.Equal("git", e.User) + s.Equal("", e.Password) + s.Equal("github.com", e.Host) + s.Equal(777, e.Port) + s.Equal("/user/repository.git", e.Path) + s.Equal("ssh://git@github.com:777/user/repository.git", e.String()) +} + +func (s *SuiteCommon) TestNewEndpointSCPLike() { + e, err := NewEndpoint("git@github.com:user/repository.git") + s.Nil(err) + s.Equal("ssh", e.Protocol) + s.Equal("git", e.User) + s.Equal("", e.Password) + s.Equal("github.com", e.Host) + s.Equal(22, e.Port) + s.Equal("user/repository.git", e.Path) + s.Equal("ssh://git@github.com/user/repository.git", e.String()) +} + +func (s *SuiteCommon) TestNewEndpointSCPLikeWithNumericPath() { + e, err := NewEndpoint("git@github.com:9999/user/repository.git") + s.Nil(err) + s.Equal("ssh", e.Protocol) + s.Equal("git", e.User) + s.Equal("", e.Password) + s.Equal("github.com", e.Host) + s.Equal(22, e.Port) + s.Equal("9999/user/repository.git", e.Path) + s.Equal("ssh://git@github.com/9999/user/repository.git", e.String()) +} + +func (s *SuiteCommon) TestNewEndpointSCPLikeWithPort() { + e, err := NewEndpoint("git@github.com:8080:9999/user/repository.git") + s.Nil(err) + s.Equal("ssh", e.Protocol) + s.Equal("git", e.User) + s.Equal("", e.Password) + s.Equal("github.com", e.Host) + s.Equal(8080, e.Port) + s.Equal("9999/user/repository.git", e.Path) + s.Equal("ssh://git@github.com:8080/9999/user/repository.git", e.String()) +} + +func (s *SuiteCommon) TestNewEndpointFileAbs() { + var err error + abs := "/foo.git" + + if runtime.GOOS == "windows" { + abs, err = filepath.Abs(abs) + s.Nil(err) + } + + e, err := NewEndpoint("/foo.git") + s.Nil(err) + s.Equal("file", e.Protocol) + s.Equal("", e.User) + s.Equal("", e.Password) + s.Equal("", e.Host) + s.Equal(0, e.Port) + s.Equal(abs, e.Path) + s.Equal("file://"+abs, e.String()) +} + +func (s *SuiteCommon) TestNewEndpointFileRel() { + abs, err := filepath.Abs("foo.git") + s.Nil(err) + + e, err := NewEndpoint("foo.git") + s.Nil(err) + s.Equal("file", e.Protocol) + s.Equal("", e.User) + s.Equal("", e.Password) + s.Equal("", e.Host) + s.Equal(0, e.Port) + s.Equal(abs, e.Path) + s.Equal("file://"+abs, e.String()) +} + +func (s *SuiteCommon) TestNewEndpointFileWindows() { + abs := "C:\\foo.git" + + if runtime.GOOS != "windows" { + cwd, err := os.Getwd() + s.Nil(err) + + abs = filepath.Join(cwd, "C:\\foo.git") + } + + e, err := NewEndpoint("C:\\foo.git") + s.Nil(err) + s.Equal("file", e.Protocol) + s.Equal("", e.User) + s.Equal("", e.Password) + s.Equal("", e.Host) + s.Equal(0, e.Port) + s.Equal(abs, e.Path) + s.Equal("file://"+abs, e.String()) +} + +func (s *SuiteCommon) TestNewEndpointFileURL() { + e, err := NewEndpoint("file:///foo.git") + s.Nil(err) + s.Equal("file", e.Protocol) + s.Equal("", e.User) + s.Equal("", e.Password) + s.Equal("", e.Host) + s.Equal(0, e.Port) + s.Equal("/foo.git", e.Path) + s.Equal("file:///foo.git", e.String()) +} + +func (s *SuiteCommon) TestValidEndpoint() { + user := "person@mail.com" + pass := " !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~" + e, err := NewEndpoint(fmt.Sprintf( + "http://%s:%s@github.com/user/repository.git", + url.PathEscape(user), + url.PathEscape(pass), + )) + s.Nil(err) + s.NotNil(e) + s.Equal(user, e.User) + s.Equal(pass, e.Password) + s.Equal("github.com", e.Host) + s.Equal("/user/repository.git", e.Path) + + s.Equal("http://person@mail.com:%20%21%22%23$%25&%27%28%29%2A+%2C-.%2F:%3B%3C=%3E%3F@%5B%5C%5D%5E_%60%7B%7C%7D~@github.com/user/repository.git", e.String()) +} + +func (s *SuiteCommon) TestNewEndpointInvalidURL() { + e, err := NewEndpoint("http://\\") + s.NotNil(err) + s.Nil(e) +} + +func (s *SuiteCommon) TestFilterUnsupportedCapabilities() { + l := capability.NewList() + l.Set(capability.MultiACK) + l.Set(capability.MultiACKDetailed) + + FilterUnsupportedCapabilities(l) + s.False(l.Supports(capability.ThinPack)) +} + +func (s *SuiteCommon) TestNewEndpointIPv6() { + e, err := NewEndpoint("http://[::1]:8080/foo.git") + s.Nil(err) + s.Equal("[::1]", e.Host) + s.Equal("http://[::1]:8080/foo.git", e.String()) +} + +func FuzzNewEndpoint(f *testing.F) { + f.Add("http://127.0.0.1:8080/foo.git") + f.Add("http://[::1]:8080/foo.git") + f.Add("file:///foo.git") + f.Add("ssh://git@github.com/user/repository.git") + f.Add("git@github.com:user/repository.git") + + f.Fuzz(func(t *testing.T, input string) { + NewEndpoint(input) + }) +} diff --git a/plumbing/transport/version.go b/plumbing/transport/version.go new file mode 100644 index 000000000..987e77722 --- /dev/null +++ b/plumbing/transport/version.go @@ -0,0 +1,47 @@ +package transport + +import ( + "strings" + + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing/protocol" + "github.com/jesseduffield/go-git/v5/utils/ioutil" +) + +// DiscoverVersion reads the first pktline from the reader to determine the +// protocol version. This is used by the client to determine the protocol +// version of the server. +func DiscoverVersion(r ioutil.ReadPeeker) (protocol.Version, error) { + ver := protocol.V0 + _, pktb, err := pktline.PeekLine(r) + if err != nil { + return ver, err + } + + pkt := strings.TrimSpace(string(pktb)) + if strings.HasPrefix(pkt, "version ") { + // Consume the version packet + pktline.ReadLine(r) // nolint:errcheck + if v, _ := protocol.Parse(pkt[8:]); v > ver { + ver = protocol.Version(v) + } + } + + return ver, nil +} + +// ProtocolVersion tries to find the version parameter in the protocol string. +// This expects the protocol string from the GIT_PROTOCOL environment variable. +// This is used by the server to determine the protocol version requested by +// the client. +func ProtocolVersion(p string) protocol.Version { + var ver protocol.Version + for _, param := range strings.Split(p, ":") { + if strings.HasPrefix(param, "version=") { + if v, _ := protocol.Parse(param[8:]); v > ver { + ver = protocol.Version(v) + } + } + } + return ver +} diff --git a/plumbing/transport/version_test.go b/plumbing/transport/version_test.go new file mode 100644 index 000000000..82a55df61 --- /dev/null +++ b/plumbing/transport/version_test.go @@ -0,0 +1,117 @@ +package transport + +import ( + "bufio" + "bytes" + "testing" + + "github.com/jesseduffield/go-git/v5/plumbing/format/pktline" + "github.com/jesseduffield/go-git/v5/plumbing/protocol" + "github.com/stretchr/testify/assert" +) + +func TestDiscoverVersion(t *testing.T) { + tests := []struct { + name string + input string + expected protocol.Version + wantErr bool + }{ + { + name: "version 1", + input: "version 1\n", + expected: protocol.V1, + }, + { + name: "version 2", + input: "version 2\n", + expected: protocol.V2, + }, + { + name: "no version prefix", + input: "git-upload-pack /project.git\n", + expected: protocol.V0, + }, + { + name: "unknown version", + input: "version 999\n", + expected: protocol.V0, + }, + { + name: "empty input", + input: "", + expected: protocol.V0, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + var buf bytes.Buffer + if tt.input != "" { + pktline.WriteString(&buf, tt.input) //nolint:errcheck + } + + r := bufio.NewReader(&buf) + version, err := DiscoverVersion(r) + if tt.wantErr { + assert.Error(t, err) + return + } + + assert.NoError(t, err) + assert.Equal(t, tt.expected, version) + }) + } +} + +func TestProtocolVersion(t *testing.T) { + tests := []struct { + name string + input string + expected protocol.Version + }{ + { + name: "version 1", + input: "version=1", + expected: protocol.V1, + }, + { + name: "version 2", + input: "version=2", + expected: protocol.V2, + }, + { + name: "version with other parameters", + input: "hello:version=2:side-band-64k", + expected: protocol.V2, + }, + { + name: "multiple versions takes highest", + input: "version=1:version=2", + expected: protocol.V2, + }, + { + name: "no version parameter", + input: "side-band-64k:thin-pack", + expected: protocol.V0, + }, + { + name: "unknown version", + input: "version=999", + expected: protocol.V0, + }, + { + name: "empty string", + input: "", + expected: protocol.V0, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + version := ProtocolVersion(tt.input) + assert.Equal(t, tt.expected, version) + }) + } +} diff --git a/prune.go b/prune.go index 8e35b994e..d8772de6f 100644 --- a/prune.go +++ b/prune.go @@ -4,8 +4,8 @@ import ( "errors" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" ) type PruneHandler func(unreferencedObjectHash plumbing.Hash) error diff --git a/prune_test.go b/prune_test.go index 8c726d04c..355ef21c6 100644 --- a/prune_test.go +++ b/prune_test.go @@ -1,75 +1,79 @@ package git import ( + "testing" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage" - "github.com/go-git/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) type PruneSuite struct { + suite.Suite BaseSuite } -var _ = Suite(&PruneSuite{}) +func TestPruneSuite(t *testing.T) { + suite.Run(t, new(PruneSuite)) +} -func (s *PruneSuite) testPrune(c *C, deleteTime time.Time) { +func (s *PruneSuite) testPrune(deleteTime time.Time) { srcFs := fixtures.ByTag("unpacked").One().DotGit() var sto storage.Storer var err error sto = filesystem.NewStorage(srcFs, cache.NewObjectLRUDefault()) los := sto.(storer.LooseObjectStorer) - c.Assert(los, NotNil) + s.NotNil(los) count := 0 err = los.ForEachObjectHash(func(_ plumbing.Hash) error { count++ return nil }) - c.Assert(err, IsNil) + s.NoError(err) r, err := Open(sto, srcFs) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) // Remove a branch so we can prune some objects. err = sto.RemoveReference(plumbing.ReferenceName("refs/heads/v4")) - c.Assert(err, IsNil) + s.NoError(err) err = sto.RemoveReference(plumbing.ReferenceName("refs/remotes/origin/v4")) - c.Assert(err, IsNil) + s.NoError(err) err = r.Prune(PruneOptions{ OnlyObjectsOlderThan: deleteTime, Handler: r.DeleteObject, }) - c.Assert(err, IsNil) + s.NoError(err) newCount := 0 err = los.ForEachObjectHash(func(_ plumbing.Hash) error { newCount++ return nil }) - c.Assert(err, IsNil) + s.NoError(err) if deleteTime.IsZero() { - c.Assert(newCount < count, Equals, true) + s.True(newCount < count) } else { // Assume a delete time older than any of the objects was passed in. - c.Assert(newCount, Equals, count) + s.Equal(count, newCount) } } -func (s *PruneSuite) TestPrune(c *C) { - s.testPrune(c, time.Time{}) +func (s *PruneSuite) TestPrune() { + s.testPrune(time.Time{}) } -func (s *PruneSuite) TestPruneWithNoDelete(c *C) { - s.testPrune(c, time.Unix(0, 1)) +func (s *PruneSuite) TestPruneWithNoDelete() { + s.testPrune(time.Unix(0, 1)) } diff --git a/remote.go b/remote.go index 170883abc..254ccf161 100644 --- a/remote.go +++ b/remote.go @@ -10,23 +10,22 @@ import ( "github.com/go-git/go-billy/v5/osfs" - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/internal/url" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/format/packfile" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/plumbing/protocol/packp" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband" - "github.com/go-git/go-git/v5/plumbing/revlist" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/plumbing/transport/client" - "github.com/go-git/go-git/v5/storage" - "github.com/go-git/go-git/v5/storage/filesystem" - "github.com/go-git/go-git/v5/storage/memory" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/internal/url" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/format/packfile" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/sideband" + "github.com/jesseduffield/go-git/v5/plumbing/revlist" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/storage" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/jesseduffield/go-git/v5/utils/ioutil" ) var ( @@ -35,6 +34,7 @@ var ( ErrForceNeeded = errors.New("some refs were not updated") ErrExactSHA1NotSupported = errors.New("server does not support exact SHA1 refspec") ErrEmptyUrls = errors.New("URLs cannot be empty") + ErrFilterNotSupported = errors.New("server does not support filters") ) type NoMatchingRefSpecError struct { @@ -83,7 +83,7 @@ func (r *Remote) String() string { var fetch, push string if len(r.c.URLs) > 0 { fetch = r.c.URLs[0] - push = r.c.URLs[0] + push = r.c.URLs[len(r.c.URLs)-1] } return fmt.Sprintf("%s\t%s (fetch)\n%[1]s\t%[3]s (push)", r.c.Name, fetch, push) @@ -110,8 +110,8 @@ func (r *Remote) PushContext(ctx context.Context, o *PushOptions) (err error) { return fmt.Errorf("remote names don't match: %s != %s", o.RemoteName, r.c.Name) } - if o.RemoteURL == "" { - o.RemoteURL = r.c.URLs[0] + if o.RemoteURL == "" && len(r.c.URLs) > 0 { + o.RemoteURL = r.c.URLs[len(r.c.URLs)-1] } s, err := newSendPackSession(o.RemoteURL, o.Auth, o.InsecureSkipTLS, o.CABundle, o.ProxyOptions) @@ -199,7 +199,7 @@ func (r *Remote) PushContext(ctx context.Context, o *PushOptions) (err error) { // faster to use a local storage layer to get the commits // to ignore, when calculating the object revlist. localStorer := filesystem.NewStorage( - osfs.New(o.RemoteURL), cache.NewObjectLRUDefault()) + osfs.New(o.RemoteURL, osfs.WithBoundOS()), cache.NewObjectLRUDefault()) hashesToPush, err = revlist.ObjectsWithStorageForIgnores( r.s, localStorer, objects, haves) } else { @@ -335,7 +335,6 @@ func (r *Remote) newReferenceUpdateRequest( } if err := r.addReferencesToUpdate(o.RefSpecs, localRefs, remoteRefs, req, o.Prune, o.ForceWithLease); err != nil { - return nil, err } @@ -351,7 +350,6 @@ func (r *Remote) newReferenceUpdateRequest( func (r *Remote) updateRemoteReferenceStorage( req *packp.ReferenceUpdateRequest, ) error { - for _, spec := range r.c.Fetch { for _, c := range req.Commands { if !spec.Match(c.Name) { @@ -559,7 +557,7 @@ func newClient(url string, insecure bool, cabundle []byte, proxyOpts transport.P ep.CaBundle = cabundle ep.Proxy = proxyOpts - c, err := client.NewClient(ep) + c, err := transport.Get(ep.Protocol) if err != nil { return nil, nil, err } @@ -568,8 +566,8 @@ func newClient(url string, insecure bool, cabundle []byte, proxyOpts transport.P } func (r *Remote) fetchPack(ctx context.Context, o *FetchOptions, s transport.UploadPackSession, - req *packp.UploadPackRequest) (err error) { - + req *packp.UploadPackRequest, +) (err error) { reader, err := s.UploadPack(ctx, req) if err != nil { if errors.Is(err, transport.ErrEmptyUploadPackRequest) { @@ -688,7 +686,8 @@ func (r *Remote) deleteReferences(rs config.RefSpec, remoteRefs storer.ReferenceStorer, refsDict map[string]*plumbing.Reference, req *packp.ReferenceUpdateRequest, - prune bool) error { + prune bool, +) error { iter, err := remoteRefs.IterReferences() if err != nil { return err @@ -724,8 +723,8 @@ func (r *Remote) deleteReferences(rs config.RefSpec, func (r *Remote) addCommit(rs config.RefSpec, remoteRefs storer.ReferenceStorer, localCommit plumbing.Hash, - req *packp.ReferenceUpdateRequest) error { - + req *packp.ReferenceUpdateRequest, +) error { if rs.IsWildcard() { return errors.New("can't use wildcard together with hash refspecs") } @@ -761,8 +760,8 @@ func (r *Remote) addCommit(rs config.RefSpec, func (r *Remote) addReferenceIfRefSpecMatches(rs config.RefSpec, remoteRefs storer.ReferenceStorer, localRef *plumbing.Reference, - req *packp.ReferenceUpdateRequest, forceWithLease *ForceWithLease) error { - + req *packp.ReferenceUpdateRequest, forceWithLease *ForceWithLease, +) error { if localRef.Type() != plumbing.HashReference { return nil } @@ -857,7 +856,8 @@ func (r *Remote) references() ([]*plumbing.Reference, error) { } func getRemoteRefsFromStorer(remoteRefStorer storer.ReferenceStorer) ( - map[plumbing.Hash]bool, error) { + map[plumbing.Hash]bool, error, +) { remoteRefs := map[plumbing.Hash]bool{} iter, err := remoteRefStorer.IterReferences() if err != nil { @@ -969,9 +969,9 @@ const refspecAllTags = "+refs/tags/*:refs/tags/*" func calculateRefs( spec []config.RefSpec, remoteRefs storer.ReferenceStorer, - tagMode TagMode, + tagMode plumbing.TagMode, ) (memory.ReferenceStorage, [][]*plumbing.Reference, error) { - if tagMode == AllTags { + if tagMode == plumbing.AllTags { spec = append(spec, refspecAllTags) } @@ -1152,8 +1152,8 @@ func isFastForward(s storer.EncodedObjectStorer, old, new plumbing.Hash, earlies } func (r *Remote) newUploadPackRequest(o *FetchOptions, - ar *packp.AdvRefs) (*packp.UploadPackRequest, error) { - + ar *packp.AdvRefs, +) (*packp.UploadPackRequest, error) { req := packp.NewUploadPackRequestFromCapabilities(ar.Capabilities) if o.Depth != 0 { @@ -1169,6 +1169,16 @@ func (r *Remote) newUploadPackRequest(o *FetchOptions, } } + if o.Filter != "" { + if ar.Capabilities.Supports(capability.Filter) { + req.Filter = o.Filter + if err := req.Capabilities.Set(capability.Filter); err != nil { + return nil, err + } + } else { + return nil, ErrFilterNotSupported + } + } isWildcard := true for _, s := range o.RefSpecs { if !s.IsWildcard() { @@ -1177,7 +1187,7 @@ func (r *Remote) newUploadPackRequest(o *FetchOptions, } } - if isWildcard && o.Tags == TagFollowing && ar.Capabilities.Supports(capability.IncludeTag) { + if isWildcard && o.Tags == plumbing.TagFollowing && ar.Capabilities.Supports(capability.IncludeTag) { if err := req.Capabilities.Set(capability.IncludeTag); err != nil { return nil, err } @@ -1228,7 +1238,7 @@ func (r *Remote) updateLocalReferenceStorage( specs []config.RefSpec, fetchedRefs, remoteRefs memory.ReferenceStorage, specToRefs [][]*plumbing.Reference, - tagMode TagMode, + tagMode plumbing.TagMode, force bool, ) (updated bool, err error) { isWildcard := true @@ -1277,7 +1287,7 @@ func (r *Remote) updateLocalReferenceStorage( } } - if tagMode == NoTags { + if tagMode == plumbing.NoTags { return updated, nil } diff --git a/remote_test.go b/remote_test.go index c816cc561..c9e1a0c5d 100644 --- a/remote_test.go +++ b/remote_test.go @@ -16,65 +16,68 @@ import ( "github.com/go-git/go-billy/v5/memfs" "github.com/go-git/go-billy/v5/osfs" "github.com/go-git/go-billy/v5/util" - - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/plumbing/protocol/packp" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage" - "github.com/go-git/go-git/v5/storage/filesystem" - "github.com/go-git/go-git/v5/storage/memory" + "github.com/stretchr/testify/suite" + + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp/capability" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/storage/memory" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) type RemoteSuite struct { + suite.Suite BaseSuite } -var _ = Suite(&RemoteSuite{}) +func TestRemoteSuite(t *testing.T) { + suite.Run(t, new(RemoteSuite)) +} -func (s *RemoteSuite) TestFetchInvalidEndpoint(c *C) { +func (s *RemoteSuite) TestFetchInvalidEndpoint() { r := NewRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"http://\\"}}) err := r.Fetch(&FetchOptions{RemoteName: "foo"}) - c.Assert(err, ErrorMatches, ".*invalid character.*") + s.ErrorContains(err, "invalid character") } -func (s *RemoteSuite) TestFetchNonExistentEndpoint(c *C) { +func (s *RemoteSuite) TestFetchNonExistentEndpoint() { r := NewRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"ssh://non-existent/foo.git"}}) err := r.Fetch(&FetchOptions{}) - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *RemoteSuite) TestFetchInvalidSchemaEndpoint(c *C) { +func (s *RemoteSuite) TestFetchInvalidSchemaEndpoint() { r := NewRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"qux://foo"}}) err := r.Fetch(&FetchOptions{}) - c.Assert(err, ErrorMatches, ".*unsupported scheme.*") + s.ErrorContains(err, "unsupported scheme") } -func (s *RemoteSuite) TestFetchOverriddenEndpoint(c *C) { +func (s *RemoteSuite) TestFetchOverriddenEndpoint() { r := NewRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"http://perfectly-valid-url.example.com"}}) err := r.Fetch(&FetchOptions{RemoteURL: "http://\\"}) - c.Assert(err, ErrorMatches, ".*invalid character.*") + s.ErrorContains(err, "invalid character") } -func (s *RemoteSuite) TestFetchInvalidFetchOptions(c *C) { +func (s *RemoteSuite) TestFetchInvalidFetchOptions() { r := NewRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"qux://foo"}}) invalid := config.RefSpec("^*$ñ") err := r.Fetch(&FetchOptions{RefSpecs: []config.RefSpec{invalid}}) - c.Assert(err, Equals, config.ErrRefSpecMalformedSeparator) + s.ErrorIs(err, config.ErrRefSpecMalformedSeparator) } -func (s *RemoteSuite) TestFetchWildcard(c *C) { +func (s *RemoteSuite) TestFetchWildcard() { r := NewRemote(memory.NewStorage(), &config.RemoteConfig{ URLs: []string{s.GetBasicLocalRepositoryURL()}, }) - s.testFetch(c, r, &FetchOptions{ + s.testFetch(r, &FetchOptions{ RefSpecs: []config.RefSpec{ config.RefSpec("+refs/heads/*:refs/remotes/origin/*"), }, @@ -85,12 +88,12 @@ func (s *RemoteSuite) TestFetchWildcard(c *C) { }) } -func (s *RemoteSuite) TestFetchExactSHA1(c *C) { +func (s *RemoteSuite) TestFetchExactSHA1() { r := NewRemote(memory.NewStorage(), &config.RemoteConfig{ URLs: []string{"https://github.com/git-fixtures/basic.git"}, }) - s.testFetch(c, r, &FetchOptions{ + s.testFetch(r, &FetchOptions{ RefSpecs: []config.RefSpec{ config.RefSpec("35e85108805c84807bc66a02d91535e1e24b38b9:refs/heads/foo"), }, @@ -99,7 +102,7 @@ func (s *RemoteSuite) TestFetchExactSHA1(c *C) { }) } -func (s *RemoteSuite) TestFetchExactSHA1_NotSoported(c *C) { +func (s *RemoteSuite) TestFetchExactSHA1_NotSoported() { r := NewRemote(memory.NewStorage(), &config.RemoteConfig{ URLs: []string{s.GetBasicLocalRepositoryURL()}, }) @@ -110,16 +113,15 @@ func (s *RemoteSuite) TestFetchExactSHA1_NotSoported(c *C) { }, }) - c.Assert(err, Equals, ErrExactSHA1NotSupported) - + s.ErrorIs(err, ErrExactSHA1NotSupported) } -func (s *RemoteSuite) TestFetchWildcardTags(c *C) { +func (s *RemoteSuite) TestFetchWildcardTags() { r := NewRemote(memory.NewStorage(), &config.RemoteConfig{ URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())}, }) - s.testFetch(c, r, &FetchOptions{ + s.testFetch(r, &FetchOptions{ RefSpecs: []config.RefSpec{ config.RefSpec("+refs/heads/*:refs/remotes/origin/*"), }, @@ -133,12 +135,12 @@ func (s *RemoteSuite) TestFetchWildcardTags(c *C) { }) } -func (s *RemoteSuite) TestFetch(c *C) { +func (s *RemoteSuite) TestFetch() { r := NewRemote(memory.NewStorage(), &config.RemoteConfig{ URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())}, }) - s.testFetch(c, r, &FetchOptions{ + s.testFetch(r, &FetchOptions{ RefSpecs: []config.RefSpec{ config.RefSpec("+refs/heads/master:refs/remotes/origin/master"), }, @@ -147,12 +149,12 @@ func (s *RemoteSuite) TestFetch(c *C) { }) } -func (s *RemoteSuite) TestFetchToNewBranch(c *C) { +func (s *RemoteSuite) TestFetchToNewBranch() { r := NewRemote(memory.NewStorage(), &config.RemoteConfig{ URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())}, }) - s.testFetch(c, r, &FetchOptions{ + s.testFetch(r, &FetchOptions{ RefSpecs: []config.RefSpec{ // qualified branch to unqualified branch "refs/heads/master:foo", @@ -173,12 +175,12 @@ func (s *RemoteSuite) TestFetchToNewBranch(c *C) { }) } -func (s *RemoteSuite) TestFetchToNewBranchWithAllTags(c *C) { +func (s *RemoteSuite) TestFetchToNewBranchWithAllTags() { r := NewRemote(memory.NewStorage(), &config.RemoteConfig{ URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())}, }) - s.testFetch(c, r, &FetchOptions{ + s.testFetch(r, &FetchOptions{ Tags: AllTags, RefSpecs: []config.RefSpec{ // qualified branch to unqualified branch @@ -203,7 +205,7 @@ func (s *RemoteSuite) TestFetchToNewBranchWithAllTags(c *C) { }) } -func (s *RemoteSuite) TestFetchNonExistentReference(c *C) { +func (s *RemoteSuite) TestFetchNonExistentReference() { r := NewRemote(memory.NewStorage(), &config.RemoteConfig{ URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())}, }) @@ -214,11 +216,11 @@ func (s *RemoteSuite) TestFetchNonExistentReference(c *C) { }, }) - c.Assert(err, ErrorMatches, "couldn't find remote ref.*") - c.Assert(errors.Is(err, NoMatchingRefSpecError{}), Equals, true) + s.ErrorContains(err, "couldn't find remote ref") + s.True(errors.Is(err, NoMatchingRefSpecError{})) } -func (s *RemoteSuite) TestFetchContext(c *C) { +func (s *RemoteSuite) TestFetchContext() { r := NewRemote(memory.NewStorage(), &config.RemoteConfig{ URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())}, }) @@ -231,10 +233,10 @@ func (s *RemoteSuite) TestFetchContext(c *C) { config.RefSpec("+refs/heads/master:refs/remotes/origin/master"), }, }) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *RemoteSuite) TestFetchContextCanceled(c *C) { +func (s *RemoteSuite) TestFetchContextCanceled() { r := NewRemote(memory.NewStorage(), &config.RemoteConfig{ URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())}, }) @@ -247,15 +249,15 @@ func (s *RemoteSuite) TestFetchContextCanceled(c *C) { config.RefSpec("+refs/heads/master:refs/remotes/origin/master"), }, }) - c.Assert(err, Equals, context.Canceled) + s.ErrorIs(err, context.Canceled) } -func (s *RemoteSuite) TestFetchWithAllTags(c *C) { +func (s *RemoteSuite) TestFetchWithAllTags() { r := NewRemote(memory.NewStorage(), &config.RemoteConfig{ URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())}, }) - s.testFetch(c, r, &FetchOptions{ + s.testFetch(r, &FetchOptions{ Tags: AllTags, RefSpecs: []config.RefSpec{ config.RefSpec("+refs/heads/master:refs/remotes/origin/master"), @@ -270,12 +272,12 @@ func (s *RemoteSuite) TestFetchWithAllTags(c *C) { }) } -func (s *RemoteSuite) TestFetchWithNoTags(c *C) { +func (s *RemoteSuite) TestFetchWithNoTags() { r := NewRemote(memory.NewStorage(), &config.RemoteConfig{ URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())}, }) - s.testFetch(c, r, &FetchOptions{ + s.testFetch(r, &FetchOptions{ Tags: NoTags, RefSpecs: []config.RefSpec{ config.RefSpec("+refs/heads/*:refs/remotes/origin/*"), @@ -283,15 +285,14 @@ func (s *RemoteSuite) TestFetchWithNoTags(c *C) { }, []*plumbing.Reference{ plumbing.NewReferenceFromStrings("refs/remotes/origin/master", "f7b877701fbf855b44c0a9e86f3fdce2c298b07f"), }) - } -func (s *RemoteSuite) TestFetchWithDepth(c *C) { +func (s *RemoteSuite) TestFetchWithDepth() { r := NewRemote(memory.NewStorage(), &config.RemoteConfig{ URLs: []string{s.GetBasicLocalRepositoryURL()}, }) - s.testFetch(c, r, &FetchOptions{ + s.testFetch(r, &FetchOptions{ Depth: 1, RefSpecs: []config.RefSpec{ config.RefSpec("+refs/heads/*:refs/remotes/origin/*"), @@ -302,15 +303,15 @@ func (s *RemoteSuite) TestFetchWithDepth(c *C) { plumbing.NewReferenceFromStrings("refs/tags/v1.0.0", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"), }) - c.Assert(r.s.(*memory.Storage).Objects, HasLen, 18) + s.Len(r.s.(*memory.Storage).Objects, 18) } -func (s *RemoteSuite) TestFetchWithDepthChange(c *C) { +func (s *RemoteSuite) TestFetchWithDepthChange() { r := NewRemote(memory.NewStorage(), &config.RemoteConfig{ URLs: []string{s.GetBasicLocalRepositoryURL()}, }) - s.testFetch(c, r, &FetchOptions{ + s.testFetch(r, &FetchOptions{ Depth: 1, RefSpecs: []config.RefSpec{ config.RefSpec("refs/heads/master:refs/heads/master"), @@ -318,9 +319,9 @@ func (s *RemoteSuite) TestFetchWithDepthChange(c *C) { }, []*plumbing.Reference{ plumbing.NewReferenceFromStrings("refs/heads/master", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"), }) - c.Assert(r.s.(*memory.Storage).Commits, HasLen, 1) + s.Len(r.s.(*memory.Storage).Commits, 1) - s.testFetch(c, r, &FetchOptions{ + s.testFetch(r, &FetchOptions{ Depth: 3, RefSpecs: []config.RefSpec{ config.RefSpec("refs/heads/master:refs/heads/master"), @@ -328,60 +329,60 @@ func (s *RemoteSuite) TestFetchWithDepthChange(c *C) { }, []*plumbing.Reference{ plumbing.NewReferenceFromStrings("refs/heads/master", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"), }) - c.Assert(r.s.(*memory.Storage).Commits, HasLen, 3) + s.Len(r.s.(*memory.Storage).Commits, 3) } -func (s *RemoteSuite) testFetch(c *C, r *Remote, o *FetchOptions, expected []*plumbing.Reference) { +func (s *RemoteSuite) testFetch(r *Remote, o *FetchOptions, expected []*plumbing.Reference) { err := r.Fetch(o) - c.Assert(err, IsNil) + s.NoError(err) var refs int l, err := r.s.IterReferences() - c.Assert(err, IsNil) + s.NoError(err) l.ForEach(func(r *plumbing.Reference) error { refs++; return nil }) - c.Assert(refs, Equals, len(expected)) + s.Len(expected, refs) for _, exp := range expected { r, err := r.s.Reference(exp.Name()) - c.Assert(err, IsNil) - c.Assert(exp.String(), Equals, r.String()) + s.NoError(err) + s.Equal(r.String(), exp.String()) } } -func (s *RemoteSuite) TestFetchOfMissingObjects(c *C) { - tmp, clean := s.TemporalDir() - defer clean() +func (s *RemoteSuite) TestFetchOfMissingObjects() { + tmp, err := os.MkdirTemp("", "") + s.NoError(err) // clone to a local temp folder - _, err := PlainClone(tmp, true, &CloneOptions{ + _, err = PlainClone(tmp, true, &CloneOptions{ URL: fixtures.Basic().One().DotGit().Root(), }) - c.Assert(err, IsNil) + s.NoError(err) // Delete the pack files fsTmp := osfs.New(tmp) err = util.RemoveAll(fsTmp, "objects/pack") - c.Assert(err, IsNil) + s.NoError(err) // Reopen the repo from the filesystem (with missing objects) r, err := Open(filesystem.NewStorage(fsTmp, cache.NewObjectLRUDefault()), nil) - c.Assert(err, IsNil) + s.NoError(err) // Confirm we are missing a commit _, err = r.CommitObject(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) - c.Assert(err, Equals, plumbing.ErrObjectNotFound) + s.ErrorIs(err, plumbing.ErrObjectNotFound) // Refetch to get all the missing objects err = r.Fetch(&FetchOptions{}) - c.Assert(err, IsNil) + s.NoError(err) // Confirm we now have the commit _, err = r.CommitObject(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *RemoteSuite) TestFetchWithProgress(c *C) { +func (s *RemoteSuite) TestFetchWithProgress() { url := s.GetBasicLocalRepositoryURL() sto := memory.NewStorage() buf := bytes.NewBuffer(nil) @@ -394,10 +395,10 @@ func (s *RemoteSuite) TestFetchWithProgress(c *C) { Progress: buf, }) - c.Assert(err, IsNil) - c.Assert(sto.Objects, HasLen, 31) + s.NoError(err) + s.Len(sto.Objects, 31) - c.Assert(buf.Len(), Not(Equals), 0) + s.NotEqual(0, buf.Len()) } type mockPackfileWriter struct { @@ -410,9 +411,8 @@ func (m *mockPackfileWriter) PackfileWriter() (io.WriteCloser, error) { return m.Storer.(storer.PackfileWriter).PackfileWriter() } -func (s *RemoteSuite) TestFetchWithPackfileWriter(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *RemoteSuite) TestFetchWithPackfileWriter() { + fs := s.TemporalFilesystem() fss := filesystem.NewStorage(fs, cache.NewObjectLRUDefault()) mock := &mockPackfileWriter{Storer: fss} @@ -425,27 +425,27 @@ func (s *RemoteSuite) TestFetchWithPackfileWriter(c *C) { RefSpecs: []config.RefSpec{refspec}, }) - c.Assert(err, IsNil) + s.NoError(err) var count int iter, err := mock.IterEncodedObjects(plumbing.AnyObject) - c.Assert(err, IsNil) + s.NoError(err) iter.ForEach(func(plumbing.EncodedObject) error { count++ return nil }) - c.Assert(count, Equals, 31) - c.Assert(mock.PackfileWriterCalled, Equals, true) + s.Equal(31, count) + s.True(mock.PackfileWriterCalled) } -func (s *RemoteSuite) TestFetchNoErrAlreadyUpToDate(c *C) { +func (s *RemoteSuite) TestFetchNoErrAlreadyUpToDate() { url := s.GetBasicLocalRepositoryURL() - s.doTestFetchNoErrAlreadyUpToDate(c, url) + s.doTestFetchNoErrAlreadyUpToDate(url) } -func (s *RemoteSuite) TestFetchNoErrAlreadyUpToDateButStillUpdateLocalRemoteRefs(c *C) { +func (s *RemoteSuite) TestFetchNoErrAlreadyUpToDateButStillUpdateLocalRemoteRefs() { r := NewRemote(memory.NewStorage(), &config.RemoteConfig{ URLs: []string{s.GetBasicLocalRepositoryURL()}, }) @@ -457,7 +457,7 @@ func (s *RemoteSuite) TestFetchNoErrAlreadyUpToDateButStillUpdateLocalRemoteRefs } err := r.Fetch(o) - c.Assert(err, IsNil) + s.NoError(err) // Simulate an out of date remote ref even though we have the new commit locally r.s.SetReference(plumbing.NewReferenceFromStrings( @@ -465,24 +465,24 @@ func (s *RemoteSuite) TestFetchNoErrAlreadyUpToDateButStillUpdateLocalRemoteRefs )) err = r.Fetch(o) - c.Assert(err, IsNil) + s.NoError(err) exp := plumbing.NewReferenceFromStrings( "refs/remotes/origin/master", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", ) ref, err := r.s.Reference("refs/remotes/origin/master") - c.Assert(err, IsNil) - c.Assert(exp.String(), Equals, ref.String()) + s.NoError(err) + s.Equal(ref.String(), exp.String()) } -func (s *RemoteSuite) TestFetchNoErrAlreadyUpToDateWithNonCommitObjects(c *C) { +func (s *RemoteSuite) TestFetchNoErrAlreadyUpToDateWithNonCommitObjects() { fixture := fixtures.ByTag("tags").One() url := s.GetLocalRepositoryURL(fixture) - s.doTestFetchNoErrAlreadyUpToDate(c, url) + s.doTestFetchNoErrAlreadyUpToDate(url) } -func (s *RemoteSuite) doTestFetchNoErrAlreadyUpToDate(c *C, url string) { +func (s *RemoteSuite) doTestFetchNoErrAlreadyUpToDate(url string) { r := NewRemote(memory.NewStorage(), &config.RemoteConfig{URLs: []string{url}}) o := &FetchOptions{ @@ -492,17 +492,17 @@ func (s *RemoteSuite) doTestFetchNoErrAlreadyUpToDate(c *C, url string) { } err := r.Fetch(o) - c.Assert(err, IsNil) + s.NoError(err) err = r.Fetch(o) - c.Assert(err, Equals, NoErrAlreadyUpToDate) + s.ErrorIs(err, NoErrAlreadyUpToDate) } -func (s *RemoteSuite) testFetchFastForward(c *C, sto storage.Storer) { +func (s *RemoteSuite) testFetchFastForward(sto storage.Storer) { r := NewRemote(sto, &config.RemoteConfig{ URLs: []string{s.GetBasicLocalRepositoryURL()}, }) - s.testFetch(c, r, &FetchOptions{ + s.testFetch(r, &FetchOptions{ RefSpecs: []config.RefSpec{ config.RefSpec("+refs/heads/master:refs/heads/master"), }, @@ -516,7 +516,7 @@ func (s *RemoteSuite) testFetchFastForward(c *C, sto storage.Storer) { config.RefSpec("refs/heads/branch:refs/heads/master"), }, }) - c.Assert(err, Equals, ErrForceNeeded) + s.ErrorIs(err, ErrForceNeeded) // And that forcing it fixes the problem. err = r.Fetch(&FetchOptions{ @@ -524,13 +524,13 @@ func (s *RemoteSuite) testFetchFastForward(c *C, sto storage.Storer) { config.RefSpec("+refs/heads/branch:refs/heads/master"), }, }) - c.Assert(err, IsNil) + s.NoError(err) // Now test that a fast-forward, non-force fetch works. r.s.SetReference(plumbing.NewReferenceFromStrings( "refs/heads/master", "918c48b83bd081e863dbe1b80f8998f058cd8294", )) - s.testFetch(c, r, &FetchOptions{ + s.testFetch(r, &FetchOptions{ RefSpecs: []config.RefSpec{ config.RefSpec("refs/heads/master:refs/heads/master"), }, @@ -539,38 +539,38 @@ func (s *RemoteSuite) testFetchFastForward(c *C, sto storage.Storer) { }) } -func (s *RemoteSuite) TestFetchFastForwardMem(c *C) { - s.testFetchFastForward(c, memory.NewStorage()) +func (s *RemoteSuite) TestFetchFastForwardMem() { + s.testFetchFastForward(memory.NewStorage()) } -func (s *RemoteSuite) TestFetchFastForwardFS(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *RemoteSuite) TestFetchFastForwardFS() { + fs := s.TemporalFilesystem() fss := filesystem.NewStorage(fs, cache.NewObjectLRUDefault()) // This exercises `storage.filesystem.Storage.CheckAndSetReference()`. - s.testFetchFastForward(c, fss) + s.testFetchFastForward(fss) } -func (s *RemoteSuite) TestString(c *C) { +func (s *RemoteSuite) TestString() { r := NewRemote(nil, &config.RemoteConfig{ Name: "foo", URLs: []string{"https://github.com/git-fixtures/basic.git"}, }) - c.Assert(r.String(), Equals, ""+ + s.Equal(""+ "foo\thttps://github.com/git-fixtures/basic.git (fetch)\n"+ "foo\thttps://github.com/git-fixtures/basic.git (push)", + r.String(), ) } -func (s *RemoteSuite) TestPushToEmptyRepository(c *C) { - url, clean := s.TemporalDir() - defer clean() +func (s *RemoteSuite) TestPushToEmptyRepository() { + url, err := os.MkdirTemp("", "") + s.NoError(err) server, err := PlainInit(url, true) - c.Assert(err, IsNil) + s.NoError(err) srcFs := fixtures.Basic().One().DotGit() sto := filesystem.NewStorage(srcFs, cache.NewObjectLRUDefault()) @@ -584,10 +584,10 @@ func (s *RemoteSuite) TestPushToEmptyRepository(c *C) { err = r.Push(&PushOptions{ RefSpecs: []config.RefSpec{rs}, }) - c.Assert(err, IsNil) + s.NoError(err) iter, err := r.s.IterReferences() - c.Assert(err, IsNil) + s.NoError(err) expected := make(map[string]string) iter.ForEach(func(ref *plumbing.Reference) error { @@ -598,18 +598,17 @@ func (s *RemoteSuite) TestPushToEmptyRepository(c *C) { expected[ref.Name().String()] = ref.Hash().String() return nil }) - c.Assert(err, IsNil) - - AssertReferences(c, server, expected) + s.NoError(err) + AssertReferences(s.T(), server, expected) } -func (s *RemoteSuite) TestPushContext(c *C) { - url, clean := s.TemporalDir() - defer clean() +func (s *RemoteSuite) TestPushContext() { + url, err := os.MkdirTemp("", "") + s.NoError(err) - _, err := PlainInit(url, true) - c.Assert(err, IsNil) + _, err = PlainInit(url, true) + s.NoError(err) fs := fixtures.ByURL("https://github.com/git-fixtures/tags.git").One().DotGit() sto := filesystem.NewStorage(fs, cache.NewObjectLRUDefault()) @@ -627,14 +626,14 @@ func (s *RemoteSuite) TestPushContext(c *C) { err = r.PushContext(ctx, &PushOptions{ RefSpecs: []config.RefSpec{"refs/tags/*:refs/tags/*"}, }) - c.Assert(err, IsNil) + s.NoError(err) - eventually(c, func() bool { + eventually(s, func() bool { return runtime.NumGoroutine() <= numGoroutines }) } -func eventually(c *C, condition func() bool) { +func eventually(s *RemoteSuite, condition func() bool) { select { case <-time.After(5 * time.Second): default: @@ -644,15 +643,15 @@ func eventually(c *C, condition func() bool) { time.Sleep(100 * time.Millisecond) } - c.Assert(condition(), Equals, true) + s.True(condition()) } -func (s *RemoteSuite) TestPushContextCanceled(c *C) { - url, clean := s.TemporalDir() - defer clean() +func (s *RemoteSuite) TestPushContextCanceled() { + url, err := os.MkdirTemp("", "") + s.NoError(err) - _, err := PlainInit(url, true) - c.Assert(err, IsNil) + _, err = PlainInit(url, true) + s.NoError(err) fs := fixtures.ByURL("https://github.com/git-fixtures/tags.git").One().DotGit() sto := filesystem.NewStorage(fs, cache.NewObjectLRUDefault()) @@ -670,19 +669,19 @@ func (s *RemoteSuite) TestPushContextCanceled(c *C) { err = r.PushContext(ctx, &PushOptions{ RefSpecs: []config.RefSpec{"refs/tags/*:refs/tags/*"}, }) - c.Assert(err, Equals, context.Canceled) + s.ErrorIs(err, context.Canceled) - eventually(c, func() bool { + eventually(s, func() bool { return runtime.NumGoroutine() <= numGoroutines }) } -func (s *RemoteSuite) TestPushTags(c *C) { - url, clean := s.TemporalDir() - defer clean() +func (s *RemoteSuite) TestPushTags() { + url, err := os.MkdirTemp("", "") + s.NoError(err) server, err := PlainInit(url, true) - c.Assert(err, IsNil) + s.NoError(err) fs := fixtures.ByURL("https://github.com/git-fixtures/tags.git").One().DotGit() sto := filesystem.NewStorage(fs, cache.NewObjectLRUDefault()) @@ -695,9 +694,9 @@ func (s *RemoteSuite) TestPushTags(c *C) { err = r.Push(&PushOptions{ RefSpecs: []config.RefSpec{"refs/tags/*:refs/tags/*"}, }) - c.Assert(err, IsNil) + s.NoError(err) - AssertReferences(c, server, map[string]string{ + AssertReferences(s.T(), server, map[string]string{ "refs/tags/lightweight-tag": "f7b877701fbf855b44c0a9e86f3fdce2c298b07f", "refs/tags/annotated-tag": "b742a2a9fa0afcfa9a6fad080980fbc26b007c69", "refs/tags/commit-tag": "ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc", @@ -706,12 +705,12 @@ func (s *RemoteSuite) TestPushTags(c *C) { }) } -func (s *RemoteSuite) TestPushFollowTags(c *C) { - url, clean := s.TemporalDir() - defer clean() +func (s *RemoteSuite) TestPushFollowTags() { + url, err := os.MkdirTemp("", "") + s.NoError(err) server, err := PlainInit(url, true) - c.Assert(err, IsNil) + s.NoError(err) fs := fixtures.ByURL("https://github.com/git-fixtures/basic.git").One().DotGit() sto := filesystem.NewStorage(fs, cache.NewObjectLRUDefault()) @@ -729,7 +728,7 @@ func (s *RemoteSuite) TestPushFollowTags(c *C) { Message: "an annotated tag", }, ) - c.Assert(err, IsNil) + s.NoError(err) initialTag, err := localRepo.CreateTag( "initial-commit", @@ -738,7 +737,7 @@ func (s *RemoteSuite) TestPushFollowTags(c *C) { Message: "a tag for the initial commit", }, ) - c.Assert(err, IsNil) + s.NoError(err) _, err = localRepo.CreateTag( "master-tag", @@ -747,26 +746,26 @@ func (s *RemoteSuite) TestPushFollowTags(c *C) { Message: "a tag with a commit not reachable from branch", }, ) - c.Assert(err, IsNil) + s.NoError(err) err = r.Push(&PushOptions{ RefSpecs: []config.RefSpec{"+refs/heads/branch:refs/heads/branch"}, FollowTags: true, }) - c.Assert(err, IsNil) + s.NoError(err) - AssertReferences(c, server, map[string]string{ + AssertReferences(s.T(), server, map[string]string{ "refs/heads/branch": "e8d3ffab552895c19b9fcf7aa264d277cde33881", "refs/tags/tip": tipTag.Hash().String(), "refs/tags/initial-commit": initialTag.Hash().String(), }) - AssertReferencesMissing(c, server, []string{ + AssertReferencesMissing(s.T(), server, []string{ "refs/tags/master-tag", }) } -func (s *RemoteSuite) TestPushNoErrAlreadyUpToDate(c *C) { +func (s *RemoteSuite) TestPushNoErrAlreadyUpToDate() { fs := fixtures.Basic().One().DotGit() sto := filesystem.NewStorage(fs, cache.NewObjectLRUDefault()) @@ -778,95 +777,95 @@ func (s *RemoteSuite) TestPushNoErrAlreadyUpToDate(c *C) { err := r.Push(&PushOptions{ RefSpecs: []config.RefSpec{"refs/heads/*:refs/heads/*"}, }) - c.Assert(err, Equals, NoErrAlreadyUpToDate) + s.ErrorIs(err, NoErrAlreadyUpToDate) } -func (s *RemoteSuite) TestPushDeleteReference(c *C) { +func (s *RemoteSuite) TestPushDeleteReference() { fs := fixtures.Basic().One().DotGit() sto := filesystem.NewStorage(fs, cache.NewObjectLRUDefault()) - url, clean := s.TemporalDir() - defer clean() + url, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainClone(url, true, &CloneOptions{ URL: fs.Root(), }) - c.Assert(err, IsNil) + s.NoError(err) remote, err := r.Remote(DefaultRemoteName) - c.Assert(err, IsNil) + s.NoError(err) err = remote.Push(&PushOptions{ RefSpecs: []config.RefSpec{":refs/heads/branch"}, }) - c.Assert(err, IsNil) + s.NoError(err) _, err = sto.Reference(plumbing.ReferenceName("refs/heads/branch")) - c.Assert(err, Equals, plumbing.ErrReferenceNotFound) + s.ErrorIs(err, plumbing.ErrReferenceNotFound) _, err = r.Storer.Reference(plumbing.ReferenceName("refs/heads/branch")) - c.Assert(err, Equals, plumbing.ErrReferenceNotFound) + s.ErrorIs(err, plumbing.ErrReferenceNotFound) } -func (s *RemoteSuite) TestForcePushDeleteReference(c *C) { +func (s *RemoteSuite) TestForcePushDeleteReference() { fs := fixtures.Basic().One().DotGit() sto := filesystem.NewStorage(fs, cache.NewObjectLRUDefault()) - url, clean := s.TemporalDir() - defer clean() + url, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainClone(url, true, &CloneOptions{ URL: fs.Root(), }) - c.Assert(err, IsNil) + s.NoError(err) remote, err := r.Remote(DefaultRemoteName) - c.Assert(err, IsNil) + s.NoError(err) err = remote.Push(&PushOptions{ RefSpecs: []config.RefSpec{":refs/heads/branch"}, Force: true, }) - c.Assert(err, IsNil) + s.NoError(err) _, err = sto.Reference(plumbing.ReferenceName("refs/heads/branch")) - c.Assert(err, Equals, plumbing.ErrReferenceNotFound) + s.ErrorIs(err, plumbing.ErrReferenceNotFound) _, err = r.Storer.Reference(plumbing.ReferenceName("refs/heads/branch")) - c.Assert(err, Equals, plumbing.ErrReferenceNotFound) + s.ErrorIs(err, plumbing.ErrReferenceNotFound) } -func (s *RemoteSuite) TestPushRejectNonFastForward(c *C) { +func (s *RemoteSuite) TestPushRejectNonFastForward() { fs := fixtures.Basic().One().DotGit() server := filesystem.NewStorage(fs, cache.NewObjectLRUDefault()) - url, clean := s.TemporalDir() - defer clean() + url, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainClone(url, true, &CloneOptions{ URL: fs.Root(), }) - c.Assert(err, IsNil) + s.NoError(err) remote, err := r.Remote(DefaultRemoteName) - c.Assert(err, IsNil) + s.NoError(err) branch := plumbing.ReferenceName("refs/heads/branch") oldRef, err := server.Reference(branch) - c.Assert(err, IsNil) - c.Assert(oldRef, NotNil) + s.NoError(err) + s.NotNil(oldRef) err = remote.Push(&PushOptions{RefSpecs: []config.RefSpec{ "refs/heads/master:refs/heads/branch", }}) - c.Assert(err, ErrorMatches, "non-fast-forward update: refs/heads/branch") + s.ErrorContains(err, "non-fast-forward update: refs/heads/branch") newRef, err := server.Reference(branch) - c.Assert(err, IsNil) - c.Assert(newRef, DeepEquals, oldRef) + s.NoError(err) + s.Equal(oldRef, newRef) } -func (s *RemoteSuite) TestPushForce(c *C) { +func (s *RemoteSuite) TestPushForce() { f := fixtures.Basic().One() sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) @@ -880,20 +879,20 @@ func (s *RemoteSuite) TestPushForce(c *C) { }) oldRef, err := dstSto.Reference(plumbing.ReferenceName("refs/heads/branch")) - c.Assert(err, IsNil) - c.Assert(oldRef, NotNil) + s.NoError(err) + s.NotNil(oldRef) err = r.Push(&PushOptions{RefSpecs: []config.RefSpec{ config.RefSpec("+refs/heads/master:refs/heads/branch"), }}) - c.Assert(err, IsNil) + s.NoError(err) newRef, err := dstSto.Reference(plumbing.ReferenceName("refs/heads/branch")) - c.Assert(err, IsNil) - c.Assert(newRef, Not(DeepEquals), oldRef) + s.NoError(err) + s.NotEqual(oldRef, newRef) } -func (s *RemoteSuite) TestPushForceWithOption(c *C) { +func (s *RemoteSuite) TestPushForceWithOption() { f := fixtures.Basic().One() sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) @@ -907,21 +906,21 @@ func (s *RemoteSuite) TestPushForceWithOption(c *C) { }) oldRef, err := dstSto.Reference(plumbing.ReferenceName("refs/heads/branch")) - c.Assert(err, IsNil) - c.Assert(oldRef, NotNil) + s.NoError(err) + s.NotNil(oldRef) err = r.Push(&PushOptions{ RefSpecs: []config.RefSpec{"refs/heads/master:refs/heads/branch"}, Force: true, }) - c.Assert(err, IsNil) + s.NoError(err) newRef, err := dstSto.Reference(plumbing.ReferenceName("refs/heads/branch")) - c.Assert(err, IsNil) - c.Assert(newRef, Not(DeepEquals), oldRef) + s.NoError(err) + s.NotEqual(oldRef, newRef) } -func (s *RemoteSuite) TestPushForceWithLease_success(c *C) { +func (s *RemoteSuite) TestPushForceWithLease_success() { testCases := []struct { desc string forceWithLease ForceWithLease @@ -946,7 +945,7 @@ func (s *RemoteSuite) TestPushForceWithLease_success(c *C) { } for _, tc := range testCases { - c.Log("Executing test cases:", tc.desc) + s.T().Log("Executing test cases:", tc.desc) f := fixtures.Basic().One() sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) @@ -956,11 +955,11 @@ func (s *RemoteSuite) TestPushForceWithLease_success(c *C) { newCommit := plumbing.NewHashReference( "refs/heads/branch", plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"), ) - c.Assert(sto.SetReference(newCommit), IsNil) + s.Nil(sto.SetReference(newCommit)) ref, err := sto.Reference("refs/heads/branch") - c.Assert(err, IsNil) - c.Log(ref.String()) + s.NoError(err) + s.T().Log(ref.String()) url := dstFs.Root() r := NewRemote(sto, &config.RemoteConfig{ @@ -969,21 +968,21 @@ func (s *RemoteSuite) TestPushForceWithLease_success(c *C) { }) oldRef, err := dstSto.Reference("refs/heads/branch") - c.Assert(err, IsNil) - c.Assert(oldRef, NotNil) + s.NoError(err) + s.NotNil(oldRef) - c.Assert(r.Push(&PushOptions{ + s.NoError(r.Push(&PushOptions{ RefSpecs: []config.RefSpec{"refs/heads/branch:refs/heads/branch"}, ForceWithLease: &ForceWithLease{}, - }), IsNil) + })) newRef, err := dstSto.Reference("refs/heads/branch") - c.Assert(err, IsNil) - c.Assert(newRef, DeepEquals, newCommit) + s.NoError(err) + s.Equal(newCommit, newRef) } } -func (s *RemoteSuite) TestPushForceWithLease_failure(c *C) { +func (s *RemoteSuite) TestPushForceWithLease_failure() { testCases := []struct { desc string forceWithLease ForceWithLease @@ -1008,23 +1007,23 @@ func (s *RemoteSuite) TestPushForceWithLease_failure(c *C) { } for _, tc := range testCases { - c.Log("Executing test cases:", tc.desc) + s.T().Log("Executing test cases:", tc.desc) f := fixtures.Basic().One() sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) - c.Assert(sto.SetReference( + s.NoError(sto.SetReference( plumbing.NewHashReference( "refs/heads/branch", plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"), ), - ), IsNil) + )) dstFs := f.DotGit() dstSto := filesystem.NewStorage(dstFs, cache.NewObjectLRUDefault()) - c.Assert(dstSto.SetReference( + s.NoError(dstSto.SetReference( plumbing.NewHashReference( "refs/heads/branch", plumbing.NewHash("ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc"), ), - ), IsNil) + )) url := dstFs.Root() r := NewRemote(sto, &config.RemoteConfig{ @@ -1033,52 +1032,52 @@ func (s *RemoteSuite) TestPushForceWithLease_failure(c *C) { }) oldRef, err := dstSto.Reference("refs/heads/branch") - c.Assert(err, IsNil) - c.Assert(oldRef, NotNil) + s.NoError(err) + s.NotNil(oldRef) err = r.Push(&PushOptions{ RefSpecs: []config.RefSpec{"refs/heads/branch:refs/heads/branch"}, ForceWithLease: &ForceWithLease{}, }) - c.Assert(err, DeepEquals, errors.New("non-fast-forward update: refs/heads/branch")) + s.ErrorContains(err, "non-fast-forward update: refs/heads/branch") newRef, err := dstSto.Reference("refs/heads/branch") - c.Assert(err, IsNil) - c.Assert(newRef, Not(DeepEquals), plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9")) + s.NoError(err) + s.NotEqual(plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"), newRef) } } -func (s *RemoteSuite) TestPushPrune(c *C) { +func (s *RemoteSuite) TestPushPrune() { fs := fixtures.Basic().One().DotGit() - url, clean := s.TemporalDir() - defer clean() + url, err := os.MkdirTemp("", "") + s.NoError(err) server, err := PlainClone(url, true, &CloneOptions{ URL: fs.Root(), }) - c.Assert(err, IsNil) + s.NoError(err) - dir, clean := s.TemporalDir() - defer clean() + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainClone(dir, true, &CloneOptions{ URL: url, }) - c.Assert(err, IsNil) + s.NoError(err) tag, err := r.Reference(plumbing.ReferenceName("refs/tags/v1.0.0"), true) - c.Assert(err, IsNil) + s.NoError(err) err = r.DeleteTag("v1.0.0") - c.Assert(err, IsNil) + s.NoError(err) remote, err := r.Remote(DefaultRemoteName) - c.Assert(err, IsNil) + s.NoError(err) ref, err := r.Reference(plumbing.ReferenceName("refs/heads/master"), true) - c.Assert(err, IsNil) + s.NoError(err) err = remote.Push(&PushOptions{ RefSpecs: []config.RefSpec{ @@ -1086,9 +1085,9 @@ func (s *RemoteSuite) TestPushPrune(c *C) { }, Prune: true, }) - c.Assert(err, Equals, NoErrAlreadyUpToDate) + s.ErrorIs(err, NoErrAlreadyUpToDate) - AssertReferences(c, server, map[string]string{ + AssertReferences(s.T(), server, map[string]string{ "refs/tags/v1.0.0": tag.Hash().String(), }) @@ -1098,134 +1097,134 @@ func (s *RemoteSuite) TestPushPrune(c *C) { }, Prune: true, }) - c.Assert(err, IsNil) + s.NoError(err) - AssertReferences(c, server, map[string]string{ + AssertReferences(s.T(), server, map[string]string{ "refs/remotes/origin/master": ref.Hash().String(), }) - AssertReferences(c, server, map[string]string{ + AssertReferences(s.T(), server, map[string]string{ "refs/remotes/origin/master": ref.Hash().String(), }) _, err = server.Reference(plumbing.ReferenceName("refs/tags/v1.0.0"), true) - c.Assert(err, Equals, plumbing.ErrReferenceNotFound) + s.ErrorIs(err, plumbing.ErrReferenceNotFound) } -func (s *RemoteSuite) TestPushNewReference(c *C) { +func (s *RemoteSuite) TestPushNewReference() { fs := fixtures.Basic().One().DotGit() - url, clean := s.TemporalDir() - defer clean() + url, err := os.MkdirTemp("", "") + s.NoError(err) server, err := PlainClone(url, true, &CloneOptions{ URL: fs.Root(), }) - c.Assert(err, IsNil) + s.NoError(err) - dir, clean := s.TemporalDir() - defer clean() + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainClone(dir, true, &CloneOptions{ URL: url, }) - c.Assert(err, IsNil) + s.NoError(err) remote, err := r.Remote(DefaultRemoteName) - c.Assert(err, IsNil) + s.NoError(err) ref, err := r.Reference(plumbing.ReferenceName("refs/heads/master"), true) - c.Assert(err, IsNil) + s.NoError(err) err = remote.Push(&PushOptions{RefSpecs: []config.RefSpec{ "refs/heads/master:refs/heads/branch2", }}) - c.Assert(err, IsNil) + s.NoError(err) - AssertReferences(c, server, map[string]string{ + AssertReferences(s.T(), server, map[string]string{ "refs/heads/branch2": ref.Hash().String(), }) - AssertReferences(c, r, map[string]string{ + AssertReferences(s.T(), r, map[string]string{ "refs/remotes/origin/branch2": ref.Hash().String(), }) } -func (s *RemoteSuite) TestPushNewReferenceAndDeleteInBatch(c *C) { +func (s *RemoteSuite) TestPushNewReferenceAndDeleteInBatch() { fs := fixtures.Basic().One().DotGit() - url, clean := s.TemporalDir() - defer clean() + url, err := os.MkdirTemp("", "") + s.NoError(err) server, err := PlainClone(url, true, &CloneOptions{ URL: fs.Root(), }) - c.Assert(err, IsNil) + s.NoError(err) - dir, clean := s.TemporalDir() - defer clean() + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainClone(dir, true, &CloneOptions{ URL: url, }) - c.Assert(err, IsNil) + s.NoError(err) remote, err := r.Remote(DefaultRemoteName) - c.Assert(err, IsNil) + s.NoError(err) ref, err := r.Reference(plumbing.ReferenceName("refs/heads/master"), true) - c.Assert(err, IsNil) + s.NoError(err) err = remote.Push(&PushOptions{RefSpecs: []config.RefSpec{ "refs/heads/master:refs/heads/branch2", ":refs/heads/branch", }}) - c.Assert(err, IsNil) + s.NoError(err) - AssertReferences(c, server, map[string]string{ + AssertReferences(s.T(), server, map[string]string{ "refs/heads/branch2": ref.Hash().String(), }) - AssertReferences(c, r, map[string]string{ + AssertReferences(s.T(), r, map[string]string{ "refs/remotes/origin/branch2": ref.Hash().String(), }) _, err = server.Storer.Reference(plumbing.ReferenceName("refs/heads/branch")) - c.Assert(err, Equals, plumbing.ErrReferenceNotFound) + s.ErrorIs(err, plumbing.ErrReferenceNotFound) } -func (s *RemoteSuite) TestPushInvalidEndpoint(c *C) { +func (s *RemoteSuite) TestPushInvalidEndpoint() { r := NewRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"http://\\"}}) err := r.Push(&PushOptions{RemoteName: "foo"}) - c.Assert(err, ErrorMatches, ".*invalid character.*") + s.ErrorContains(err, "invalid character") } -func (s *RemoteSuite) TestPushNonExistentEndpoint(c *C) { +func (s *RemoteSuite) TestPushNonExistentEndpoint() { r := NewRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"ssh://non-existent/foo.git"}}) err := r.Push(&PushOptions{}) - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *RemoteSuite) TestPushOverriddenEndpoint(c *C) { +func (s *RemoteSuite) TestPushOverriddenEndpoint() { r := NewRemote(nil, &config.RemoteConfig{Name: "origin", URLs: []string{"http://perfectly-valid-url.example.com"}}) err := r.Push(&PushOptions{RemoteURL: "http://\\"}) - c.Assert(err, ErrorMatches, ".*invalid character.*") + s.ErrorContains(err, "invalid character") } -func (s *RemoteSuite) TestPushInvalidSchemaEndpoint(c *C) { +func (s *RemoteSuite) TestPushInvalidSchemaEndpoint() { r := NewRemote(nil, &config.RemoteConfig{Name: "origin", URLs: []string{"qux://foo"}}) err := r.Push(&PushOptions{}) - c.Assert(err, ErrorMatches, ".*unsupported scheme.*") + s.ErrorContains(err, "unsupported scheme") } -func (s *RemoteSuite) TestPushInvalidFetchOptions(c *C) { +func (s *RemoteSuite) TestPushInvalidFetchOptions() { r := NewRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"qux://foo"}}) invalid := config.RefSpec("^*$ñ") err := r.Push(&PushOptions{RefSpecs: []config.RefSpec{invalid}}) - c.Assert(err, Equals, config.ErrRefSpecMalformedSeparator) + s.ErrorIs(err, config.ErrRefSpecMalformedSeparator) } -func (s *RemoteSuite) TestPushInvalidRefSpec(c *C) { +func (s *RemoteSuite) TestPushInvalidRefSpec() { r := NewRemote(nil, &config.RemoteConfig{ Name: DefaultRemoteName, URLs: []string{"some-url"}, @@ -1235,10 +1234,10 @@ func (s *RemoteSuite) TestPushInvalidRefSpec(c *C) { err := r.Push(&PushOptions{ RefSpecs: []config.RefSpec{rs}, }) - c.Assert(err, Equals, config.ErrRefSpecMalformedSeparator) + s.ErrorIs(err, config.ErrRefSpecMalformedSeparator) } -func (s *RemoteSuite) TestPushWrongRemoteName(c *C) { +func (s *RemoteSuite) TestPushWrongRemoteName() { r := NewRemote(nil, &config.RemoteConfig{ Name: DefaultRemoteName, URLs: []string{"some-url"}, @@ -1247,14 +1246,14 @@ func (s *RemoteSuite) TestPushWrongRemoteName(c *C) { err := r.Push(&PushOptions{ RemoteName: "other-remote", }) - c.Assert(err, ErrorMatches, ".*remote names don't match.*") + s.ErrorContains(err, "remote names don't match") } -func (s *RemoteSuite) TestGetHaves(c *C) { +func (s *RemoteSuite) TestGetHaves() { f := fixtures.Basic().One() sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) - var localRefs = []*plumbing.Reference{ + localRefs := []*plumbing.Reference{ // Exists plumbing.NewReferenceFromStrings( "foo", @@ -1273,11 +1272,11 @@ func (s *RemoteSuite) TestGetHaves(c *C) { } l, err := getHaves(localRefs, memory.NewStorage(), sto, 0) - c.Assert(err, IsNil) - c.Assert(l, HasLen, 2) + s.NoError(err) + s.Len(l, 2) } -func (s *RemoteSuite) TestList(c *C) { +func (s *RemoteSuite) TestList() { repo := fixtures.Basic().One() remote := NewRemote(memory.NewStorage(), &config.RemoteConfig{ Name: DefaultRemoteName, @@ -1285,7 +1284,7 @@ func (s *RemoteSuite) TestList(c *C) { }) refs, err := remote.List(&ListOptions{}) - c.Assert(err, IsNil) + s.NoError(err) expected := []*plumbing.Reference{ plumbing.NewSymbolicReference("HEAD", "refs/heads/master"), @@ -1295,20 +1294,20 @@ func (s *RemoteSuite) TestList(c *C) { plumbing.NewReferenceFromStrings("refs/pull/2/head", "9632f02833b2f9613afb5e75682132b0b22e4a31"), plumbing.NewReferenceFromStrings("refs/pull/2/merge", "c37f58a130ca555e42ff96a071cb9ccb3f437504"), } - c.Assert(len(refs), Equals, len(expected)) + s.Len(expected, len(refs)) for _, e := range expected { found := false for _, r := range refs { if r.Name() == e.Name() { found = true - c.Assert(r, DeepEquals, e) + s.Equal(e, r) } } - c.Assert(found, Equals, true) + s.True(found) } } -func (s *RemoteSuite) TestListPeeling(c *C) { +func (s *RemoteSuite) TestListPeeling() { remote := NewRemote(memory.NewStorage(), &config.RemoteConfig{ Name: DefaultRemoteName, URLs: []string{"https://github.com/git-fixtures/tags.git"}, @@ -1326,8 +1325,8 @@ func (s *RemoteSuite) TestListPeeling(c *C) { refs, err := remote.List(&ListOptions{ PeelingOption: tc.peelingOption, }) - c.Assert(err, IsNil) - c.Assert(len(refs) > 0, Equals, true) + s.NoError(err) + s.True(len(refs) > 0) foundPeeled, foundNonPeeled := false, false for _, ref := range refs { @@ -1338,12 +1337,12 @@ func (s *RemoteSuite) TestListPeeling(c *C) { } } - c.Assert(foundPeeled, Equals, tc.expectPeeled) - c.Assert(foundNonPeeled, Equals, tc.expectNonPeeled) + s.Equal(tc.expectPeeled, foundPeeled) + s.Equal(tc.expectNonPeeled, foundNonPeeled) } } -func (s *RemoteSuite) TestListTimeout(c *C) { +func (s *RemoteSuite) TestListTimeout() { remote := NewRemote(memory.NewStorage(), &config.RemoteConfig{ Name: DefaultRemoteName, URLs: []string{"https://deelay.me/60000/https://httpstat.us/503"}, @@ -1351,10 +1350,10 @@ func (s *RemoteSuite) TestListTimeout(c *C) { _, err := remote.List(&ListOptions{}) - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *RemoteSuite) TestUpdateShallows(c *C) { +func (s *RemoteSuite) TestUpdateShallows() { hashes := []plumbing.Hash{ plumbing.NewHash("0000000000000000000000000000000000000001"), plumbing.NewHash("0000000000000000000000000000000000000002"), @@ -1385,8 +1384,8 @@ func (s *RemoteSuite) TestUpdateShallows(c *C) { }) shallows, err := remote.s.Shallow() - c.Assert(err, IsNil) - c.Assert(len(shallows), Equals, 0) + s.NoError(err) + s.Len(shallows, 0) resp := new(packp.UploadPackResponse) o := &FetchOptions{ @@ -1396,21 +1395,21 @@ func (s *RemoteSuite) TestUpdateShallows(c *C) { for _, t := range tests { resp.Shallows = t.hashes err = remote.updateShallow(o, resp) - c.Assert(err, IsNil) + s.NoError(err) shallow, err := remote.s.Shallow() - c.Assert(err, IsNil) - c.Assert(len(shallow), Equals, len(t.result)) - c.Assert(shallow, DeepEquals, t.result) + s.NoError(err) + s.Len(t.result, len(shallow)) + s.Equal(t.result, shallow) } } -func (s *RemoteSuite) TestUseRefDeltas(c *C) { - url, clean := s.TemporalDir() - defer clean() +func (s *RemoteSuite) TestUseRefDeltas() { + url, err := os.MkdirTemp("", "") + s.NoError(err) - _, err := PlainInit(url, true) - c.Assert(err, IsNil) + _, err = PlainInit(url, true) + s.NoError(err) fs := fixtures.ByURL("https://github.com/git-fixtures/tags.git").One().DotGit() sto := filesystem.NewStorage(fs, cache.NewObjectLRUDefault()) @@ -1423,13 +1422,13 @@ func (s *RemoteSuite) TestUseRefDeltas(c *C) { ar := packp.NewAdvRefs() ar.Capabilities.Add(capability.OFSDelta) - c.Assert(r.useRefDeltas(ar), Equals, false) + s.False(r.useRefDeltas(ar)) ar.Capabilities.Delete(capability.OFSDelta) - c.Assert(r.useRefDeltas(ar), Equals, true) + s.True(r.useRefDeltas(ar)) } -func (s *RemoteSuite) TestPushRequireRemoteRefs(c *C) { +func (s *RemoteSuite) TestPushRequireRemoteRefs() { f := fixtures.Basic().One() sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) @@ -1443,187 +1442,189 @@ func (s *RemoteSuite) TestPushRequireRemoteRefs(c *C) { }) oldRef, err := dstSto.Reference(plumbing.ReferenceName("refs/heads/branch")) - c.Assert(err, IsNil) - c.Assert(oldRef, NotNil) + s.NoError(err) + s.NotNil(oldRef) otherRef, err := dstSto.Reference(plumbing.ReferenceName("refs/heads/master")) - c.Assert(err, IsNil) - c.Assert(otherRef, NotNil) + s.NoError(err) + s.NotNil(otherRef) err = r.Push(&PushOptions{ RefSpecs: []config.RefSpec{"refs/heads/master:refs/heads/branch"}, RequireRemoteRefs: []config.RefSpec{config.RefSpec(otherRef.Hash().String() + ":refs/heads/branch")}, }) - c.Assert(err, ErrorMatches, "remote ref refs/heads/branch required to be .* but is .*") + s.ErrorContains(err, "remote ref refs/heads/branch required to be 6ecf0ef2c2dffb796033e5a02219af86ec6584e5 but is e8d3ffab552895c19b9fcf7aa264d277cde33881") newRef, err := dstSto.Reference(plumbing.ReferenceName("refs/heads/branch")) - c.Assert(err, IsNil) - c.Assert(newRef, DeepEquals, oldRef) + s.NoError(err) + s.Equal(oldRef, newRef) err = r.Push(&PushOptions{ RefSpecs: []config.RefSpec{"refs/heads/master:refs/heads/branch"}, RequireRemoteRefs: []config.RefSpec{config.RefSpec(oldRef.Hash().String() + ":refs/heads/branch")}, }) - c.Assert(err, ErrorMatches, "non-fast-forward update: .*") + s.ErrorContains(err, "non-fast-forward update: ") newRef, err = dstSto.Reference(plumbing.ReferenceName("refs/heads/branch")) - c.Assert(err, IsNil) - c.Assert(newRef, DeepEquals, oldRef) + s.NoError(err) + s.Equal(oldRef, newRef) err = r.Push(&PushOptions{ RefSpecs: []config.RefSpec{"refs/heads/master:refs/heads/branch"}, RequireRemoteRefs: []config.RefSpec{config.RefSpec(oldRef.Hash().String() + ":refs/heads/branch")}, Force: true, }) - c.Assert(err, IsNil) + s.NoError(err) newRef, err = dstSto.Reference(plumbing.ReferenceName("refs/heads/branch")) - c.Assert(err, IsNil) - c.Assert(newRef, Not(DeepEquals), oldRef) + s.NoError(err) + s.NotEqual(oldRef, newRef) } -func (s *RemoteSuite) TestFetchPrune(c *C) { +func (s *RemoteSuite) TestFetchPrune() { fs := fixtures.Basic().One().DotGit() - url, clean := s.TemporalDir() - defer clean() + url, err := os.MkdirTemp("", "") + s.NoError(err) - _, err := PlainClone(url, true, &CloneOptions{ + _, err = PlainClone(url, true, &CloneOptions{ URL: fs.Root(), }) - c.Assert(err, IsNil) + s.NoError(err) - dir, clean := s.TemporalDir() - defer clean() + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainClone(dir, true, &CloneOptions{ URL: url, }) - c.Assert(err, IsNil) + s.NoError(err) remote, err := r.Remote(DefaultRemoteName) - c.Assert(err, IsNil) + s.NoError(err) ref, err := r.Reference(plumbing.ReferenceName("refs/heads/master"), true) - c.Assert(err, IsNil) + s.NoError(err) err = remote.Push(&PushOptions{RefSpecs: []config.RefSpec{ "refs/heads/master:refs/heads/branch", }}) - c.Assert(err, IsNil) + s.NoError(err) - dirSave, clean := s.TemporalDir() - defer clean() + dirSave, err := os.MkdirTemp("", "") + s.NoError(err) rSave, err := PlainClone(dirSave, true, &CloneOptions{ URL: url, }) - c.Assert(err, IsNil) + s.NoError(err) - AssertReferences(c, rSave, map[string]string{ + AssertReferences(s.T(), rSave, map[string]string{ "refs/remotes/origin/branch": ref.Hash().String(), }) err = remote.Push(&PushOptions{RefSpecs: []config.RefSpec{ ":refs/heads/branch", }}) - c.Assert(err, IsNil) + s.NoError(err) - AssertReferences(c, rSave, map[string]string{ + AssertReferences(s.T(), rSave, map[string]string{ "refs/remotes/origin/branch": ref.Hash().String(), }) err = rSave.Fetch(&FetchOptions{Prune: true}) - c.Assert(err, IsNil) + s.NoError(err) _, err = rSave.Reference("refs/remotes/origin/branch", true) - c.Assert(err, ErrorMatches, "reference not found") + s.ErrorContains(err, "reference not found") } -func (s *RemoteSuite) TestFetchPruneTags(c *C) { +func (s *RemoteSuite) TestFetchPruneTags() { fs := fixtures.Basic().One().DotGit() - url, clean := s.TemporalDir() - defer clean() + url, err := os.MkdirTemp("", "") + s.NoError(err) - _, err := PlainClone(url, true, &CloneOptions{ + _, err = PlainClone(url, true, &CloneOptions{ URL: fs.Root(), }) - c.Assert(err, IsNil) + s.NoError(err) - dir, clean := s.TemporalDir() - defer clean() + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainClone(dir, true, &CloneOptions{ URL: url, }) - c.Assert(err, IsNil) + s.NoError(err) remote, err := r.Remote(DefaultRemoteName) - c.Assert(err, IsNil) + s.NoError(err) ref, err := r.Reference(plumbing.ReferenceName("refs/heads/master"), true) - c.Assert(err, IsNil) + s.NoError(err) err = remote.Push(&PushOptions{RefSpecs: []config.RefSpec{ "refs/heads/master:refs/tags/v1", }}) - c.Assert(err, IsNil) + s.NoError(err) - dirSave, clean := s.TemporalDir() - defer clean() + dirSave, err := os.MkdirTemp("", "") + s.NoError(err) rSave, err := PlainClone(dirSave, true, &CloneOptions{ URL: url, }) - c.Assert(err, IsNil) + s.NoError(err) - AssertReferences(c, rSave, map[string]string{ + AssertReferences(s.T(), rSave, map[string]string{ "refs/tags/v1": ref.Hash().String(), }) err = remote.Push(&PushOptions{RefSpecs: []config.RefSpec{ ":refs/tags/v1", }}) - c.Assert(err, IsNil) + s.NoError(err) - AssertReferences(c, rSave, map[string]string{ + AssertReferences(s.T(), rSave, map[string]string{ "refs/tags/v1": ref.Hash().String(), }) err = rSave.Fetch(&FetchOptions{Prune: true, RefSpecs: []config.RefSpec{"refs/tags/*:refs/tags/*"}}) - c.Assert(err, IsNil) + s.NoError(err) _, err = rSave.Reference("refs/tags/v1", true) - c.Assert(err, ErrorMatches, "reference not found") + s.ErrorContains(err, "reference not found") } -func (s *RemoteSuite) TestCanPushShasToReference(c *C) { - d, err := os.MkdirTemp("", "TestCanPushShasToReference") - c.Assert(err, IsNil) +func (s *RemoteSuite) TestCanPushShasToReference() { + d, err := os.MkdirTemp("", "") + s.NoError(err) + + d, err = os.MkdirTemp(d, "TestCanPushShasToReference") + s.NoError(err) if err != nil { return } - defer os.RemoveAll(d) // remote currently forces a plain path for path based remotes inside the PushContext function. // This makes it impossible, in the current state to use memfs. // For the sake of readability, use the same osFS everywhere and use plain git repositories on temporary files remote, err := PlainInit(filepath.Join(d, "remote"), true) - c.Assert(err, IsNil) - c.Assert(remote, NotNil) + s.NoError(err) + s.NotNil(remote) repo, err := PlainInit(filepath.Join(d, "repo"), false) - c.Assert(err, IsNil) - c.Assert(repo, NotNil) + s.NoError(err) + s.NotNil(repo) - sha := CommitNewFile(c, repo, "README.md") + sha := CommitNewFile(s.T(), repo, "README.md") gitremote, err := repo.CreateRemote(&config.RemoteConfig{ Name: "local", URLs: []string{filepath.Join(d, "remote")}, }) - c.Assert(err, IsNil) + s.NoError(err) if err != nil { return } @@ -1635,53 +1636,53 @@ func (s *RemoteSuite) TestCanPushShasToReference(c *C) { config.RefSpec(sha.String() + ":refs/heads/branch"), }, }) - c.Assert(err, IsNil) + s.NoError(err) if err != nil { return } ref, err := remote.Reference(plumbing.ReferenceName("refs/heads/branch"), false) - c.Assert(err, IsNil) + s.NoError(err) if err != nil { return } - c.Assert(ref.Hash().String(), Equals, sha.String()) + s.Equal(sha.String(), ref.Hash().String()) } -func (s *RemoteSuite) TestFetchAfterShallowClone(c *C) { - tempDir, clean := s.TemporalDir() - defer clean() +func (s *RemoteSuite) TestFetchAfterShallowClone() { + tempDir, err := os.MkdirTemp("", "") + s.NoError(err) remoteUrl := filepath.Join(tempDir, "remote") repoDir := filepath.Join(tempDir, "repo") // Create a new repo and add more than 1 commit (so we can have a shallow commit) remote, err := PlainInit(remoteUrl, false) - c.Assert(err, IsNil) - c.Assert(remote, NotNil) + s.NoError(err) + s.NotNil(remote) - _ = CommitNewFile(c, remote, "File1") - _ = CommitNewFile(c, remote, "File2") + _ = CommitNewFile(s.T(), remote, "File1") + _ = CommitNewFile(s.T(), remote, "File2") // Clone the repo with a depth of 1 repo, err := PlainClone(repoDir, false, &CloneOptions{ URL: remoteUrl, Depth: 1, - Tags: NoTags, + Tags: plumbing.NoTags, SingleBranch: true, ReferenceName: "master", }) - c.Assert(err, IsNil) + s.NoError(err) // Add new commits to the origin (more than 1 so that our next test hits a missing commit) - _ = CommitNewFile(c, remote, "File3") - sha4 := CommitNewFile(c, remote, "File4") + _ = CommitNewFile(s.T(), remote, "File3") + sha4 := CommitNewFile(s.T(), remote, "File4") // Try fetch with depth of 1 again (note, we need to ensure no remote branch remains pointing at the old commit) r, err := repo.Remote(DefaultRemoteName) - c.Assert(err, IsNil) - s.testFetch(c, r, &FetchOptions{ + s.NoError(err) + s.testFetch(r, &FetchOptions{ Depth: 2, - Tags: NoTags, + Tags: plumbing.NoTags, RefSpecs: []config.RefSpec{ "+refs/heads/master:refs/heads/master", @@ -1694,14 +1695,14 @@ func (s *RemoteSuite) TestFetchAfterShallowClone(c *C) { }) // Add another commit to the origin - sha5 := CommitNewFile(c, remote, "File5") + sha5 := CommitNewFile(s.T(), remote, "File5") // Try fetch with depth of 2 this time (to reach a commit that we don't have locally) r, err = repo.Remote(DefaultRemoteName) - c.Assert(err, IsNil) - s.testFetch(c, r, &FetchOptions{ + s.NoError(err) + s.testFetch(r, &FetchOptions{ Depth: 1, - Tags: NoTags, + Tags: plumbing.NoTags, RefSpecs: []config.RefSpec{ "+refs/heads/master:refs/heads/master", diff --git a/repository.go b/repository.go index 6d7e196b3..648bae375 100644 --- a/repository.go +++ b/repository.go @@ -19,21 +19,22 @@ import ( "github.com/go-git/go-billy/v5" "github.com/go-git/go-billy/v5/osfs" "github.com/go-git/go-billy/v5/util" - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/internal/path_util" - "github.com/go-git/go-git/v5/internal/revision" - "github.com/go-git/go-git/v5/internal/url" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - formatcfg "github.com/go-git/go-git/v5/plumbing/format/config" - "github.com/go-git/go-git/v5/plumbing/format/packfile" - "github.com/go-git/go-git/v5/plumbing/hash" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage" - "github.com/go-git/go-git/v5/storage/filesystem" - "github.com/go-git/go-git/v5/storage/filesystem/dotgit" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/internal/path_util" + "github.com/jesseduffield/go-git/v5/internal/revision" + "github.com/jesseduffield/go-git/v5/internal/url" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + formatcfg "github.com/jesseduffield/go-git/v5/plumbing/format/config" + "github.com/jesseduffield/go-git/v5/plumbing/format/packfile" + "github.com/jesseduffield/go-git/v5/plumbing/hash" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/storage/filesystem/dotgit" + "github.com/jesseduffield/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/utils/trace" ) // GitDirName this is a special folder where all the git stuff is. @@ -231,6 +232,15 @@ func Clone(s storage.Storer, worktree billy.Filesystem, o *CloneOptions) (*Repos func CloneContext( ctx context.Context, s storage.Storer, worktree billy.Filesystem, o *CloneOptions, ) (*Repository, error) { + start := time.Now() + defer func() { + url := "" + if o != nil { + url = o.URL + } + trace.Performance.Printf("performance: %.9f s: git command: git clone %s", time.Since(start).Seconds(), url) + }() + r, err := Init(s, worktree) if err != nil { return nil, err @@ -256,9 +266,9 @@ func PlainInitWithOptions(path string, opts *PlainInitOptions) (*Repository, err var wt, dot billy.Filesystem if opts.Bare { - dot = osfs.New(path) + dot = osfs.New(path, osfs.WithBoundOS()) } else { - wt = osfs.New(path) + wt = osfs.New(path, osfs.WithBoundOS()) dot, _ = wt.Chroot(GitDirName) } @@ -344,7 +354,7 @@ func dotGitToOSFilesystems(path string, detect bool) (dot, wt billy.Filesystem, var fs billy.Filesystem var fi os.FileInfo for { - fs = osfs.New(path) + fs = osfs.New(path, osfs.WithBoundOS()) pathinfo, err := fs.Stat("/") if !os.IsNotExist(err) { @@ -352,7 +362,7 @@ func dotGitToOSFilesystems(path string, detect bool) (dot, wt billy.Filesystem, return nil, nil, err } if !pathinfo.IsDir() && detect { - fs = osfs.New(filepath.Dir(path)) + fs = osfs.New(filepath.Dir(path), osfs.WithBoundOS()) } } @@ -412,10 +422,10 @@ func dotGitFileToOSFilesystem(path string, fs billy.Filesystem) (bfs billy.Files gitdir := strings.Split(line[len(prefix):], "\n")[0] gitdir = strings.TrimSpace(gitdir) if filepath.IsAbs(gitdir) { - return osfs.New(gitdir), nil + return osfs.New(gitdir, osfs.WithBoundOS()), nil } - return osfs.New(fs.Join(path, gitdir)), nil + return osfs.New(fs.Join(path, gitdir), osfs.WithBoundOS()), nil } func dotGitCommonDirectory(fs billy.Filesystem) (commonDir billy.Filesystem, err error) { @@ -434,9 +444,9 @@ func dotGitCommonDirectory(fs billy.Filesystem) (commonDir billy.Filesystem, err if len(b) > 0 { path := strings.TrimSpace(string(b)) if filepath.IsAbs(path) { - commonDir = osfs.New(path) + commonDir = osfs.New(path, osfs.WithBoundOS()) } else { - commonDir = osfs.New(filepath.Join(fs.Root(), path)) + commonDir = osfs.New(filepath.Join(fs.Root(), path), osfs.WithBoundOS()) } if _, err := commonDir.Stat(""); err != nil { if os.IsNotExist(err) { @@ -470,6 +480,15 @@ func PlainClone(path string, isBare bool, o *CloneOptions) (*Repository, error) // TODO(mcuadros): move isBare to CloneOptions in v5 // TODO(smola): refuse upfront to clone on a non-empty directory in v5, see #1027 func PlainCloneContext(ctx context.Context, path string, isBare bool, o *CloneOptions) (*Repository, error) { + start := time.Now() + defer func() { + url := "" + if o != nil { + url = o.URL + } + trace.Performance.Printf("performance: %.9f s: git command: git clone %s", time.Since(start).Seconds(), url) + }() + cleanup, cleanupParent, err := checkIfCleanupIsNeeded(path) if err != nil { return nil, err @@ -932,6 +951,7 @@ func (r *Repository) clone(ctx context.Context, o *CloneOptions) error { InsecureSkipTLS: o.InsecureSkipTLS, CABundle: o.CABundle, ProxyOptions: o.ProxyOptions, + Filter: o.Filter, }, o.ReferenceName) if err != nil { return err @@ -956,7 +976,7 @@ func (r *Repository) clone(ctx context.Context, o *CloneOptions) error { } if o.RecurseSubmodules != NoRecurseSubmodules { - if err := w.updateSubmodules(&SubmoduleUpdateOptions{ + if err := w.updateSubmodules(ctx, &SubmoduleUpdateOptions{ RecurseSubmodules: o.RecurseSubmodules, Depth: func() int { if o.ShallowSubmodules { @@ -1264,8 +1284,8 @@ func (r *Repository) Log(o *LogOptions) (object.CommitIter, error) { it = r.logWithPathFilter(o.PathFilter, it, o.All) } - if o.Since != nil || o.Until != nil { - limitOptions := object.LogLimitOptions{Since: o.Since, Until: o.Until} + if o.Since != nil || o.Until != nil || !o.To.IsZero() { + limitOptions := object.LogLimitOptions{Since: o.Since, Until: o.Until, TailHash: o.To} it = r.logWithLimit(it, limitOptions) } diff --git a/repository_test.go b/repository_test.go index 0b77c5afb..fa3515fa2 100644 --- a/repository_test.go +++ b/repository_test.go @@ -17,84 +17,89 @@ import ( "time" fixtures "github.com/go-git/go-git-fixtures/v4" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" "github.com/ProtonMail/go-crypto/openpgp" "github.com/ProtonMail/go-crypto/openpgp/armor" openpgperr "github.com/ProtonMail/go-crypto/openpgp/errors" - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/storage" - "github.com/go-git/go-git/v5/storage/filesystem" - "github.com/go-git/go-git/v5/storage/memory" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/plumbing/protocol/packp" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/storage" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/storage/memory" "github.com/go-git/go-billy/v5" "github.com/go-git/go-billy/v5/memfs" "github.com/go-git/go-billy/v5/osfs" "github.com/go-git/go-billy/v5/util" - . "gopkg.in/check.v1" ) type RepositorySuite struct { + suite.Suite BaseSuite } -var _ = Suite(&RepositorySuite{}) +func TestRepositorySuite(t *testing.T) { + suite.Run(t, new(RepositorySuite)) +} -func (s *RepositorySuite) TestInit(c *C) { +func (s *RepositorySuite) TestInit() { r, err := Init(memory.NewStorage(), memfs.New()) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) cfg, err := r.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Core.IsBare, Equals, false) + s.NoError(err) + s.False(cfg.Core.IsBare) // check the HEAD to see what the default branch is - createCommit(c, r) + createCommit(s, r) ref, err := r.Head() - c.Assert(err, IsNil) - c.Assert(ref.Name().String(), Equals, plumbing.Master.String()) + s.NoError(err) + s.Equal(plumbing.Master.String(), ref.Name().String()) } -func (s *RepositorySuite) TestInitWithOptions(c *C) { +func (s *RepositorySuite) TestInitWithOptions() { r, err := InitWithOptions(memory.NewStorage(), memfs.New(), InitOptions{ DefaultBranch: "refs/heads/foo", }) - c.Assert(err, IsNil) - c.Assert(r, NotNil) - createCommit(c, r) + s.NoError(err) + s.NotNil(r) + createCommit(s, r) ref, err := r.Head() - c.Assert(err, IsNil) - c.Assert(ref.Name().String(), Equals, "refs/heads/foo") + s.NoError(err) + s.Equal("refs/heads/foo", ref.Name().String()) } -func (s *RepositorySuite) TestInitWithInvalidDefaultBranch(c *C) { +func (s *RepositorySuite) TestInitWithInvalidDefaultBranch() { _, err := InitWithOptions(memory.NewStorage(), memfs.New(), InitOptions{ DefaultBranch: "foo", }) - c.Assert(err, NotNil) + s.NotNil(err) } -func createCommit(c *C, r *Repository) plumbing.Hash { +func createCommit(s *RepositorySuite, r *Repository) plumbing.Hash { // Create a commit so there is a HEAD to check wt, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) rm, err := wt.Filesystem.Create("foo.txt") - c.Assert(err, IsNil) + s.NoError(err) _, err = rm.Write([]byte("foo text")) - c.Assert(err, IsNil) + s.NoError(err) _, err = wt.Add("foo.txt") - c.Assert(err, IsNil) + s.NoError(err) author := object.Signature{ Name: "go-git", @@ -108,13 +113,13 @@ func createCommit(c *C, r *Repository) plumbing.Hash { Committer: &author, AllowEmptyCommits: true, }) - c.Assert(err, IsNil) + s.NoError(err) return h } -func (s *RepositorySuite) TestInitNonStandardDotGit(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestInitNonStandardDotGit() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) fs := osfs.New(dir) dot, _ := fs.Chroot("storage") @@ -122,121 +127,120 @@ func (s *RepositorySuite) TestInitNonStandardDotGit(c *C) { wt, _ := fs.Chroot("worktree") r, err := Init(st, wt) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) f, err := fs.Open(fs.Join("worktree", ".git")) - c.Assert(err, IsNil) + s.NoError(err) defer func() { _ = f.Close() }() all, err := io.ReadAll(f) - c.Assert(err, IsNil) - c.Assert(string(all), Equals, fmt.Sprintf("gitdir: %s\n", filepath.Join("..", "storage"))) + s.NoError(err) + s.Equal(string(all), fmt.Sprintf("gitdir: %s\n", filepath.Join("..", "storage"))) cfg, err := r.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Core.Worktree, Equals, filepath.Join("..", "worktree")) + s.NoError(err) + s.Equal(cfg.Core.Worktree, filepath.Join("..", "worktree")) } -func (s *RepositorySuite) TestInitStandardDotGit(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestInitStandardDotGit() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) fs := osfs.New(dir) dot, _ := fs.Chroot(".git") st := filesystem.NewStorage(dot, cache.NewObjectLRUDefault()) r, err := Init(st, fs) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) l, err := fs.ReadDir(".git") - c.Assert(err, IsNil) - c.Assert(len(l) > 0, Equals, true) + s.NoError(err) + s.True(len(l) > 0) cfg, err := r.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Core.Worktree, Equals, "") + s.NoError(err) + s.Equal("", cfg.Core.Worktree) } -func (s *RepositorySuite) TestInitBare(c *C) { +func (s *RepositorySuite) TestInitBare() { r, err := Init(memory.NewStorage(), nil) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) cfg, err := r.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Core.IsBare, Equals, true) - + s.NoError(err) + s.True(cfg.Core.IsBare) } -func (s *RepositorySuite) TestInitAlreadyExists(c *C) { +func (s *RepositorySuite) TestInitAlreadyExists() { st := memory.NewStorage() r, err := Init(st, nil) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) r, err = Init(st, nil) - c.Assert(err, Equals, ErrRepositoryAlreadyExists) - c.Assert(r, IsNil) + s.ErrorIs(err, ErrRepositoryAlreadyExists) + s.Nil(r) } -func (s *RepositorySuite) TestOpen(c *C) { +func (s *RepositorySuite) TestOpen() { st := memory.NewStorage() r, err := Init(st, memfs.New()) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) r, err = Open(st, memfs.New()) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) } -func (s *RepositorySuite) TestOpenBare(c *C) { +func (s *RepositorySuite) TestOpenBare() { st := memory.NewStorage() r, err := Init(st, nil) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) r, err = Open(st, nil) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) } -func (s *RepositorySuite) TestOpenBareMissingWorktree(c *C) { +func (s *RepositorySuite) TestOpenBareMissingWorktree() { st := memory.NewStorage() r, err := Init(st, memfs.New()) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) r, err = Open(st, nil) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) } -func (s *RepositorySuite) TestOpenNotExists(c *C) { +func (s *RepositorySuite) TestOpenNotExists() { r, err := Open(memory.NewStorage(), nil) - c.Assert(err, Equals, ErrRepositoryNotExists) - c.Assert(r, IsNil) + s.ErrorIs(err, ErrRepositoryNotExists) + s.Nil(r) } -func (s *RepositorySuite) TestClone(c *C) { +func (s *RepositorySuite) TestClone() { r, err := Clone(memory.NewStorage(), nil, &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) remotes, err := r.Remotes() - c.Assert(err, IsNil) - c.Assert(remotes, HasLen, 1) + s.NoError(err) + s.Len(remotes, 1) } -func (s *RepositorySuite) TestCloneContext(c *C) { +func (s *RepositorySuite) TestCloneContext() { ctx, cancel := context.WithCancel(context.Background()) cancel() @@ -244,22 +248,22 @@ func (s *RepositorySuite) TestCloneContext(c *C) { URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(r, NotNil) - c.Assert(err, Equals, context.Canceled) + s.NotNil(r) + s.ErrorIs(err, context.Canceled) } -func (s *RepositorySuite) TestCloneMirror(c *C) { +func (s *RepositorySuite) TestCloneMirror() { r, err := Clone(memory.NewStorage(), nil, &CloneOptions{ URL: fixtures.Basic().One().URL, Mirror: true, }) - c.Assert(err, IsNil) + s.NoError(err) refs, err := r.References() var count int - refs.ForEach(func(r *plumbing.Reference) error { c.Log(r); count++; return nil }) - c.Assert(err, IsNil) + refs.ForEach(func(r *plumbing.Reference) error { s.T().Log(r); count++; return nil }) + s.NoError(err) // 6 refs total from github.com/git-fixtures/basic.git: // - HEAD // - refs/heads/master @@ -267,57 +271,58 @@ func (s *RepositorySuite) TestCloneMirror(c *C) { // - refs/pull/1/head // - refs/pull/2/head // - refs/pull/2/merge - c.Assert(count, Equals, 6) + s.Equal(6, count) cfg, err := r.Config() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(cfg.Core.IsBare, Equals, true) - c.Assert(cfg.Remotes[DefaultRemoteName].Validate(), IsNil) - c.Assert(cfg.Remotes[DefaultRemoteName].Mirror, Equals, true) + s.True(cfg.Core.IsBare) + s.Nil(cfg.Remotes[DefaultRemoteName].Validate()) + s.True(cfg.Remotes[DefaultRemoteName].Mirror) } -func (s *RepositorySuite) TestCloneWithTags(c *C) { +func (s *RepositorySuite) TestCloneWithTags() { url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(), ) r, err := Clone(memory.NewStorage(), nil, &CloneOptions{URL: url, Tags: NoTags}) - c.Assert(err, IsNil) + s.NoError(err) remotes, err := r.Remotes() - c.Assert(err, IsNil) - c.Assert(remotes, HasLen, 1) + s.NoError(err) + s.Len(remotes, 1) i, err := r.References() - c.Assert(err, IsNil) + s.NoError(err) var count int i.ForEach(func(r *plumbing.Reference) error { count++; return nil }) - c.Assert(count, Equals, 3) + s.Equal(3, count) } -func (s *RepositorySuite) TestCloneSparse(c *C) { +func (s *RepositorySuite) TestCloneSparse() { fs := memfs.New() r, err := Clone(memory.NewStorage(), fs, &CloneOptions{ - URL: s.GetBasicLocalRepositoryURL(), + URL: s.GetBasicLocalRepositoryURL(), + NoCheckout: true, }) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) sparseCheckoutDirectories := []string{"go", "json", "php"} - c.Assert(w.Checkout(&CheckoutOptions{ + s.NoError(w.Checkout(&CheckoutOptions{ Branch: "refs/heads/master", SparseCheckoutDirectories: sparseCheckoutDirectories, - }), IsNil) + })) fis, err := fs.ReadDir(".") - c.Assert(err, IsNil) + s.NoError(err) for _, fi := range fis { - c.Assert(fi.IsDir(), Equals, true) + s.True(fi.IsDir()) var oneOfSparseCheckoutDirs bool for _, sparseCheckoutDirectory := range sparseCheckoutDirectories { @@ -325,98 +330,98 @@ func (s *RepositorySuite) TestCloneSparse(c *C) { oneOfSparseCheckoutDirs = true } } - c.Assert(oneOfSparseCheckoutDirs, Equals, true) + s.True(oneOfSparseCheckoutDirs) } } -func (s *RepositorySuite) TestCreateRemoteAndRemote(c *C) { +func (s *RepositorySuite) TestCreateRemoteAndRemote() { r, _ := Init(memory.NewStorage(), nil) remote, err := r.CreateRemote(&config.RemoteConfig{ Name: "foo", URLs: []string{"http://foo/foo.git"}, }) - c.Assert(err, IsNil) - c.Assert(remote.Config().Name, Equals, "foo") + s.NoError(err) + s.Equal("foo", remote.Config().Name) alt, err := r.Remote("foo") - c.Assert(err, IsNil) - c.Assert(alt, Not(Equals), remote) - c.Assert(alt.Config().Name, Equals, "foo") + s.NoError(err) + s.NotSame(remote, alt) + s.Equal("foo", alt.Config().Name) } -func (s *RepositorySuite) TestCreateRemoteInvalid(c *C) { +func (s *RepositorySuite) TestCreateRemoteInvalid() { r, _ := Init(memory.NewStorage(), nil) remote, err := r.CreateRemote(&config.RemoteConfig{}) - c.Assert(err, Equals, config.ErrRemoteConfigEmptyName) - c.Assert(remote, IsNil) + s.ErrorIs(err, config.ErrRemoteConfigEmptyName) + s.Nil(remote) } -func (s *RepositorySuite) TestCreateRemoteAnonymous(c *C) { +func (s *RepositorySuite) TestCreateRemoteAnonymous() { r, _ := Init(memory.NewStorage(), nil) remote, err := r.CreateRemoteAnonymous(&config.RemoteConfig{ Name: "anonymous", URLs: []string{"http://foo/foo.git"}, }) - c.Assert(err, IsNil) - c.Assert(remote.Config().Name, Equals, "anonymous") + s.NoError(err) + s.Equal("anonymous", remote.Config().Name) } -func (s *RepositorySuite) TestCreateRemoteAnonymousInvalidName(c *C) { +func (s *RepositorySuite) TestCreateRemoteAnonymousInvalidName() { r, _ := Init(memory.NewStorage(), nil) remote, err := r.CreateRemoteAnonymous(&config.RemoteConfig{ Name: "not_anonymous", URLs: []string{"http://foo/foo.git"}, }) - c.Assert(err, Equals, ErrAnonymousRemoteName) - c.Assert(remote, IsNil) + s.ErrorIs(err, ErrAnonymousRemoteName) + s.Nil(remote) } -func (s *RepositorySuite) TestCreateRemoteAnonymousInvalid(c *C) { +func (s *RepositorySuite) TestCreateRemoteAnonymousInvalid() { r, _ := Init(memory.NewStorage(), nil) remote, err := r.CreateRemoteAnonymous(&config.RemoteConfig{}) - c.Assert(err, Equals, config.ErrRemoteConfigEmptyName) - c.Assert(remote, IsNil) + s.ErrorIs(err, config.ErrRemoteConfigEmptyName) + s.Nil(remote) } -func (s *RepositorySuite) TestDeleteRemote(c *C) { +func (s *RepositorySuite) TestDeleteRemote() { r, _ := Init(memory.NewStorage(), nil) _, err := r.CreateRemote(&config.RemoteConfig{ Name: "foo", URLs: []string{"http://foo/foo.git"}, }) - c.Assert(err, IsNil) + s.NoError(err) err = r.DeleteRemote("foo") - c.Assert(err, IsNil) + s.NoError(err) alt, err := r.Remote("foo") - c.Assert(err, Equals, ErrRemoteNotFound) - c.Assert(alt, IsNil) + s.ErrorIs(err, ErrRemoteNotFound) + s.Nil(alt) } -func (s *RepositorySuite) TestEmptyCreateBranch(c *C) { +func (s *RepositorySuite) TestEmptyCreateBranch() { r, _ := Init(memory.NewStorage(), nil) err := r.CreateBranch(&config.Branch{}) - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *RepositorySuite) TestInvalidCreateBranch(c *C) { +func (s *RepositorySuite) TestInvalidCreateBranch() { r, _ := Init(memory.NewStorage(), nil) err := r.CreateBranch(&config.Branch{ Name: "-foo", }) - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *RepositorySuite) TestCreateBranchAndBranch(c *C) { +func (s *RepositorySuite) TestCreateBranchAndBranch() { r, _ := Init(memory.NewStorage(), nil) testBranch := &config.Branch{ Name: "foo", @@ -425,34 +430,34 @@ func (s *RepositorySuite) TestCreateBranchAndBranch(c *C) { } err := r.CreateBranch(testBranch) - c.Assert(err, IsNil) + s.NoError(err) cfg, err := r.Config() - c.Assert(err, IsNil) - c.Assert(len(cfg.Branches), Equals, 1) + s.NoError(err) + s.Len(cfg.Branches, 1) branch := cfg.Branches["foo"] - c.Assert(branch.Name, Equals, testBranch.Name) - c.Assert(branch.Remote, Equals, testBranch.Remote) - c.Assert(branch.Merge, Equals, testBranch.Merge) + s.Equal(testBranch.Name, branch.Name) + s.Equal(testBranch.Remote, branch.Remote) + s.Equal(testBranch.Merge, branch.Merge) branch, err = r.Branch("foo") - c.Assert(err, IsNil) - c.Assert(branch.Name, Equals, testBranch.Name) - c.Assert(branch.Remote, Equals, testBranch.Remote) - c.Assert(branch.Merge, Equals, testBranch.Merge) + s.NoError(err) + s.Equal(testBranch.Name, branch.Name) + s.Equal(testBranch.Remote, branch.Remote) + s.Equal(testBranch.Merge, branch.Merge) } -func (s *RepositorySuite) TestMergeFF(c *C) { +func (s *RepositorySuite) TestMergeFF() { r, err := Init(memory.NewStorage(), memfs.New()) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) - createCommit(c, r) - createCommit(c, r) - createCommit(c, r) - lastCommit := createCommit(c, r) + createCommit(s, r) + createCommit(s, r) + createCommit(s, r) + lastCommit := createCommit(s, r) wt, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) targetBranch := plumbing.NewBranchReferenceName("foo") err = wt.Checkout(&CheckoutOptions{ @@ -460,49 +465,49 @@ func (s *RepositorySuite) TestMergeFF(c *C) { Create: true, Branch: targetBranch, }) - c.Assert(err, IsNil) + s.NoError(err) - createCommit(c, r) - fooHash := createCommit(c, r) + createCommit(s, r) + fooHash := createCommit(s, r) // Checkout the master branch so that we can try to merge foo into it. err = wt.Checkout(&CheckoutOptions{ Branch: plumbing.Master, }) - c.Assert(err, IsNil) + s.NoError(err) head, err := r.Head() - c.Assert(err, IsNil) - c.Assert(head.Hash(), Equals, lastCommit) + s.NoError(err) + s.Equal(lastCommit, head.Hash()) targetRef := plumbing.NewHashReference(targetBranch, fooHash) - c.Assert(targetRef, NotNil) + s.NotNil(targetRef) err = r.Merge(*targetRef, MergeOptions{ Strategy: FastForwardMerge, }) - c.Assert(err, IsNil) + s.NoError(err) head, err = r.Head() - c.Assert(err, IsNil) - c.Assert(head.Hash(), Equals, fooHash) + s.NoError(err) + s.Equal(fooHash, head.Hash()) } -func (s *RepositorySuite) TestMergeFF_Invalid(c *C) { +func (s *RepositorySuite) TestMergeFF_Invalid() { r, err := Init(memory.NewStorage(), memfs.New()) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) // Keep track of the first commit, which will be the // reference to create the target branch so that we // can simulate a non-ff merge. - firstCommit := createCommit(c, r) - createCommit(c, r) - createCommit(c, r) - lastCommit := createCommit(c, r) + firstCommit := createCommit(s, r) + createCommit(s, r) + createCommit(s, r) + lastCommit := createCommit(s, r) wt, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) targetBranch := plumbing.NewBranchReferenceName("foo") err = wt.Checkout(&CheckoutOptions{ @@ -511,43 +516,43 @@ func (s *RepositorySuite) TestMergeFF_Invalid(c *C) { Branch: targetBranch, }) - c.Assert(err, IsNil) + s.NoError(err) - createCommit(c, r) - h := createCommit(c, r) + createCommit(s, r) + h := createCommit(s, r) // Checkout the master branch so that we can try to merge foo into it. err = wt.Checkout(&CheckoutOptions{ Branch: plumbing.Master, }) - c.Assert(err, IsNil) + s.NoError(err) head, err := r.Head() - c.Assert(err, IsNil) - c.Assert(head.Hash(), Equals, lastCommit) + s.NoError(err) + s.Equal(lastCommit, head.Hash()) targetRef := plumbing.NewHashReference(targetBranch, h) - c.Assert(targetRef, NotNil) + s.NotNil(targetRef) err = r.Merge(*targetRef, MergeOptions{ Strategy: MergeStrategy(10), }) - c.Assert(err, Equals, ErrUnsupportedMergeStrategy) + s.ErrorIs(err, ErrUnsupportedMergeStrategy) // Failed merge operations must not change HEAD. head, err = r.Head() - c.Assert(err, IsNil) - c.Assert(head.Hash(), Equals, lastCommit) + s.NoError(err) + s.Equal(lastCommit, head.Hash()) err = r.Merge(*targetRef, MergeOptions{}) - c.Assert(err, Equals, ErrFastForwardMergeNotPossible) + s.ErrorIs(err, ErrFastForwardMergeNotPossible) head, err = r.Head() - c.Assert(err, IsNil) - c.Assert(head.Hash(), Equals, lastCommit) + s.NoError(err) + s.Equal(lastCommit, head.Hash()) } -func (s *RepositorySuite) TestCreateBranchUnmarshal(c *C) { +func (s *RepositorySuite) TestCreateBranchUnmarshal() { r, _ := Init(memory.NewStorage(), nil) expected := []byte(`[core] @@ -567,7 +572,7 @@ func (s *RepositorySuite) TestCreateBranchUnmarshal(c *C) { Name: "foo", URLs: []string{"http://foo/foo.git"}, }) - c.Assert(err, IsNil) + s.NoError(err) testBranch1 := &config.Branch{ Name: "master", Remote: "origin", @@ -579,30 +584,30 @@ func (s *RepositorySuite) TestCreateBranchUnmarshal(c *C) { Merge: "refs/heads/foo", } err = r.CreateBranch(testBranch1) - c.Assert(err, IsNil) + s.NoError(err) err = r.CreateBranch(testBranch2) - c.Assert(err, IsNil) + s.NoError(err) cfg, err := r.Config() - c.Assert(err, IsNil) + s.NoError(err) marshaled, err := cfg.Marshal() - c.Assert(err, IsNil) - c.Assert(string(expected), Equals, string(marshaled)) + s.NoError(err) + s.Equal(string(marshaled), string(expected)) } -func (s *RepositorySuite) TestBranchInvalid(c *C) { +func (s *RepositorySuite) TestBranchInvalid() { r, _ := Init(memory.NewStorage(), nil) branch, err := r.Branch("foo") - c.Assert(err, NotNil) - c.Assert(branch, IsNil) + s.NotNil(err) + s.Nil(branch) } -func (s *RepositorySuite) TestCreateBranchInvalid(c *C) { +func (s *RepositorySuite) TestCreateBranchInvalid() { r, _ := Init(memory.NewStorage(), nil) err := r.CreateBranch(&config.Branch{}) - c.Assert(err, NotNil) + s.NotNil(err) testBranch := &config.Branch{ Name: "foo", @@ -610,12 +615,12 @@ func (s *RepositorySuite) TestCreateBranchInvalid(c *C) { Merge: "refs/heads/foo", } err = r.CreateBranch(testBranch) - c.Assert(err, IsNil) + s.NoError(err) err = r.CreateBranch(testBranch) - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *RepositorySuite) TestDeleteBranch(c *C) { +func (s *RepositorySuite) TestDeleteBranch() { r, _ := Init(memory.NewStorage(), nil) testBranch := &config.Branch{ Name: "foo", @@ -624,35 +629,35 @@ func (s *RepositorySuite) TestDeleteBranch(c *C) { } err := r.CreateBranch(testBranch) - c.Assert(err, IsNil) + s.NoError(err) err = r.DeleteBranch("foo") - c.Assert(err, IsNil) + s.NoError(err) b, err := r.Branch("foo") - c.Assert(err, Equals, ErrBranchNotFound) - c.Assert(b, IsNil) + s.ErrorIs(err, ErrBranchNotFound) + s.Nil(b) err = r.DeleteBranch("foo") - c.Assert(err, Equals, ErrBranchNotFound) + s.ErrorIs(err, ErrBranchNotFound) } -func (s *RepositorySuite) TestPlainInit(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestPlainInit() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainInit(dir, true) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) cfg, err := r.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Core.IsBare, Equals, true) + s.NoError(err) + s.True(cfg.Core.IsBare) } -func (s *RepositorySuite) TestPlainInitWithOptions(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestPlainInitWithOptions() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainInitWithOptions(dir, &PlainInitOptions{ InitOptions: InitOptions{ @@ -660,56 +665,56 @@ func (s *RepositorySuite) TestPlainInitWithOptions(c *C) { }, Bare: false, }) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) cfg, err := r.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Core.IsBare, Equals, false) + s.NoError(err) + s.False(cfg.Core.IsBare) - createCommit(c, r) + createCommit(s, r) ref, err := r.Head() - c.Assert(err, IsNil) - c.Assert(ref.Name().String(), Equals, "refs/heads/foo") + s.NoError(err) + s.Equal("refs/heads/foo", ref.Name().String()) } -func (s *RepositorySuite) TestPlainInitAlreadyExists(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestPlainInitAlreadyExists() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainInit(dir, true) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) r, err = PlainInit(dir, true) - c.Assert(err, Equals, ErrRepositoryAlreadyExists) - c.Assert(r, IsNil) + s.ErrorIs(err, ErrRepositoryAlreadyExists) + s.Nil(r) } -func (s *RepositorySuite) TestPlainOpen(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestPlainOpen() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainInit(dir, false) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) r, err = PlainOpen(dir) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) } -func (s *RepositorySuite) TestPlainOpenTildePath(c *C) { +func (s *RepositorySuite) TestPlainOpenTildePath() { dir, clean := s.TemporalHomeDir() defer clean() r, err := PlainInit(dir, false) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) currentUser, err := user.Current() - c.Assert(err, IsNil) + s.NoError(err) // remove domain for windows username := currentUser.Username[strings.Index(currentUser.Username, "\\")+1:] @@ -718,214 +723,210 @@ func (s *RepositorySuite) TestPlainOpenTildePath(c *C) { path := strings.Replace(dir, strings.Split(dir, ".tmp")[0], home, 1) r, err = PlainOpen(path) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) } } -func (s *RepositorySuite) TestPlainOpenBare(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestPlainOpenBare() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainInit(dir, true) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) r, err = PlainOpen(dir) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) } -func (s *RepositorySuite) TestPlainOpenNotBare(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestPlainOpenNotBare() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainInit(dir, false) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) r, err = PlainOpen(filepath.Join(dir, ".git")) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) } -func (s *RepositorySuite) testPlainOpenGitFile(c *C, f func(string, string) string) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *RepositorySuite) testPlainOpenGitFile(f func(string, string) string) { + fs := s.TemporalFilesystem() dir, err := util.TempDir(fs, "", "plain-open") - c.Assert(err, IsNil) + s.NoError(err) r, err := PlainInit(fs.Join(fs.Root(), dir), true) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) altDir, err := util.TempDir(fs, "", "plain-open") - c.Assert(err, IsNil) + s.NoError(err) err = util.WriteFile(fs, fs.Join(altDir, ".git"), []byte(f(fs.Join(fs.Root(), dir), fs.Join(fs.Root(), altDir))), - 0644, + 0o644, ) - c.Assert(err, IsNil) + s.NoError(err) r, err = PlainOpen(fs.Join(fs.Root(), altDir)) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) } -func (s *RepositorySuite) TestPlainOpenBareAbsoluteGitDirFile(c *C) { - s.testPlainOpenGitFile(c, func(dir, altDir string) string { +func (s *RepositorySuite) TestPlainOpenBareAbsoluteGitDirFile() { + s.testPlainOpenGitFile(func(dir, altDir string) string { return fmt.Sprintf("gitdir: %s\n", dir) }) } -func (s *RepositorySuite) TestPlainOpenBareAbsoluteGitDirFileNoEOL(c *C) { - s.testPlainOpenGitFile(c, func(dir, altDir string) string { +func (s *RepositorySuite) TestPlainOpenBareAbsoluteGitDirFileNoEOL() { + s.testPlainOpenGitFile(func(dir, altDir string) string { return fmt.Sprintf("gitdir: %s", dir) }) } -func (s *RepositorySuite) TestPlainOpenBareRelativeGitDirFile(c *C) { - s.testPlainOpenGitFile(c, func(dir, altDir string) string { +func (s *RepositorySuite) TestPlainOpenBareRelativeGitDirFile() { + s.testPlainOpenGitFile(func(dir, altDir string) string { dir, err := filepath.Rel(altDir, dir) - c.Assert(err, IsNil) + s.NoError(err) return fmt.Sprintf("gitdir: %s\n", dir) }) } -func (s *RepositorySuite) TestPlainOpenBareRelativeGitDirFileNoEOL(c *C) { - s.testPlainOpenGitFile(c, func(dir, altDir string) string { +func (s *RepositorySuite) TestPlainOpenBareRelativeGitDirFileNoEOL() { + s.testPlainOpenGitFile(func(dir, altDir string) string { dir, err := filepath.Rel(altDir, dir) - c.Assert(err, IsNil) + s.NoError(err) return fmt.Sprintf("gitdir: %s\n", dir) }) } -func (s *RepositorySuite) TestPlainOpenBareRelativeGitDirFileTrailingGarbage(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *RepositorySuite) TestPlainOpenBareRelativeGitDirFileTrailingGarbage() { + fs := s.TemporalFilesystem() dir, err := util.TempDir(fs, "", "") - c.Assert(err, IsNil) + s.NoError(err) r, err := PlainInit(dir, true) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) altDir, err := util.TempDir(fs, "", "") - c.Assert(err, IsNil) + s.NoError(err) err = util.WriteFile(fs, fs.Join(altDir, ".git"), []byte(fmt.Sprintf("gitdir: %s\nTRAILING", fs.Join(fs.Root(), altDir))), - 0644, + 0o644, ) - c.Assert(err, IsNil) + s.NoError(err) r, err = PlainOpen(altDir) - c.Assert(err, Equals, ErrRepositoryNotExists) - c.Assert(r, IsNil) + s.ErrorIs(err, ErrRepositoryNotExists) + s.Nil(r) } -func (s *RepositorySuite) TestPlainOpenBareRelativeGitDirFileBadPrefix(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *RepositorySuite) TestPlainOpenBareRelativeGitDirFileBadPrefix() { + fs := s.TemporalFilesystem() dir, err := util.TempDir(fs, "", "") - c.Assert(err, IsNil) + s.NoError(err) r, err := PlainInit(fs.Join(fs.Root(), dir), true) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) altDir, err := util.TempDir(fs, "", "") - c.Assert(err, IsNil) + s.NoError(err) err = util.WriteFile(fs, fs.Join(altDir, ".git"), []byte( fmt.Sprintf("xgitdir: %s\n", fs.Join(fs.Root(), dir)), - ), 0644) + ), 0o644) - c.Assert(err, IsNil) + s.NoError(err) r, err = PlainOpen(fs.Join(fs.Root(), altDir)) - c.Assert(err, ErrorMatches, ".*gitdir.*") - c.Assert(r, IsNil) + s.ErrorContains(err, "gitdir") + s.Nil(r) } -func (s *RepositorySuite) TestPlainOpenNotExists(c *C) { +func (s *RepositorySuite) TestPlainOpenNotExists() { r, err := PlainOpen("/not-exists/") - c.Assert(err, Equals, ErrRepositoryNotExists) - c.Assert(r, IsNil) + s.ErrorIs(err, ErrRepositoryNotExists) + s.Nil(r) } -func (s *RepositorySuite) TestPlainOpenDetectDotGit(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *RepositorySuite) TestPlainOpenDetectDotGit() { + fs := s.TemporalFilesystem() dir, err := util.TempDir(fs, "", "") - c.Assert(err, IsNil) + s.NoError(err) subdir := filepath.Join(dir, "a", "b") err = fs.MkdirAll(subdir, 0755) - c.Assert(err, IsNil) + s.NoError(err) file := fs.Join(subdir, "file.txt") f, err := fs.Create(file) - c.Assert(err, IsNil) + s.NoError(err) f.Close() r, err := PlainInit(fs.Join(fs.Root(), dir), false) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) opt := &PlainOpenOptions{DetectDotGit: true} r, err = PlainOpenWithOptions(fs.Join(fs.Root(), subdir), opt) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) r, err = PlainOpenWithOptions(fs.Join(fs.Root(), file), opt) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) optnodetect := &PlainOpenOptions{DetectDotGit: false} r, err = PlainOpenWithOptions(fs.Join(fs.Root(), file), optnodetect) - c.Assert(err, NotNil) - c.Assert(r, IsNil) + s.NotNil(err) + s.Nil(r) } -func (s *RepositorySuite) TestPlainOpenNotExistsDetectDotGit(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestPlainOpenNotExistsDetectDotGit() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) opt := &PlainOpenOptions{DetectDotGit: true} r, err := PlainOpenWithOptions(dir, opt) - c.Assert(err, Equals, ErrRepositoryNotExists) - c.Assert(r, IsNil) + s.ErrorIs(err, ErrRepositoryNotExists) + s.Nil(r) } -func (s *RepositorySuite) TestPlainClone(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestPlainClone() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainClone(dir, false, &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) remotes, err := r.Remotes() - c.Assert(err, IsNil) - c.Assert(remotes, HasLen, 1) + s.NoError(err) + s.Len(remotes, 1) cfg, err := r.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Branches, HasLen, 1) - c.Assert(cfg.Branches["master"].Name, Equals, "master") + s.NoError(err) + s.Len(cfg.Branches, 1) + s.Equal("master", cfg.Branches["master"].Name) } -func (s *RepositorySuite) TestPlainCloneBareAndShared(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestPlainCloneBareAndShared() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) remote := s.GetBasicLocalRepositoryURL() @@ -933,27 +934,27 @@ func (s *RepositorySuite) TestPlainCloneBareAndShared(c *C) { URL: remote, Shared: true, }) - c.Assert(err, IsNil) + s.NoError(err) altpath := path.Join(dir, "objects", "info", "alternates") _, err = os.Stat(altpath) - c.Assert(err, IsNil) + s.NoError(err) data, err := os.ReadFile(altpath) - c.Assert(err, IsNil) + s.NoError(err) line := path.Join(remote, GitDirName, "objects") + "\n" - c.Assert(string(data), Equals, line) + s.Equal(line, string(data)) cfg, err := r.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Branches, HasLen, 1) - c.Assert(cfg.Branches["master"].Name, Equals, "master") + s.NoError(err) + s.Len(cfg.Branches, 1) + s.Equal("master", cfg.Branches["master"].Name) } -func (s *RepositorySuite) TestPlainCloneShared(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestPlainCloneShared() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) remote := s.GetBasicLocalRepositoryURL() @@ -961,236 +962,232 @@ func (s *RepositorySuite) TestPlainCloneShared(c *C) { URL: remote, Shared: true, }) - c.Assert(err, IsNil) + s.NoError(err) altpath := path.Join(dir, GitDirName, "objects", "info", "alternates") _, err = os.Stat(altpath) - c.Assert(err, IsNil) + s.NoError(err) data, err := os.ReadFile(altpath) - c.Assert(err, IsNil) + s.NoError(err) line := path.Join(remote, GitDirName, "objects") + "\n" - c.Assert(string(data), Equals, line) + s.Equal(line, string(data)) cfg, err := r.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Branches, HasLen, 1) - c.Assert(cfg.Branches["master"].Name, Equals, "master") + s.NoError(err) + s.Len(cfg.Branches, 1) + s.Equal("master", cfg.Branches["master"].Name) } -func (s *RepositorySuite) TestPlainCloneSharedHttpShouldReturnError(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestPlainCloneSharedHttpShouldReturnError() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) remote := "http://somerepo" - _, err := PlainClone(dir, false, &CloneOptions{ + _, err = PlainClone(dir, false, &CloneOptions{ URL: remote, Shared: true, }) - c.Assert(err, Equals, ErrAlternatePathNotSupported) + s.ErrorIs(err, ErrAlternatePathNotSupported) } -func (s *RepositorySuite) TestPlainCloneSharedHttpsShouldReturnError(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestPlainCloneSharedHttpsShouldReturnError() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) remote := "https://somerepo" - _, err := PlainClone(dir, false, &CloneOptions{ + _, err = PlainClone(dir, false, &CloneOptions{ URL: remote, Shared: true, }) - c.Assert(err, Equals, ErrAlternatePathNotSupported) + s.ErrorIs(err, ErrAlternatePathNotSupported) } -func (s *RepositorySuite) TestPlainCloneSharedSSHShouldReturnError(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestPlainCloneSharedSSHShouldReturnError() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) remote := "ssh://somerepo" - _, err := PlainClone(dir, false, &CloneOptions{ + _, err = PlainClone(dir, false, &CloneOptions{ URL: remote, Shared: true, }) - c.Assert(err, Equals, ErrAlternatePathNotSupported) + s.ErrorIs(err, ErrAlternatePathNotSupported) } -func (s *RepositorySuite) TestPlainCloneWithRemoteName(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestPlainCloneWithRemoteName() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainClone(dir, false, &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), RemoteName: "test", }) - c.Assert(err, IsNil) + s.NoError(err) remote, err := r.Remote("test") - c.Assert(err, IsNil) - c.Assert(remote, NotNil) + s.NoError(err) + s.NotNil(remote) } -func (s *RepositorySuite) TestPlainCloneOverExistingGitDirectory(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestPlainCloneOverExistingGitDirectory() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainInit(dir, false) - c.Assert(r, NotNil) - c.Assert(err, IsNil) + s.NotNil(r) + s.NoError(err) r, err = PlainClone(dir, false, &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(r, IsNil) - c.Assert(err, Equals, ErrRepositoryAlreadyExists) + s.Nil(r) + s.ErrorIs(err, ErrRepositoryAlreadyExists) } -func (s *RepositorySuite) TestPlainCloneContextCancel(c *C) { +func (s *RepositorySuite) TestPlainCloneContextCancel() { ctx, cancel := context.WithCancel(context.Background()) cancel() - dir, clean := s.TemporalDir() - defer clean() + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainCloneContext(ctx, dir, false, &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(r, NotNil) - c.Assert(err, Equals, context.Canceled) + s.NotNil(r) + s.ErrorIs(err, context.Canceled) } -func (s *RepositorySuite) TestPlainCloneContextNonExistentWithExistentDir(c *C) { +func (s *RepositorySuite) TestPlainCloneContextNonExistentWithExistentDir() { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - fs, clean := s.TemporalFilesystem() - defer clean() + fs := s.TemporalFilesystem() dir, err := util.TempDir(fs, "", "") - c.Assert(err, IsNil) + s.NoError(err) r, err := PlainCloneContext(ctx, dir, false, &CloneOptions{ URL: "incorrectOnPurpose", }) - c.Assert(r, NotNil) - c.Assert(err, Equals, transport.ErrRepositoryNotFound) + s.NotNil(r) + s.ErrorIs(err, transport.ErrRepositoryNotFound) _, err = fs.Stat(dir) - c.Assert(os.IsNotExist(err), Equals, false) + s.False(os.IsNotExist(err)) names, err := fs.ReadDir(dir) - c.Assert(err, IsNil) - c.Assert(names, HasLen, 0) + s.NoError(err) + s.Len(names, 0) } -func (s *RepositorySuite) TestPlainCloneContextNonExistentWithNonExistentDir(c *C) { +func (s *RepositorySuite) TestPlainCloneContextNonExistentWithNonExistentDir() { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - fs, clean := s.TemporalFilesystem() - defer clean() + fs := s.TemporalFilesystem() tmpDir, err := util.TempDir(fs, "", "") - c.Assert(err, IsNil) + s.NoError(err) repoDir := filepath.Join(tmpDir, "repoDir") r, err := PlainCloneContext(ctx, repoDir, false, &CloneOptions{ URL: "incorrectOnPurpose", }) - c.Assert(r, NotNil) - c.Assert(err, Equals, transport.ErrRepositoryNotFound) + s.NotNil(r) + s.ErrorIs(err, transport.ErrRepositoryNotFound) _, err = fs.Stat(repoDir) - c.Assert(os.IsNotExist(err), Equals, true) + s.True(os.IsNotExist(err)) } -func (s *RepositorySuite) TestPlainCloneContextNonExistentWithNotDir(c *C) { +func (s *RepositorySuite) TestPlainCloneContextNonExistentWithNotDir() { ctx, cancel := context.WithCancel(context.Background()) cancel() - fs, clean := s.TemporalFilesystem() - defer clean() + fs := s.TemporalFilesystem() tmpDir, err := util.TempDir(fs, "", "") - c.Assert(err, IsNil) + s.NoError(err) repoDir := fs.Join(tmpDir, "repoDir") f, err := fs.Create(repoDir) - c.Assert(err, IsNil) - c.Assert(f.Close(), IsNil) + s.NoError(err) + s.Nil(f.Close()) r, err := PlainCloneContext(ctx, fs.Join(fs.Root(), repoDir), false, &CloneOptions{ URL: "incorrectOnPurpose", }) - c.Assert(r, IsNil) - c.Assert(err, ErrorMatches, ".*not a directory.*") + s.Nil(r) + s.ErrorContains(err, "not a directory") fi, err := fs.Stat(repoDir) - c.Assert(err, IsNil) - c.Assert(fi.IsDir(), Equals, false) + s.NoError(err) + s.False(fi.IsDir()) } -func (s *RepositorySuite) TestPlainCloneContextNonExistentWithNotEmptyDir(c *C) { +func (s *RepositorySuite) TestPlainCloneContextNonExistentWithNotEmptyDir() { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - fs, clean := s.TemporalFilesystem() - defer clean() + fs := s.TemporalFilesystem() tmpDir, err := util.TempDir(fs, "", "") - c.Assert(err, IsNil) + s.NoError(err) repoDir := filepath.Join(tmpDir, "repoDir") err = fs.MkdirAll(repoDir, 0777) - c.Assert(err, IsNil) + s.NoError(err) dummyFile := filepath.Join(repoDir, "dummyFile") err = util.WriteFile(fs, dummyFile, []byte("dummyContent"), 0644) - c.Assert(err, IsNil) + s.NoError(err) r, err := PlainCloneContext(ctx, fs.Join(fs.Root(), repoDir), false, &CloneOptions{ URL: "incorrectOnPurpose", }) - c.Assert(r, NotNil) - c.Assert(err, Equals, transport.ErrRepositoryNotFound) + s.NotNil(r) + s.ErrorIs(err, transport.ErrRepositoryNotFound) _, err = fs.Stat(dummyFile) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *RepositorySuite) TestPlainCloneContextNonExistingOverExistingGitDirectory(c *C) { +func (s *RepositorySuite) TestPlainCloneContextNonExistingOverExistingGitDirectory() { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - dir, clean := s.TemporalDir() - defer clean() + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainInit(dir, false) - c.Assert(r, NotNil) - c.Assert(err, IsNil) + s.NotNil(r) + s.NoError(err) r, err = PlainCloneContext(ctx, dir, false, &CloneOptions{ URL: "incorrectOnPurpose", }) - c.Assert(r, IsNil) - c.Assert(err, Equals, ErrRepositoryAlreadyExists) + s.Nil(r) + s.ErrorIs(err, ErrRepositoryAlreadyExists) } -func (s *RepositorySuite) TestPlainCloneWithRecurseSubmodules(c *C) { +func (s *RepositorySuite) TestPlainCloneWithRecurseSubmodules() { if testing.Short() { - c.Skip("skipping test in short mode.") + s.T().Skip("skipping test in short mode.") } - dir, clean := s.TemporalDir() - defer clean() + dir, err := os.MkdirTemp("", "") + s.NoError(err) path := fixtures.ByTag("submodule").One().Worktree().Root() r, err := PlainClone(dir, false, &CloneOptions{ @@ -1198,22 +1195,22 @@ func (s *RepositorySuite) TestPlainCloneWithRecurseSubmodules(c *C) { RecurseSubmodules: DefaultSubmoduleRecursionDepth, }) - c.Assert(err, IsNil) + s.NoError(err) cfg, err := r.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Remotes, HasLen, 1) - c.Assert(cfg.Branches, HasLen, 1) - c.Assert(cfg.Submodules, HasLen, 2) + s.NoError(err) + s.Len(cfg.Remotes, 1) + s.Len(cfg.Branches, 1) + s.Len(cfg.Submodules, 2) } -func (s *RepositorySuite) TestPlainCloneWithShallowSubmodules(c *C) { +func (s *RepositorySuite) TestPlainCloneWithShallowSubmodules() { if testing.Short() { - c.Skip("skipping test in short mode.") + s.T().Skip("skipping test in short mode.") } - dir, clean := s.TemporalDir() - defer clean() + dir, err := os.MkdirTemp("", "") + s.NoError(err) path := fixtures.ByTag("submodule").One().Worktree().Root() mainRepo, err := PlainClone(dir, false, &CloneOptions{ @@ -1221,32 +1218,32 @@ func (s *RepositorySuite) TestPlainCloneWithShallowSubmodules(c *C) { RecurseSubmodules: 1, ShallowSubmodules: true, }) - c.Assert(err, IsNil) + s.NoError(err) mainWorktree, err := mainRepo.Worktree() - c.Assert(err, IsNil) + s.NoError(err) submodule, err := mainWorktree.Submodule("basic") - c.Assert(err, IsNil) + s.NoError(err) subRepo, err := submodule.Repository() - c.Assert(err, IsNil) + s.NoError(err) lr, err := subRepo.Log(&LogOptions{}) - c.Assert(err, IsNil) + s.NoError(err) commitCount := 0 for _, err := lr.Next(); err == nil; _, err = lr.Next() { commitCount++ } - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(commitCount, Equals, 1) + s.Equal(1, commitCount) } -func (s *RepositorySuite) TestPlainCloneNoCheckout(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestPlainCloneNoCheckout() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) path := fixtures.ByTag("submodule").One().Worktree().Root() r, err := PlainClone(dir, false, &CloneOptions{ @@ -1254,55 +1251,85 @@ func (s *RepositorySuite) TestPlainCloneNoCheckout(c *C) { NoCheckout: true, RecurseSubmodules: DefaultSubmoduleRecursionDepth, }) - c.Assert(err, IsNil) + s.NoError(err) h, err := r.Head() - c.Assert(err, IsNil) - c.Assert(h.Hash().String(), Equals, "b685400c1f9316f350965a5993d350bc746b0bf4") + s.NoError(err) + s.Equal("b685400c1f9316f350965a5993d350bc746b0bf4", h.Hash().String()) fi, err := osfs.New(dir).ReadDir("") - c.Assert(err, IsNil) - c.Assert(fi, HasLen, 1) // .git + s.NoError(err) + s.Len(fi, 1) // .git } -func (s *RepositorySuite) TestFetch(c *C) { +func (s *RepositorySuite) TestFetch() { r, _ := Init(memory.NewStorage(), nil) _, err := r.CreateRemote(&config.RemoteConfig{ Name: DefaultRemoteName, URLs: []string{s.GetBasicLocalRepositoryURL()}, }) - c.Assert(err, IsNil) - c.Assert(r.Fetch(&FetchOptions{}), IsNil) + s.NoError(err) + s.Nil(r.Fetch(&FetchOptions{})) remotes, err := r.Remotes() - c.Assert(err, IsNil) - c.Assert(remotes, HasLen, 1) + s.NoError(err) + s.Len(remotes, 1) _, err = r.Head() - c.Assert(err, Equals, plumbing.ErrReferenceNotFound) + s.ErrorIs(err, plumbing.ErrReferenceNotFound) branch, err := r.Reference("refs/remotes/origin/master", false) - c.Assert(err, IsNil) - c.Assert(branch, NotNil) - c.Assert(branch.Type(), Equals, plumbing.HashReference) - c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") + s.NoError(err) + s.NotNil(branch) + s.Equal(plumbing.HashReference, branch.Type()) + s.Equal("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", branch.Hash().String()) } -func (s *RepositorySuite) TestFetchContext(c *C) { +func (s *RepositorySuite) TestFetchContext() { r, _ := Init(memory.NewStorage(), nil) _, err := r.CreateRemote(&config.RemoteConfig{ Name: DefaultRemoteName, URLs: []string{s.GetBasicLocalRepositoryURL()}, }) - c.Assert(err, IsNil) + s.NoError(err) ctx, cancel := context.WithCancel(context.Background()) cancel() - c.Assert(r.FetchContext(ctx, &FetchOptions{}), NotNil) + s.NotNil(r.FetchContext(ctx, &FetchOptions{})) +} + +func (s *RepositorySuite) TestFetchWithFilters() { + r, _ := Init(memory.NewStorage(), nil) + _, err := r.CreateRemote(&config.RemoteConfig{ + Name: DefaultRemoteName, + URLs: []string{s.GetBasicLocalRepositoryURL()}, + }) + s.NoError(err) + + err = r.Fetch(&FetchOptions{ + Filter: packp.FilterBlobNone(), + }) + s.ErrorIs(err, ErrFilterNotSupported) + } +func (s *RepositorySuite) TestFetchWithFiltersReal() { + r, _ := Init(memory.NewStorage(), nil) + _, err := r.CreateRemote(&config.RemoteConfig{ + Name: DefaultRemoteName, + URLs: []string{"https://github.com/git-fixtures/basic.git"}, + }) + s.NoError(err) + err = r.Fetch(&FetchOptions{ + Filter: packp.FilterBlobNone(), + }) + s.NoError(err) + blob, err := r.BlobObject(plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492")) + s.NotNil(err) + s.Nil(blob) -func (s *RepositorySuite) TestCloneWithProgress(c *C) { +} +func (s *RepositorySuite) TestCloneWithProgress() { fs := memfs.New() buf := bytes.NewBuffer(nil) @@ -1311,88 +1338,88 @@ func (s *RepositorySuite) TestCloneWithProgress(c *C) { Progress: buf, }) - c.Assert(err, IsNil) - c.Assert(buf.Len(), Not(Equals), 0) + s.NoError(err) + s.NotEqual(0, buf.Len()) } -func (s *RepositorySuite) TestCloneDeep(c *C) { +func (s *RepositorySuite) TestCloneDeep() { fs := memfs.New() r, _ := Init(memory.NewStorage(), fs) head, err := r.Head() - c.Assert(err, Equals, plumbing.ErrReferenceNotFound) - c.Assert(head, IsNil) + s.ErrorIs(err, plumbing.ErrReferenceNotFound) + s.Nil(head) err = r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) remotes, err := r.Remotes() - c.Assert(err, IsNil) - c.Assert(remotes, HasLen, 1) + s.NoError(err) + s.Len(remotes, 1) head, err = r.Reference(plumbing.HEAD, false) - c.Assert(err, IsNil) - c.Assert(head, NotNil) - c.Assert(head.Type(), Equals, plumbing.SymbolicReference) - c.Assert(head.Target().String(), Equals, "refs/heads/master") + s.NoError(err) + s.NotNil(head) + s.Equal(plumbing.SymbolicReference, head.Type()) + s.Equal("refs/heads/master", head.Target().String()) branch, err := r.Reference(head.Target(), false) - c.Assert(err, IsNil) - c.Assert(branch, NotNil) - c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") + s.NoError(err) + s.NotNil(branch) + s.Equal("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", branch.Hash().String()) branch, err = r.Reference("refs/remotes/origin/master", false) - c.Assert(err, IsNil) - c.Assert(branch, NotNil) - c.Assert(branch.Type(), Equals, plumbing.HashReference) - c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") + s.NoError(err) + s.NotNil(branch) + s.Equal(plumbing.HashReference, branch.Type()) + s.Equal("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", branch.Hash().String()) fi, err := fs.ReadDir("") - c.Assert(err, IsNil) - c.Assert(fi, HasLen, 8) + s.NoError(err) + s.Len(fi, 8) } -func (s *RepositorySuite) TestCloneConfig(c *C) { +func (s *RepositorySuite) TestCloneConfig() { r, _ := Init(memory.NewStorage(), nil) head, err := r.Head() - c.Assert(err, Equals, plumbing.ErrReferenceNotFound) - c.Assert(head, IsNil) + s.ErrorIs(err, plumbing.ErrReferenceNotFound) + s.Nil(head) err = r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) cfg, err := r.Config() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(cfg.Core.IsBare, Equals, true) - c.Assert(cfg.Remotes, HasLen, 1) - c.Assert(cfg.Remotes["origin"].Name, Equals, "origin") - c.Assert(cfg.Remotes["origin"].URLs, HasLen, 1) - c.Assert(cfg.Branches, HasLen, 1) - c.Assert(cfg.Branches["master"].Name, Equals, "master") + s.True(cfg.Core.IsBare) + s.Len(cfg.Remotes, 1) + s.Equal("origin", cfg.Remotes["origin"].Name) + s.Len(cfg.Remotes["origin"].URLs, 1) + s.Len(cfg.Branches, 1) + s.Equal("master", cfg.Branches["master"].Name) } -func (s *RepositorySuite) TestCloneSingleBranchAndNonHEAD(c *C) { - s.testCloneSingleBranchAndNonHEADReference(c, "refs/heads/branch") +func (s *RepositorySuite) TestCloneSingleBranchAndNonHEAD() { + s.testCloneSingleBranchAndNonHEADReference("refs/heads/branch") } -func (s *RepositorySuite) TestCloneSingleBranchAndNonHEADAndNonFull(c *C) { - s.testCloneSingleBranchAndNonHEADReference(c, "branch") +func (s *RepositorySuite) TestCloneSingleBranchAndNonHEADAndNonFull() { + s.testCloneSingleBranchAndNonHEADReference("branch") } -func (s *RepositorySuite) testCloneSingleBranchAndNonHEADReference(c *C, ref string) { +func (s *RepositorySuite) testCloneSingleBranchAndNonHEADReference(ref string) { r, _ := Init(memory.NewStorage(), nil) head, err := r.Head() - c.Assert(err, Equals, plumbing.ErrReferenceNotFound) - c.Assert(head, IsNil) + s.ErrorIs(err, plumbing.ErrReferenceNotFound) + s.Nil(head) err = r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), @@ -1400,118 +1427,118 @@ func (s *RepositorySuite) testCloneSingleBranchAndNonHEADReference(c *C, ref str SingleBranch: true, }) - c.Assert(err, IsNil) + s.NoError(err) remotes, err := r.Remotes() - c.Assert(err, IsNil) - c.Assert(remotes, HasLen, 1) + s.NoError(err) + s.Len(remotes, 1) cfg, err := r.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Branches, HasLen, 1) - c.Assert(cfg.Branches["branch"].Name, Equals, "branch") - c.Assert(cfg.Branches["branch"].Remote, Equals, "origin") - c.Assert(cfg.Branches["branch"].Merge, Equals, plumbing.ReferenceName("refs/heads/branch")) + s.NoError(err) + s.Len(cfg.Branches, 1) + s.Equal("branch", cfg.Branches["branch"].Name) + s.Equal("origin", cfg.Branches["branch"].Remote) + s.Equal(plumbing.ReferenceName("refs/heads/branch"), cfg.Branches["branch"].Merge) head, err = r.Reference(plumbing.HEAD, false) - c.Assert(err, IsNil) - c.Assert(head, NotNil) - c.Assert(head.Type(), Equals, plumbing.SymbolicReference) - c.Assert(head.Target().String(), Equals, "refs/heads/branch") + s.NoError(err) + s.NotNil(head) + s.Equal(plumbing.SymbolicReference, head.Type()) + s.Equal("refs/heads/branch", head.Target().String()) branch, err := r.Reference(head.Target(), false) - c.Assert(err, IsNil) - c.Assert(branch, NotNil) - c.Assert(branch.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881") + s.NoError(err) + s.NotNil(branch) + s.Equal("e8d3ffab552895c19b9fcf7aa264d277cde33881", branch.Hash().String()) branch, err = r.Reference("refs/remotes/origin/branch", false) - c.Assert(err, IsNil) - c.Assert(branch, NotNil) - c.Assert(branch.Type(), Equals, plumbing.HashReference) - c.Assert(branch.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881") + s.NoError(err) + s.NotNil(branch) + s.Equal(plumbing.HashReference, branch.Type()) + s.Equal("e8d3ffab552895c19b9fcf7aa264d277cde33881", branch.Hash().String()) } -func (s *RepositorySuite) TestCloneSingleBranchHEADMain(c *C) { +func (s *RepositorySuite) TestCloneSingleBranchHEADMain() { r, _ := Init(memory.NewStorage(), nil) head, err := r.Head() - c.Assert(err, Equals, plumbing.ErrReferenceNotFound) - c.Assert(head, IsNil) + s.ErrorIs(err, plumbing.ErrReferenceNotFound) + s.Nil(head) err = r.clone(context.Background(), &CloneOptions{ URL: s.GetLocalRepositoryURL(fixtures.ByTag("no-master-head").One()), SingleBranch: true, }) - c.Assert(err, IsNil) + s.NoError(err) remotes, err := r.Remotes() - c.Assert(err, IsNil) - c.Assert(remotes, HasLen, 1) + s.NoError(err) + s.Len(remotes, 1) cfg, err := r.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Branches, HasLen, 1) - c.Assert(cfg.Branches["main"].Name, Equals, "main") - c.Assert(cfg.Branches["main"].Remote, Equals, "origin") - c.Assert(cfg.Branches["main"].Merge, Equals, plumbing.ReferenceName("refs/heads/main")) + s.NoError(err) + s.Len(cfg.Branches, 1) + s.Equal("main", cfg.Branches["main"].Name) + s.Equal("origin", cfg.Branches["main"].Remote) + s.Equal(plumbing.ReferenceName("refs/heads/main"), cfg.Branches["main"].Merge) head, err = r.Reference(plumbing.HEAD, false) - c.Assert(err, IsNil) - c.Assert(head, NotNil) - c.Assert(head.Type(), Equals, plumbing.SymbolicReference) - c.Assert(head.Target().String(), Equals, "refs/heads/main") + s.NoError(err) + s.NotNil(head) + s.Equal(plumbing.SymbolicReference, head.Type()) + s.Equal("refs/heads/main", head.Target().String()) branch, err := r.Reference(head.Target(), false) - c.Assert(err, IsNil) - c.Assert(branch, NotNil) - c.Assert(branch.Hash().String(), Equals, "786dafbd351e587da1ae97e5fb9fbdf868b4a28f") + s.NoError(err) + s.NotNil(branch) + s.Equal("786dafbd351e587da1ae97e5fb9fbdf868b4a28f", branch.Hash().String()) branch, err = r.Reference("refs/remotes/origin/HEAD", false) - c.Assert(err, IsNil) - c.Assert(branch, NotNil) - c.Assert(branch.Type(), Equals, plumbing.HashReference) - c.Assert(branch.Hash().String(), Equals, "786dafbd351e587da1ae97e5fb9fbdf868b4a28f") + s.NoError(err) + s.NotNil(branch) + s.Equal(plumbing.HashReference, branch.Type()) + s.Equal("786dafbd351e587da1ae97e5fb9fbdf868b4a28f", branch.Hash().String()) } -func (s *RepositorySuite) TestCloneSingleBranch(c *C) { +func (s *RepositorySuite) TestCloneSingleBranch() { r, _ := Init(memory.NewStorage(), nil) head, err := r.Head() - c.Assert(err, Equals, plumbing.ErrReferenceNotFound) - c.Assert(head, IsNil) + s.ErrorIs(err, plumbing.ErrReferenceNotFound) + s.Nil(head) err = r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), SingleBranch: true, }) - c.Assert(err, IsNil) + s.NoError(err) remotes, err := r.Remotes() - c.Assert(err, IsNil) - c.Assert(remotes, HasLen, 1) + s.NoError(err) + s.Len(remotes, 1) cfg, err := r.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Branches, HasLen, 1) - c.Assert(cfg.Branches["master"].Name, Equals, "master") - c.Assert(cfg.Branches["master"].Remote, Equals, "origin") - c.Assert(cfg.Branches["master"].Merge, Equals, plumbing.ReferenceName("refs/heads/master")) + s.NoError(err) + s.Len(cfg.Branches, 1) + s.Equal("master", cfg.Branches["master"].Name) + s.Equal("origin", cfg.Branches["master"].Remote) + s.Equal(plumbing.ReferenceName("refs/heads/master"), cfg.Branches["master"].Merge) head, err = r.Reference(plumbing.HEAD, false) - c.Assert(err, IsNil) - c.Assert(head, NotNil) - c.Assert(head.Type(), Equals, plumbing.SymbolicReference) - c.Assert(head.Target().String(), Equals, "refs/heads/master") + s.NoError(err) + s.NotNil(head) + s.Equal(plumbing.SymbolicReference, head.Type()) + s.Equal("refs/heads/master", head.Target().String()) branch, err := r.Reference(head.Target(), false) - c.Assert(err, IsNil) - c.Assert(branch, NotNil) - c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") + s.NoError(err) + s.NotNil(branch) + s.Equal("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", branch.Hash().String()) } -func (s *RepositorySuite) TestCloneSingleTag(c *C) { +func (s *RepositorySuite) TestCloneSingleTag() { r, _ := Init(memory.NewStorage(), nil) url := s.GetLocalRepositoryURL( @@ -1523,72 +1550,72 @@ func (s *RepositorySuite) TestCloneSingleTag(c *C) { SingleBranch: true, ReferenceName: plumbing.ReferenceName("refs/tags/commit-tag"), }) - c.Assert(err, IsNil) + s.NoError(err) branch, err := r.Reference("refs/tags/commit-tag", false) - c.Assert(err, IsNil) - c.Assert(branch, NotNil) + s.NoError(err) + s.NotNil(branch) conf, err := r.Config() - c.Assert(err, IsNil) + s.NoError(err) originRemote := conf.Remotes["origin"] - c.Assert(originRemote, NotNil) - c.Assert(originRemote.Fetch, HasLen, 1) - c.Assert(originRemote.Fetch[0].String(), Equals, "+refs/tags/commit-tag:refs/tags/commit-tag") + s.NotNil(originRemote) + s.Len(originRemote.Fetch, 1) + s.Equal("+refs/tags/commit-tag:refs/tags/commit-tag", originRemote.Fetch[0].String()) } -func (s *RepositorySuite) TestCloneDetachedHEAD(c *C) { +func (s *RepositorySuite) TestCloneDetachedHEAD() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), ReferenceName: plumbing.ReferenceName("refs/tags/v1.0.0"), }) - c.Assert(err, IsNil) + s.NoError(err) cfg, err := r.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Branches, HasLen, 0) + s.NoError(err) + s.Len(cfg.Branches, 0) head, err := r.Reference(plumbing.HEAD, false) - c.Assert(err, IsNil) - c.Assert(head, NotNil) - c.Assert(head.Type(), Equals, plumbing.HashReference) - c.Assert(head.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") + s.NoError(err) + s.NotNil(head) + s.Equal(plumbing.HashReference, head.Type()) + s.Equal("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", head.Hash().String()) count := 0 objects, err := r.Objects() - c.Assert(err, IsNil) + s.NoError(err) objects.ForEach(func(object.Object) error { count++; return nil }) - c.Assert(count, Equals, 28) + s.Equal(28, count) } -func (s *RepositorySuite) TestCloneDetachedHEADAndSingle(c *C) { +func (s *RepositorySuite) TestCloneDetachedHEADAndSingle() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), ReferenceName: plumbing.ReferenceName("refs/tags/v1.0.0"), SingleBranch: true, }) - c.Assert(err, IsNil) + s.NoError(err) cfg, err := r.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Branches, HasLen, 0) + s.NoError(err) + s.Len(cfg.Branches, 0) head, err := r.Reference(plumbing.HEAD, false) - c.Assert(err, IsNil) - c.Assert(head, NotNil) - c.Assert(head.Type(), Equals, plumbing.HashReference) - c.Assert(head.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") + s.NoError(err) + s.NotNil(head) + s.Equal(plumbing.HashReference, head.Type()) + s.Equal("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", head.Hash().String()) count := 0 objects, err := r.Objects() - c.Assert(err, IsNil) + s.NoError(err) objects.ForEach(func(object.Object) error { count++; return nil }) - c.Assert(count, Equals, 28) + s.Equal(28, count) } -func (s *RepositorySuite) TestCloneDetachedHEADAndShallow(c *C) { +func (s *RepositorySuite) TestCloneDetachedHEADAndShallow() { r, _ := Init(memory.NewStorage(), memfs.New()) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), @@ -1596,91 +1623,103 @@ func (s *RepositorySuite) TestCloneDetachedHEADAndShallow(c *C) { Depth: 1, }) - c.Assert(err, IsNil) + s.NoError(err) cfg, err := r.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Branches, HasLen, 0) + s.NoError(err) + s.Len(cfg.Branches, 0) head, err := r.Reference(plumbing.HEAD, false) - c.Assert(err, IsNil) - c.Assert(head, NotNil) - c.Assert(head.Type(), Equals, plumbing.HashReference) - c.Assert(head.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") + s.NoError(err) + s.NotNil(head) + s.Equal(plumbing.HashReference, head.Type()) + s.Equal("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", head.Hash().String()) count := 0 objects, err := r.Objects() - c.Assert(err, IsNil) + s.NoError(err) objects.ForEach(func(object.Object) error { count++; return nil }) - c.Assert(count, Equals, 15) + s.Equal(15, count) } -func (s *RepositorySuite) TestCloneDetachedHEADAnnotatedTag(c *C) { +func (s *RepositorySuite) TestCloneDetachedHEADAnnotatedTag() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetLocalRepositoryURL(fixtures.ByTag("tags").One()), ReferenceName: plumbing.ReferenceName("refs/tags/annotated-tag"), }) - c.Assert(err, IsNil) + s.NoError(err) cfg, err := r.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Branches, HasLen, 0) + s.NoError(err) + s.Len(cfg.Branches, 0) head, err := r.Reference(plumbing.HEAD, false) - c.Assert(err, IsNil) - c.Assert(head, NotNil) - c.Assert(head.Type(), Equals, plumbing.HashReference) - c.Assert(head.Hash().String(), Equals, "f7b877701fbf855b44c0a9e86f3fdce2c298b07f") + s.NoError(err) + s.NotNil(head) + s.Equal(plumbing.HashReference, head.Type()) + s.Equal("f7b877701fbf855b44c0a9e86f3fdce2c298b07f", head.Hash().String()) count := 0 objects, err := r.Objects() - c.Assert(err, IsNil) + s.NoError(err) objects.ForEach(func(object.Object) error { count++; return nil }) - c.Assert(count, Equals, 7) + s.Equal(7, count) } -func (s *RepositorySuite) TestPush(c *C) { - url, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestCloneWithFilter() { + r, _ := Init(memory.NewStorage(), nil) + + err := r.clone(context.Background(), &CloneOptions{ + URL: "https://github.com/git-fixtures/basic.git", + Filter: packp.FilterTreeDepth(0), + }) + s.NoError(err) + blob, err := r.BlobObject(plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492")) + s.NotNil(err) + s.Nil(blob) +} +func (s *RepositorySuite) TestPush() { + url, err := os.MkdirTemp("", "") + s.NoError(err) server, err := PlainInit(url, true) - c.Assert(err, IsNil) + s.NoError(err) _, err = s.Repository.CreateRemote(&config.RemoteConfig{ Name: "test", URLs: []string{url}, }) - c.Assert(err, IsNil) + s.NoError(err) err = s.Repository.Push(&PushOptions{ RemoteName: "test", }) - c.Assert(err, IsNil) + s.NoError(err) - AssertReferences(c, server, map[string]string{ + AssertReferences(s.T(), server, map[string]string{ "refs/heads/master": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "refs/heads/branch": "e8d3ffab552895c19b9fcf7aa264d277cde33881", }) - AssertReferences(c, s.Repository, map[string]string{ + AssertReferences(s.T(), s.Repository, map[string]string{ "refs/remotes/test/master": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "refs/remotes/test/branch": "e8d3ffab552895c19b9fcf7aa264d277cde33881", }) } -func (s *RepositorySuite) TestPushContext(c *C) { - url, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestPushContext() { + url, err := os.MkdirTemp("", "") + s.NoError(err) - _, err := PlainInit(url, true) - c.Assert(err, IsNil) + _, err = PlainInit(url, true) + s.NoError(err) _, err = s.Repository.CreateRemote(&config.RemoteConfig{ Name: "foo", URLs: []string{url}, }) - c.Assert(err, IsNil) + s.NoError(err) ctx, cancel := context.WithCancel(context.Background()) cancel() @@ -1688,124 +1727,123 @@ func (s *RepositorySuite) TestPushContext(c *C) { err = s.Repository.PushContext(ctx, &PushOptions{ RemoteName: "foo", }) - c.Assert(err, NotNil) + s.NotNil(err) } // installPreReceiveHook installs a pre-receive hook in the .git // directory at path which prints message m before exiting // successfully. -func installPreReceiveHook(c *C, fs billy.Filesystem, path, m string) { +func installPreReceiveHook(s *RepositorySuite, fs billy.Filesystem, path, m string) { hooks := fs.Join(path, "hooks") err := fs.MkdirAll(hooks, 0777) - c.Assert(err, IsNil) + s.NoError(err) err = util.WriteFile(fs, fs.Join(hooks, "pre-receive"), preReceiveHook(m), 0777) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *RepositorySuite) TestPushWithProgress(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *RepositorySuite) TestPushWithProgress() { + fs := s.TemporalFilesystem() path, err := util.TempDir(fs, "", "") - c.Assert(err, IsNil) + s.NoError(err) url := fs.Join(fs.Root(), path) server, err := PlainInit(url, true) - c.Assert(err, IsNil) + s.NoError(err) m := "Receiving..." - installPreReceiveHook(c, fs, path, m) + installPreReceiveHook(s, fs, path, m) _, err = s.Repository.CreateRemote(&config.RemoteConfig{ Name: "bar", URLs: []string{url}, }) - c.Assert(err, IsNil) + s.NoError(err) var p bytes.Buffer err = s.Repository.Push(&PushOptions{ RemoteName: "bar", Progress: &p, }) - c.Assert(err, IsNil) + s.NoError(err) - AssertReferences(c, server, map[string]string{ + AssertReferences(s.T(), server, map[string]string{ "refs/heads/master": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "refs/heads/branch": "e8d3ffab552895c19b9fcf7aa264d277cde33881", }) - c.Assert((&p).Bytes(), DeepEquals, []byte(m)) + s.Equal([]byte(m), (&p).Bytes()) } -func (s *RepositorySuite) TestPushDepth(c *C) { - url, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestPushDepth() { + url, err := os.MkdirTemp("", "") + s.NoError(err) server, err := PlainClone(url, true, &CloneOptions{ URL: fixtures.Basic().One().DotGit().Root(), }) - c.Assert(err, IsNil) + s.NoError(err) r, err := Clone(memory.NewStorage(), memfs.New(), &CloneOptions{ URL: url, Depth: 1, }) - c.Assert(err, IsNil) + s.NoError(err) err = util.WriteFile(r.wt, "foo", nil, 0755) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Add("foo") - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Commit("foo", &CommitOptions{ Author: defaultSignature(), Committer: defaultSignature(), }) - c.Assert(err, IsNil) + s.NoError(err) err = r.Push(&PushOptions{}) - c.Assert(err, IsNil) + s.NoError(err) - AssertReferences(c, server, map[string]string{ + AssertReferences(s.T(), server, map[string]string{ "refs/heads/master": hash.String(), }) - AssertReferences(c, r, map[string]string{ + AssertReferences(s.T(), r, map[string]string{ "refs/remotes/origin/master": hash.String(), }) } -func (s *RepositorySuite) TestPushNonExistentRemote(c *C) { +func (s *RepositorySuite) TestPushNonExistentRemote() { srcFs := fixtures.Basic().One().DotGit() sto := filesystem.NewStorage(srcFs, cache.NewObjectLRUDefault()) r, err := Open(sto, srcFs) - c.Assert(err, IsNil) + s.NoError(err) err = r.Push(&PushOptions{RemoteName: "myremote"}) - c.Assert(err, ErrorMatches, ".*remote not found.*") + s.ErrorContains(err, "remote not found") } -func (s *RepositorySuite) TestLog(c *C) { +func (s *RepositorySuite) TestLog() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) cIter, err := r.Log(&LogOptions{ From: plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"), }) - c.Assert(err, IsNil) + s.NoError(err) commitOrder := []plumbing.Hash{ plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"), @@ -1814,35 +1852,35 @@ func (s *RepositorySuite) TestLog(c *C) { for _, o := range commitOrder { commit, err := cIter.Next() - c.Assert(err, IsNil) - c.Assert(commit.Hash, Equals, o) + s.NoError(err) + s.Equal(o, commit.Hash) } _, err = cIter.Next() - c.Assert(err, Equals, io.EOF) + s.ErrorIs(err, io.EOF) } -func (s *RepositorySuite) TestLogAll(c *C) { +func (s *RepositorySuite) TestLogAll() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) rIter, err := r.Storer.IterReferences() - c.Assert(err, IsNil) + s.NoError(err) refCount := 0 err = rIter.ForEach(func(ref *plumbing.Reference) error { refCount++ return nil }) - c.Assert(err, IsNil) - c.Assert(refCount, Equals, 5) + s.NoError(err) + s.Equal(5, refCount) cIter, err := r.Log(&LogOptions{ All: true, }) - c.Assert(err, IsNil) + s.NoError(err) commitOrder := []plumbing.Hash{ plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"), @@ -1858,79 +1896,79 @@ func (s *RepositorySuite) TestLogAll(c *C) { for _, o := range commitOrder { commit, err := cIter.Next() - c.Assert(err, IsNil) - c.Assert(commit.Hash, Equals, o) + s.NoError(err) + s.Equal(o, commit.Hash) } _, err = cIter.Next() - c.Assert(err, Equals, io.EOF) + s.ErrorIs(err, io.EOF) cIter.Close() } -func (s *RepositorySuite) TestLogAllMissingReferences(c *C) { +func (s *RepositorySuite) TestLogAllMissingReferences() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) err = r.Storer.RemoveReference(plumbing.HEAD) - c.Assert(err, IsNil) + s.NoError(err) rIter, err := r.Storer.IterReferences() - c.Assert(err, IsNil) + s.NoError(err) refCount := 0 err = rIter.ForEach(func(ref *plumbing.Reference) error { refCount++ return nil }) - c.Assert(err, IsNil) - c.Assert(refCount, Equals, 4) + s.NoError(err) + s.Equal(4, refCount) err = r.Storer.SetReference(plumbing.NewHashReference(plumbing.ReferenceName("DUMMY"), plumbing.NewHash("DUMMY"))) - c.Assert(err, IsNil) + s.NoError(err) rIter, err = r.Storer.IterReferences() - c.Assert(err, IsNil) + s.NoError(err) refCount = 0 err = rIter.ForEach(func(ref *plumbing.Reference) error { refCount++ return nil }) - c.Assert(err, IsNil) - c.Assert(refCount, Equals, 5) + s.NoError(err) + s.Equal(5, refCount) cIter, err := r.Log(&LogOptions{ All: true, }) - c.Assert(cIter, NotNil) - c.Assert(err, IsNil) + s.NotNil(cIter) + s.NoError(err) cCount := 0 cIter.ForEach(func(c *object.Commit) error { cCount++ return nil }) - c.Assert(cCount, Equals, 9) + s.Equal(9, cCount) _, err = cIter.Next() - c.Assert(err, Equals, io.EOF) + s.ErrorIs(err, io.EOF) cIter.Close() } -func (s *RepositorySuite) TestLogAllOrderByTime(c *C) { +func (s *RepositorySuite) TestLogAllOrderByTime() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) cIter, err := r.Log(&LogOptions{ Order: LogOrderCommitterTime, All: true, }) - c.Assert(err, IsNil) + s.NoError(err) commitOrder := []plumbing.Hash{ plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"), @@ -1946,25 +1984,25 @@ func (s *RepositorySuite) TestLogAllOrderByTime(c *C) { for _, o := range commitOrder { commit, err := cIter.Next() - c.Assert(err, IsNil) - c.Assert(commit.Hash, Equals, o) + s.NoError(err) + s.Equal(o, commit.Hash) } _, err = cIter.Next() - c.Assert(err, Equals, io.EOF) + s.ErrorIs(err, io.EOF) cIter.Close() } -func (s *RepositorySuite) TestLogHead(c *C) { +func (s *RepositorySuite) TestLogHead() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) cIter, err := r.Log(&LogOptions{}) - c.Assert(err, IsNil) + s.NoError(err) commitOrder := []plumbing.Hash{ plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"), @@ -1979,39 +2017,39 @@ func (s *RepositorySuite) TestLogHead(c *C) { for _, o := range commitOrder { commit, err := cIter.Next() - c.Assert(err, IsNil) - c.Assert(commit.Hash, Equals, o) + s.NoError(err) + s.Equal(o, commit.Hash) } _, err = cIter.Next() - c.Assert(err, Equals, io.EOF) + s.ErrorIs(err, io.EOF) } -func (s *RepositorySuite) TestLogError(c *C) { +func (s *RepositorySuite) TestLogError() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) _, err = r.Log(&LogOptions{ From: plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), }) - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *RepositorySuite) TestLogFileNext(c *C) { +func (s *RepositorySuite) TestLogFileNext() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) fileName := "vendor/foo.go" cIter, err := r.Log(&LogOptions{FileName: &fileName}) - c.Assert(err, IsNil) + s.NoError(err) commitOrder := []plumbing.Hash{ plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"), @@ -2019,24 +2057,24 @@ func (s *RepositorySuite) TestLogFileNext(c *C) { for _, o := range commitOrder { commit, err := cIter.Next() - c.Assert(err, IsNil) - c.Assert(commit.Hash, Equals, o) + s.NoError(err) + s.Equal(o, commit.Hash) } _, err = cIter.Next() - c.Assert(err, Equals, io.EOF) + s.ErrorIs(err, io.EOF) } -func (s *RepositorySuite) TestLogFileForEach(c *C) { +func (s *RepositorySuite) TestLogFileForEach() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) fileName := "php/crappy.php" cIter, err := r.Log(&LogOptions{FileName: &fileName}) - c.Assert(err, IsNil) + s.NoError(err) defer cIter.Close() commitOrder := []plumbing.Hash{ @@ -2046,42 +2084,42 @@ func (s *RepositorySuite) TestLogFileForEach(c *C) { expectedIndex := 0 err = cIter.ForEach(func(commit *object.Commit) error { expectedCommitHash := commitOrder[expectedIndex] - c.Assert(commit.Hash.String(), Equals, expectedCommitHash.String()) + s.Equal(expectedCommitHash.String(), commit.Hash.String()) expectedIndex++ return nil }) - c.Assert(err, IsNil) - c.Assert(expectedIndex, Equals, 1) + s.NoError(err) + s.Equal(1, expectedIndex) } -func (s *RepositorySuite) TestLogNonHeadFile(c *C) { +func (s *RepositorySuite) TestLogNonHeadFile() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) fileName := "README" cIter, err := r.Log(&LogOptions{FileName: &fileName}) - c.Assert(err, IsNil) + s.NoError(err) defer cIter.Close() _, err = cIter.Next() - c.Assert(err, Equals, io.EOF) + s.ErrorIs(err, io.EOF) } -func (s *RepositorySuite) TestLogAllFileForEach(c *C) { +func (s *RepositorySuite) TestLogAllFileForEach() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) fileName := "README" cIter, err := r.Log(&LogOptions{FileName: &fileName, All: true}) - c.Assert(err, IsNil) + s.NoError(err) defer cIter.Close() commitOrder := []plumbing.Hash{ @@ -2091,45 +2129,45 @@ func (s *RepositorySuite) TestLogAllFileForEach(c *C) { expectedIndex := 0 err = cIter.ForEach(func(commit *object.Commit) error { expectedCommitHash := commitOrder[expectedIndex] - c.Assert(commit.Hash.String(), Equals, expectedCommitHash.String()) + s.Equal(expectedCommitHash.String(), commit.Hash.String()) expectedIndex++ return nil }) - c.Assert(err, IsNil) - c.Assert(expectedIndex, Equals, 1) + s.NoError(err) + s.Equal(1, expectedIndex) } -func (s *RepositorySuite) TestLogInvalidFile(c *C) { +func (s *RepositorySuite) TestLogInvalidFile() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) // Throwing in a file that does not exist fileName := "vendor/foo12.go" cIter, err := r.Log(&LogOptions{FileName: &fileName}) // Not raising an error since `git log -- vendor/foo12.go` responds silently - c.Assert(err, IsNil) + s.NoError(err) defer cIter.Close() _, err = cIter.Next() - c.Assert(err, Equals, io.EOF) + s.ErrorIs(err, io.EOF) } -func (s *RepositorySuite) TestLogFileInitialCommit(c *C) { +func (s *RepositorySuite) TestLogFileInitialCommit() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) fileName := "LICENSE" cIter, err := r.Log(&LogOptions{ Order: LogOrderCommitterTime, FileName: &fileName, }) - c.Assert(err, IsNil) + s.NoError(err) defer cIter.Close() commitOrder := []plumbing.Hash{ @@ -2139,20 +2177,20 @@ func (s *RepositorySuite) TestLogFileInitialCommit(c *C) { expectedIndex := 0 err = cIter.ForEach(func(commit *object.Commit) error { expectedCommitHash := commitOrder[expectedIndex] - c.Assert(commit.Hash.String(), Equals, expectedCommitHash.String()) + s.Equal(expectedCommitHash.String(), commit.Hash.String()) expectedIndex++ return nil }) - c.Assert(err, IsNil) - c.Assert(expectedIndex, Equals, 1) + s.NoError(err) + s.Equal(1, expectedIndex) } -func (s *RepositorySuite) TestLogFileWithOtherParamsFail(c *C) { +func (s *RepositorySuite) TestLogFileWithOtherParamsFail() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) fileName := "vendor/foo.go" cIter, err := r.Log(&LogOptions{ @@ -2160,19 +2198,19 @@ func (s *RepositorySuite) TestLogFileWithOtherParamsFail(c *C) { FileName: &fileName, From: plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"), }) - c.Assert(err, IsNil) + s.NoError(err) defer cIter.Close() _, iterErr := cIter.Next() - c.Assert(iterErr, Equals, io.EOF) + s.Equal(io.EOF, iterErr) } -func (s *RepositorySuite) TestLogFileWithOtherParamsPass(c *C) { +func (s *RepositorySuite) TestLogFileWithOtherParamsPass() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) fileName := "LICENSE" cIter, err := r.Log(&LogOptions{ @@ -2180,13 +2218,13 @@ func (s *RepositorySuite) TestLogFileWithOtherParamsPass(c *C) { FileName: &fileName, From: plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"), }) - c.Assert(err, IsNil) + s.NoError(err) commitVal, iterErr := cIter.Next() - c.Assert(iterErr, Equals, nil) - c.Assert(commitVal.Hash.String(), Equals, "b029517f6300c2da0f4b651b8642506cd6aaf45d") + s.Equal(nil, iterErr) + s.Equal("b029517f6300c2da0f4b651b8642506cd6aaf45d", commitVal.Hash.String()) _, iterErr = cIter.Next() - c.Assert(iterErr, Equals, io.EOF) + s.Equal(io.EOF, iterErr) } type mockErrCommitIter struct{} @@ -2194,13 +2232,14 @@ type mockErrCommitIter struct{} func (m *mockErrCommitIter) Next() (*object.Commit, error) { return nil, errors.New("mock next error") } + func (m *mockErrCommitIter) ForEach(func(*object.Commit) error) error { return errors.New("mock foreach error") } func (m *mockErrCommitIter) Close() {} -func (s *RepositorySuite) TestLogFileWithError(c *C) { +func (s *RepositorySuite) TestLogFileWithError() { fileName := "README" cIter := object.NewCommitFileIterFromIter(fileName, &mockErrCommitIter{}, false) defer cIter.Close() @@ -2208,10 +2247,10 @@ func (s *RepositorySuite) TestLogFileWithError(c *C) { err := cIter.ForEach(func(commit *object.Commit) error { return nil }) - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *RepositorySuite) TestLogPathWithError(c *C) { +func (s *RepositorySuite) TestLogPathWithError() { fileName := "README" pathIter := func(path string) bool { return path == fileName @@ -2222,10 +2261,10 @@ func (s *RepositorySuite) TestLogPathWithError(c *C) { err := cIter.ForEach(func(commit *object.Commit) error { return nil }) - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *RepositorySuite) TestLogPathRegexpWithError(c *C) { +func (s *RepositorySuite) TestLogPathRegexpWithError() { pathRE := regexp.MustCompile("R.*E") pathIter := func(path string) bool { return pathRE.MatchString(path) @@ -2236,10 +2275,10 @@ func (s *RepositorySuite) TestLogPathRegexpWithError(c *C) { err := cIter.ForEach(func(commit *object.Commit) error { return nil }) - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *RepositorySuite) TestLogPathFilterRegexp(c *C) { +func (s *RepositorySuite) TestLogPathFilterRegexp() { pathRE := regexp.MustCompile(`.*\.go`) pathIter := func(path string) bool { return pathRE.MatchString(path) @@ -2249,7 +2288,7 @@ func (s *RepositorySuite) TestLogPathFilterRegexp(c *C) { err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) expectedCommitIDs := []string{ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", @@ -2261,32 +2300,31 @@ func (s *RepositorySuite) TestLogPathFilterRegexp(c *C) { PathFilter: pathIter, From: plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"), }) - c.Assert(err, IsNil) + s.NoError(err) defer cIter.Close() cIter.ForEach(func(commit *object.Commit) error { commitIDs = append(commitIDs, commit.ID().String()) return nil }) - c.Assert( - strings.Join(commitIDs, ", "), - Equals, + s.Equal( strings.Join(expectedCommitIDs, ", "), + strings.Join(commitIDs, ", "), ) } -func (s *RepositorySuite) TestLogLimitNext(c *C) { +func (s *RepositorySuite) TestLogLimitNext() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) since := time.Date(2015, 4, 1, 0, 0, 0, 0, time.UTC) cIter, err := r.Log(&LogOptions{Since: &since}) - c.Assert(err, IsNil) + s.NoError(err) commitOrder := []plumbing.Hash{ plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"), @@ -2294,25 +2332,25 @@ func (s *RepositorySuite) TestLogLimitNext(c *C) { for _, o := range commitOrder { commit, err := cIter.Next() - c.Assert(err, IsNil) - c.Assert(commit.Hash, Equals, o) + s.NoError(err) + s.Equal(o, commit.Hash) } _, err = cIter.Next() - c.Assert(err, Equals, io.EOF) + s.ErrorIs(err, io.EOF) } -func (s *RepositorySuite) TestLogLimitForEach(c *C) { +func (s *RepositorySuite) TestLogLimitForEach() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) since := time.Date(2015, 3, 31, 11, 54, 0, 0, time.UTC) until := time.Date(2015, 4, 1, 0, 0, 0, 0, time.UTC) cIter, err := r.Log(&LogOptions{Since: &since, Until: &until}) - c.Assert(err, IsNil) + s.NoError(err) defer cIter.Close() commitOrder := []plumbing.Hash{ @@ -2322,26 +2360,26 @@ func (s *RepositorySuite) TestLogLimitForEach(c *C) { expectedIndex := 0 err = cIter.ForEach(func(commit *object.Commit) error { expectedCommitHash := commitOrder[expectedIndex] - c.Assert(commit.Hash.String(), Equals, expectedCommitHash.String()) + s.Equal(expectedCommitHash.String(), commit.Hash.String()) expectedIndex++ return nil }) - c.Assert(err, IsNil) - c.Assert(expectedIndex, Equals, 1) + s.NoError(err) + s.Equal(1, expectedIndex) } -func (s *RepositorySuite) TestLogAllLimitForEach(c *C) { +func (s *RepositorySuite) TestLogAllLimitForEach() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) since := time.Date(2015, 3, 31, 11, 54, 0, 0, time.UTC) until := time.Date(2015, 4, 1, 0, 0, 0, 0, time.UTC) cIter, err := r.Log(&LogOptions{Since: &since, Until: &until, All: true}) - c.Assert(err, IsNil) + s.NoError(err) defer cIter.Close() commitOrder := []plumbing.Hash{ @@ -2352,20 +2390,20 @@ func (s *RepositorySuite) TestLogAllLimitForEach(c *C) { expectedIndex := 0 err = cIter.ForEach(func(commit *object.Commit) error { expectedCommitHash := commitOrder[expectedIndex] - c.Assert(commit.Hash.String(), Equals, expectedCommitHash.String()) + s.Equal(expectedCommitHash.String(), commit.Hash.String()) expectedIndex++ return nil }) - c.Assert(err, IsNil) - c.Assert(expectedIndex, Equals, 2) + s.NoError(err) + s.Equal(2, expectedIndex) } -func (s *RepositorySuite) TestLogLimitWithOtherParamsFail(c *C) { +func (s *RepositorySuite) TestLogLimitWithOtherParamsFail() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) since := time.Date(2015, 3, 31, 11, 54, 0, 0, time.UTC) cIter, err := r.Log(&LogOptions{ @@ -2373,19 +2411,19 @@ func (s *RepositorySuite) TestLogLimitWithOtherParamsFail(c *C) { Since: &since, From: plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"), }) - c.Assert(err, IsNil) + s.NoError(err) defer cIter.Close() _, iterErr := cIter.Next() - c.Assert(iterErr, Equals, io.EOF) + s.Equal(io.EOF, iterErr) } -func (s *RepositorySuite) TestLogLimitWithOtherParamsPass(c *C) { +func (s *RepositorySuite) TestLogLimitWithOtherParamsPass() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) until := time.Date(2015, 3, 31, 11, 43, 0, 0, time.UTC) cIter, err := r.Log(&LogOptions{ @@ -2393,65 +2431,65 @@ func (s *RepositorySuite) TestLogLimitWithOtherParamsPass(c *C) { Until: &until, From: plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"), }) - c.Assert(err, IsNil) + s.NoError(err) defer cIter.Close() commitVal, iterErr := cIter.Next() - c.Assert(iterErr, Equals, nil) - c.Assert(commitVal.Hash.String(), Equals, "b029517f6300c2da0f4b651b8642506cd6aaf45d") + s.Equal(nil, iterErr) + s.Equal("b029517f6300c2da0f4b651b8642506cd6aaf45d", commitVal.Hash.String()) _, iterErr = cIter.Next() - c.Assert(iterErr, Equals, io.EOF) + s.Equal(io.EOF, iterErr) } -func (s *RepositorySuite) TestConfigScoped(c *C) { +func (s *RepositorySuite) TestConfigScoped() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) cfg, err := r.ConfigScoped(config.LocalScope) - c.Assert(err, IsNil) - c.Assert(cfg.User.Email, Equals, "") + s.NoError(err) + s.Equal("", cfg.User.Email) cfg, err = r.ConfigScoped(config.SystemScope) - c.Assert(err, IsNil) - c.Assert(cfg.User.Email, Not(Equals), "") + s.NoError(err) + s.NotEqual("", cfg.User.Email) } -func (s *RepositorySuite) TestCommit(c *C) { +func (s *RepositorySuite) TestCommit() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) hash := plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47") commit, err := r.CommitObject(hash) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(commit.Hash.IsZero(), Equals, false) - c.Assert(commit.Hash, Equals, commit.ID()) - c.Assert(commit.Hash, Equals, hash) - c.Assert(commit.Type(), Equals, plumbing.CommitObject) + s.False(commit.Hash.IsZero()) + s.Equal(commit.ID(), commit.Hash) + s.Equal(hash, commit.Hash) + s.Equal(plumbing.CommitObject, commit.Type()) tree, err := commit.Tree() - c.Assert(err, IsNil) - c.Assert(tree.Hash.IsZero(), Equals, false) + s.NoError(err) + s.False(tree.Hash.IsZero()) - c.Assert(commit.Author.Email, Equals, "daniel@lordran.local") + s.Equal("daniel@lordran.local", commit.Author.Email) } -func (s *RepositorySuite) TestCommits(c *C) { +func (s *RepositorySuite) TestCommits() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()}) - c.Assert(err, IsNil) + s.NoError(err) count := 0 commits, err := r.CommitObjects() - c.Assert(err, IsNil) + s.NoError(err) for { commit, err := commits.Next() if err != nil { @@ -2459,44 +2497,44 @@ func (s *RepositorySuite) TestCommits(c *C) { } count++ - c.Assert(commit.Hash.IsZero(), Equals, false) - c.Assert(commit.Hash, Equals, commit.ID()) - c.Assert(commit.Type(), Equals, plumbing.CommitObject) + s.False(commit.Hash.IsZero()) + s.Equal(commit.ID(), commit.Hash) + s.Equal(plumbing.CommitObject, commit.Type()) } - c.Assert(count, Equals, 9) + s.Equal(9, count) } -func (s *RepositorySuite) TestBlob(c *C) { +func (s *RepositorySuite) TestBlob() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) blob, err := r.BlobObject(plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47")) - c.Assert(err, NotNil) - c.Assert(blob, IsNil) + s.NotNil(err) + s.Nil(blob) blobHash := plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492") blob, err = r.BlobObject(blobHash) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(blob.Hash.IsZero(), Equals, false) - c.Assert(blob.Hash, Equals, blob.ID()) - c.Assert(blob.Hash, Equals, blobHash) - c.Assert(blob.Type(), Equals, plumbing.BlobObject) + s.False(blob.Hash.IsZero()) + s.Equal(blob.ID(), blob.Hash) + s.Equal(blobHash, blob.Hash) + s.Equal(plumbing.BlobObject, blob.Type()) } -func (s *RepositorySuite) TestBlobs(c *C) { +func (s *RepositorySuite) TestBlobs() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()}) - c.Assert(err, IsNil) + s.NoError(err) count := 0 blobs, err := r.BlobObjects() - c.Assert(err, IsNil) + s.NoError(err) for { blob, err := blobs.Next() if err != nil { @@ -2504,105 +2542,105 @@ func (s *RepositorySuite) TestBlobs(c *C) { } count++ - c.Assert(blob.Hash.IsZero(), Equals, false) - c.Assert(blob.Hash, Equals, blob.ID()) - c.Assert(blob.Type(), Equals, plumbing.BlobObject) + s.False(blob.Hash.IsZero()) + s.Equal(blob.ID(), blob.Hash) + s.Equal(plumbing.BlobObject, blob.Type()) } - c.Assert(count, Equals, 10) + s.Equal(10, count) } -func (s *RepositorySuite) TestTagObject(c *C) { +func (s *RepositorySuite) TestTagObject() { url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(), ) r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: url}) - c.Assert(err, IsNil) + s.NoError(err) hash := plumbing.NewHash("ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc") tag, err := r.TagObject(hash) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(tag.Hash.IsZero(), Equals, false) - c.Assert(tag.Hash, Equals, hash) - c.Assert(tag.Type(), Equals, plumbing.TagObject) + s.False(tag.Hash.IsZero()) + s.Equal(hash, tag.Hash) + s.Equal(plumbing.TagObject, tag.Type()) } -func (s *RepositorySuite) TestTags(c *C) { +func (s *RepositorySuite) TestTags() { url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(), ) r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: url}) - c.Assert(err, IsNil) + s.NoError(err) count := 0 tags, err := r.Tags() - c.Assert(err, IsNil) + s.NoError(err) tags.ForEach(func(tag *plumbing.Reference) error { count++ - c.Assert(tag.Hash().IsZero(), Equals, false) - c.Assert(tag.Name().IsTag(), Equals, true) + s.False(tag.Hash().IsZero()) + s.True(tag.Name().IsTag()) return nil }) - c.Assert(count, Equals, 5) + s.Equal(5, count) } -func (s *RepositorySuite) TestCreateTagLightweight(c *C) { +func (s *RepositorySuite) TestCreateTagLightweight() { url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(), ) r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: url}) - c.Assert(err, IsNil) + s.NoError(err) expected, err := r.Head() - c.Assert(err, IsNil) + s.NoError(err) ref, err := r.CreateTag("foobar", expected.Hash(), nil) - c.Assert(err, IsNil) - c.Assert(ref, NotNil) + s.NoError(err) + s.NotNil(ref) actual, err := r.Tag("foobar") - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(expected.Hash(), Equals, actual.Hash()) + s.Equal(actual.Hash(), expected.Hash()) } -func (s *RepositorySuite) TestCreateTagLightweightExists(c *C) { +func (s *RepositorySuite) TestCreateTagLightweightExists() { url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(), ) r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: url}) - c.Assert(err, IsNil) + s.NoError(err) expected, err := r.Head() - c.Assert(err, IsNil) + s.NoError(err) ref, err := r.CreateTag("lightweight-tag", expected.Hash(), nil) - c.Assert(ref, IsNil) - c.Assert(err, Equals, ErrTagExists) + s.Nil(ref) + s.ErrorIs(err, ErrTagExists) } -func (s *RepositorySuite) TestCreateTagAnnotated(c *C) { +func (s *RepositorySuite) TestCreateTagAnnotated() { url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(), ) r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: url}) - c.Assert(err, IsNil) + s.NoError(err) h, err := r.Head() - c.Assert(err, IsNil) + s.NoError(err) expectedHash := h.Hash() @@ -2610,291 +2648,289 @@ func (s *RepositorySuite) TestCreateTagAnnotated(c *C) { Tagger: defaultSignature(), Message: "foo bar baz qux", }) - c.Assert(err, IsNil) + s.NoError(err) tag, err := r.Tag("foobar") - c.Assert(err, IsNil) + s.NoError(err) obj, err := r.TagObject(tag.Hash()) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(ref, DeepEquals, tag) - c.Assert(obj.Hash, Equals, ref.Hash()) - c.Assert(obj.Type(), Equals, plumbing.TagObject) - c.Assert(obj.Target, Equals, expectedHash) + s.Equal(tag, ref) + s.Equal(ref.Hash(), obj.Hash) + s.Equal(plumbing.TagObject, obj.Type()) + s.Equal(expectedHash, obj.Target) } -func (s *RepositorySuite) TestCreateTagAnnotatedBadOpts(c *C) { +func (s *RepositorySuite) TestCreateTagAnnotatedBadOpts() { url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(), ) r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: url}) - c.Assert(err, IsNil) + s.NoError(err) h, err := r.Head() - c.Assert(err, IsNil) + s.NoError(err) expectedHash := h.Hash() ref, err := r.CreateTag("foobar", expectedHash, &CreateTagOptions{}) - c.Assert(ref, IsNil) - c.Assert(err, Equals, ErrMissingMessage) + s.Nil(ref) + s.ErrorIs(err, ErrMissingMessage) } -func (s *RepositorySuite) TestCreateTagAnnotatedBadHash(c *C) { +func (s *RepositorySuite) TestCreateTagAnnotatedBadHash() { url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(), ) r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: url}) - c.Assert(err, IsNil) + s.NoError(err) ref, err := r.CreateTag("foobar", plumbing.ZeroHash, &CreateTagOptions{ Tagger: defaultSignature(), Message: "foo bar baz qux", }) - c.Assert(ref, IsNil) - c.Assert(err, Equals, plumbing.ErrObjectNotFound) + s.Nil(ref) + s.ErrorIs(err, plumbing.ErrObjectNotFound) } -func (s *RepositorySuite) TestCreateTagSigned(c *C) { +func (s *RepositorySuite) TestCreateTagSigned() { url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(), ) r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: url}) - c.Assert(err, IsNil) + s.NoError(err) h, err := r.Head() - c.Assert(err, IsNil) + s.NoError(err) - key := commitSignKey(c, true) + key := commitSignKey(s.T(), true) _, err = r.CreateTag("foobar", h.Hash(), &CreateTagOptions{ Tagger: defaultSignature(), Message: "foo bar baz qux", SignKey: key, }) - c.Assert(err, IsNil) + s.NoError(err) tag, err := r.Tag("foobar") - c.Assert(err, IsNil) + s.NoError(err) obj, err := r.TagObject(tag.Hash()) - c.Assert(err, IsNil) + s.NoError(err) // Verify the tag. pks := new(bytes.Buffer) pkw, err := armor.Encode(pks, openpgp.PublicKeyType, nil) - c.Assert(err, IsNil) + s.NoError(err) err = key.Serialize(pkw) - c.Assert(err, IsNil) + s.NoError(err) err = pkw.Close() - c.Assert(err, IsNil) + s.NoError(err) actual, err := obj.Verify(pks.String()) - c.Assert(err, IsNil) - c.Assert(actual.PrimaryKey, DeepEquals, key.PrimaryKey) + s.NoError(err) + s.Equal(key.PrimaryKey, actual.PrimaryKey) } -func (s *RepositorySuite) TestCreateTagSignedBadKey(c *C) { +func (s *RepositorySuite) TestCreateTagSignedBadKey() { url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(), ) r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: url}) - c.Assert(err, IsNil) + s.NoError(err) h, err := r.Head() - c.Assert(err, IsNil) + s.NoError(err) - key := commitSignKey(c, false) + key := commitSignKey(s.T(), false) _, err = r.CreateTag("foobar", h.Hash(), &CreateTagOptions{ Tagger: defaultSignature(), Message: "foo bar baz qux", SignKey: key, }) - c.Assert(err, Equals, openpgperr.InvalidArgumentError("signing key is encrypted")) + s.ErrorIs(err, openpgperr.InvalidArgumentError("signing key is encrypted")) } -func (s *RepositorySuite) TestCreateTagCanonicalize(c *C) { +func (s *RepositorySuite) TestCreateTagCanonicalize() { url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(), ) r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: url}) - c.Assert(err, IsNil) + s.NoError(err) h, err := r.Head() - c.Assert(err, IsNil) + s.NoError(err) - key := commitSignKey(c, true) + key := commitSignKey(s.T(), true) _, err = r.CreateTag("foobar", h.Hash(), &CreateTagOptions{ Tagger: defaultSignature(), Message: "\n\nfoo bar baz qux\n\nsome message here", SignKey: key, }) - c.Assert(err, IsNil) + s.NoError(err) tag, err := r.Tag("foobar") - c.Assert(err, IsNil) + s.NoError(err) obj, err := r.TagObject(tag.Hash()) - c.Assert(err, IsNil) + s.NoError(err) // Assert the new canonicalized message. - c.Assert(obj.Message, Equals, "foo bar baz qux\n\nsome message here\n") + s.Equal("foo bar baz qux\n\nsome message here\n", obj.Message) // Verify the tag. pks := new(bytes.Buffer) pkw, err := armor.Encode(pks, openpgp.PublicKeyType, nil) - c.Assert(err, IsNil) + s.NoError(err) err = key.Serialize(pkw) - c.Assert(err, IsNil) + s.NoError(err) err = pkw.Close() - c.Assert(err, IsNil) + s.NoError(err) actual, err := obj.Verify(pks.String()) - c.Assert(err, IsNil) - c.Assert(actual.PrimaryKey, DeepEquals, key.PrimaryKey) + s.NoError(err) + s.Equal(key.PrimaryKey, actual.PrimaryKey) } -func (s *RepositorySuite) TestTagLightweight(c *C) { +func (s *RepositorySuite) TestTagLightweight() { url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(), ) r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: url}) - c.Assert(err, IsNil) + s.NoError(err) expected := plumbing.NewHash("f7b877701fbf855b44c0a9e86f3fdce2c298b07f") tag, err := r.Tag("lightweight-tag") - c.Assert(err, IsNil) + s.NoError(err) actual := tag.Hash() - c.Assert(expected, Equals, actual) + s.Equal(actual, expected) } -func (s *RepositorySuite) TestTagLightweightMissingTag(c *C) { +func (s *RepositorySuite) TestTagLightweightMissingTag() { url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(), ) r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: url}) - c.Assert(err, IsNil) + s.NoError(err) tag, err := r.Tag("lightweight-tag-tag") - c.Assert(tag, IsNil) - c.Assert(err, Equals, ErrTagNotFound) + s.Nil(tag) + s.ErrorIs(err, ErrTagNotFound) } -func (s *RepositorySuite) TestDeleteTag(c *C) { +func (s *RepositorySuite) TestDeleteTag() { url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(), ) r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: url}) - c.Assert(err, IsNil) + s.NoError(err) err = r.DeleteTag("lightweight-tag") - c.Assert(err, IsNil) + s.NoError(err) _, err = r.Tag("lightweight-tag") - c.Assert(err, Equals, ErrTagNotFound) + s.ErrorIs(err, ErrTagNotFound) } -func (s *RepositorySuite) TestDeleteTagMissingTag(c *C) { +func (s *RepositorySuite) TestDeleteTagMissingTag() { url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(), ) r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: url}) - c.Assert(err, IsNil) + s.NoError(err) err = r.DeleteTag("lightweight-tag-tag") - c.Assert(err, Equals, ErrTagNotFound) + s.ErrorIs(err, ErrTagNotFound) } -func (s *RepositorySuite) TestDeleteTagAnnotated(c *C) { +func (s *RepositorySuite) TestDeleteTagAnnotated() { url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(), ) - fs, clean := s.TemporalFilesystem() - defer clean() + fs := s.TemporalFilesystem() fss := filesystem.NewStorage(fs, cache.NewObjectLRUDefault()) r, _ := Init(fss, nil) err := r.clone(context.Background(), &CloneOptions{URL: url}) - c.Assert(err, IsNil) + s.NoError(err) ref, err := r.Tag("annotated-tag") - c.Assert(ref, NotNil) - c.Assert(err, IsNil) + s.NotNil(ref) + s.NoError(err) obj, err := r.TagObject(ref.Hash()) - c.Assert(obj, NotNil) - c.Assert(err, IsNil) + s.NotNil(obj) + s.NoError(err) err = r.DeleteTag("annotated-tag") - c.Assert(err, IsNil) + s.NoError(err) _, err = r.Tag("annotated-tag") - c.Assert(err, Equals, ErrTagNotFound) + s.ErrorIs(err, ErrTagNotFound) // Run a prune (and repack, to ensure that we are GCing everything regardless // of the fixture in use) and try to get the tag object again. // // The repo needs to be re-opened after the repack. err = r.Prune(PruneOptions{Handler: r.DeleteObject}) - c.Assert(err, IsNil) + s.NoError(err) err = r.RepackObjects(&RepackConfig{}) - c.Assert(err, IsNil) + s.NoError(err) r, err = PlainOpen(fs.Root()) - c.Assert(r, NotNil) - c.Assert(err, IsNil) + s.NotNil(r) + s.NoError(err) // Now check to see if the GC was effective in removing the tag object. obj, err = r.TagObject(ref.Hash()) - c.Assert(obj, IsNil) - c.Assert(err, Equals, plumbing.ErrObjectNotFound) + s.Nil(obj) + s.ErrorIs(err, plumbing.ErrObjectNotFound) } -func (s *RepositorySuite) TestDeleteTagAnnotatedUnpacked(c *C) { +func (s *RepositorySuite) TestDeleteTagAnnotatedUnpacked() { url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(), ) - fs, clean := s.TemporalFilesystem() - defer clean() + fs := s.TemporalFilesystem() fss := filesystem.NewStorage(fs, cache.NewObjectLRUDefault()) r, _ := Init(fss, nil) err := r.clone(context.Background(), &CloneOptions{URL: url}) - c.Assert(err, IsNil) + s.NoError(err) // Create a tag for the deletion test. This ensures that the ultimate loose // object will be unpacked (as we aren't doing anything that should pack it), // so that we can effectively test that a prune deletes it, without having to // resort to a repack. h, err := r.Head() - c.Assert(err, IsNil) + s.NoError(err) expectedHash := h.Hash() @@ -2902,35 +2938,35 @@ func (s *RepositorySuite) TestDeleteTagAnnotatedUnpacked(c *C) { Tagger: defaultSignature(), Message: "foo bar baz qux", }) - c.Assert(err, IsNil) + s.NoError(err) tag, err := r.Tag("foobar") - c.Assert(err, IsNil) + s.NoError(err) obj, err := r.TagObject(tag.Hash()) - c.Assert(obj, NotNil) - c.Assert(err, IsNil) + s.NotNil(obj) + s.NoError(err) err = r.DeleteTag("foobar") - c.Assert(err, IsNil) + s.NoError(err) _, err = r.Tag("foobar") - c.Assert(err, Equals, ErrTagNotFound) + s.ErrorIs(err, ErrTagNotFound) // As mentioned, only run a prune. We are not testing for packed objects // here. err = r.Prune(PruneOptions{Handler: r.DeleteObject}) - c.Assert(err, IsNil) + s.NoError(err) // Now check to see if the GC was effective in removing the tag object. obj, err = r.TagObject(ref.Hash()) - c.Assert(obj, IsNil) - c.Assert(err, Equals, plumbing.ErrObjectNotFound) + s.Nil(obj) + s.ErrorIs(err, plumbing.ErrObjectNotFound) } -func (s *RepositorySuite) TestInvalidTagName(c *C) { +func (s *RepositorySuite) TestInvalidTagName() { r, err := Init(memory.NewStorage(), nil) - c.Assert(err, IsNil) + s.NoError(err) for i, name := range []string{ "", "foo bar", @@ -2938,31 +2974,31 @@ func (s *RepositorySuite) TestInvalidTagName(c *C) { "foo\nbar", } { _, err = r.CreateTag(name, plumbing.ZeroHash, nil) - c.Assert(err, NotNil, Commentf("case %d %q", i, name)) + s.Error(err, fmt.Sprintf("case %d %q", i, name)) } } -func (s *RepositorySuite) TestBranches(c *C) { +func (s *RepositorySuite) TestBranches() { f := fixtures.ByURL("https://github.com/git-fixtures/root-references.git").One() sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) r, err := Open(sto, f.DotGit()) - c.Assert(err, IsNil) + s.NoError(err) count := 0 branches, err := r.Branches() - c.Assert(err, IsNil) + s.NoError(err) branches.ForEach(func(branch *plumbing.Reference) error { count++ - c.Assert(branch.Hash().IsZero(), Equals, false) - c.Assert(branch.Name().IsBranch(), Equals, true) + s.False(branch.Hash().IsZero()) + s.True(branch.Name().IsBranch()) return nil }) - c.Assert(count, Equals, 8) + s.Equal(8, count) } -func (s *RepositorySuite) TestNotes(c *C) { +func (s *RepositorySuite) TestNotes() { // TODO add fixture with Notes url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(), @@ -2970,53 +3006,53 @@ func (s *RepositorySuite) TestNotes(c *C) { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: url}) - c.Assert(err, IsNil) + s.NoError(err) count := 0 notes, err := r.Notes() - c.Assert(err, IsNil) + s.NoError(err) notes.ForEach(func(note *plumbing.Reference) error { count++ - c.Assert(note.Hash().IsZero(), Equals, false) - c.Assert(note.Name().IsNote(), Equals, true) + s.False(note.Hash().IsZero()) + s.True(note.Name().IsNote()) return nil }) - c.Assert(count, Equals, 0) + s.Equal(0, count) } -func (s *RepositorySuite) TestTree(c *C) { +func (s *RepositorySuite) TestTree() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), }) - c.Assert(err, IsNil) + s.NoError(err) invalidHash := plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") tree, err := r.TreeObject(invalidHash) - c.Assert(tree, IsNil) - c.Assert(err, NotNil) + s.Nil(tree) + s.NotNil(err) hash := plumbing.NewHash("dbd3641b371024f44d0e469a9c8f5457b0660de1") tree, err = r.TreeObject(hash) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(tree.Hash.IsZero(), Equals, false) - c.Assert(tree.Hash, Equals, tree.ID()) - c.Assert(tree.Hash, Equals, hash) - c.Assert(tree.Type(), Equals, plumbing.TreeObject) - c.Assert(len(tree.Entries), Not(Equals), 0) + s.False(tree.Hash.IsZero()) + s.Equal(tree.ID(), tree.Hash) + s.Equal(hash, tree.Hash) + s.Equal(plumbing.TreeObject, tree.Type()) + s.NotEqual(0, len(tree.Entries)) } -func (s *RepositorySuite) TestTrees(c *C) { +func (s *RepositorySuite) TestTrees() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()}) - c.Assert(err, IsNil) + s.NoError(err) count := 0 trees, err := r.TreeObjects() - c.Assert(err, IsNil) + s.NoError(err) for { tree, err := trees.Next() if err != nil { @@ -3024,33 +3060,33 @@ func (s *RepositorySuite) TestTrees(c *C) { } count++ - c.Assert(tree.Hash.IsZero(), Equals, false) - c.Assert(tree.Hash, Equals, tree.ID()) - c.Assert(tree.Type(), Equals, plumbing.TreeObject) - c.Assert(len(tree.Entries), Not(Equals), 0) + s.False(tree.Hash.IsZero()) + s.Equal(tree.ID(), tree.Hash) + s.Equal(plumbing.TreeObject, tree.Type()) + s.NotEqual(0, len(tree.Entries)) } - c.Assert(count, Equals, 12) + s.Equal(12, count) } -func (s *RepositorySuite) TestTagObjects(c *C) { +func (s *RepositorySuite) TestTagObjects() { url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(), ) r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: url}) - c.Assert(err, IsNil) + s.NoError(err) count := 0 tags, err := r.TagObjects() - c.Assert(err, IsNil) + s.NoError(err) tags.ForEach(func(tag *object.Tag) error { count++ - c.Assert(tag.Hash.IsZero(), Equals, false) - c.Assert(tag.Type(), Equals, plumbing.TagObject) + s.False(tag.Hash.IsZero()) + s.Equal(plumbing.TagObject, tag.Type()) return nil }) @@ -3059,66 +3095,66 @@ func (s *RepositorySuite) TestTagObjects(c *C) { return nil }) - c.Assert(count, Equals, 4) + s.Equal(4, count) } -func (s *RepositorySuite) TestCommitIterClosePanic(c *C) { +func (s *RepositorySuite) TestCommitIterClosePanic() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()}) - c.Assert(err, IsNil) + s.NoError(err) commits, err := r.CommitObjects() - c.Assert(err, IsNil) + s.NoError(err) commits.Close() } -func (s *RepositorySuite) TestRef(c *C) { +func (s *RepositorySuite) TestRef() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()}) - c.Assert(err, IsNil) + s.NoError(err) ref, err := r.Reference(plumbing.HEAD, false) - c.Assert(err, IsNil) - c.Assert(ref.Name(), Equals, plumbing.HEAD) + s.NoError(err) + s.Equal(plumbing.HEAD, ref.Name()) ref, err = r.Reference(plumbing.HEAD, true) - c.Assert(err, IsNil) - c.Assert(ref.Name(), Equals, plumbing.ReferenceName("refs/heads/master")) + s.NoError(err) + s.Equal(plumbing.ReferenceName("refs/heads/master"), ref.Name()) } -func (s *RepositorySuite) TestRefs(c *C) { +func (s *RepositorySuite) TestRefs() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()}) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(err, IsNil) + s.NoError(err) iter, err := r.References() - c.Assert(err, IsNil) - c.Assert(iter, NotNil) + s.NoError(err) + s.NotNil(iter) } -func (s *RepositorySuite) TestObject(c *C) { +func (s *RepositorySuite) TestObject() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()}) - c.Assert(err, IsNil) + s.NoError(err) hash := plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5") o, err := r.Object(plumbing.CommitObject, hash) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(o.ID().IsZero(), Equals, false) - c.Assert(o.Type(), Equals, plumbing.CommitObject) + s.False(o.ID().IsZero()) + s.Equal(plumbing.CommitObject, o.Type()) } -func (s *RepositorySuite) TestObjects(c *C) { +func (s *RepositorySuite) TestObjects() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()}) - c.Assert(err, IsNil) + s.NoError(err) count := 0 objects, err := r.Objects() - c.Assert(err, IsNil) + s.NoError(err) for { o, err := objects.Next() if err != nil { @@ -3126,44 +3162,44 @@ func (s *RepositorySuite) TestObjects(c *C) { } count++ - c.Assert(o.ID().IsZero(), Equals, false) - c.Assert(o.Type(), Not(Equals), plumbing.AnyObject) + s.False(o.ID().IsZero()) + s.NotEqual(plumbing.AnyObject, o.Type()) } - c.Assert(count, Equals, 31) + s.Equal(31, count) } -func (s *RepositorySuite) TestObjectNotFound(c *C) { +func (s *RepositorySuite) TestObjectNotFound() { r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()}) - c.Assert(err, IsNil) + s.NoError(err) hash := plumbing.NewHash("0a3fb06ff80156fb153bcdcc58b5e16c2d27625c") tag, err := r.Object(plumbing.TagObject, hash) - c.Assert(err, DeepEquals, plumbing.ErrObjectNotFound) - c.Assert(tag, IsNil) + s.ErrorIs(err, plumbing.ErrObjectNotFound) + s.Nil(tag) } -func (s *RepositorySuite) TestWorktree(c *C) { +func (s *RepositorySuite) TestWorktree() { def := memfs.New() r, _ := Init(memory.NewStorage(), def) w, err := r.Worktree() - c.Assert(err, IsNil) - c.Assert(w.Filesystem, Equals, def) + s.NoError(err) + s.Equal(def, w.Filesystem) } -func (s *RepositorySuite) TestWorktreeBare(c *C) { +func (s *RepositorySuite) TestWorktreeBare() { r, _ := Init(memory.NewStorage(), nil) w, err := r.Worktree() - c.Assert(err, Equals, ErrIsBareRepository) - c.Assert(w, IsNil) + s.ErrorIs(err, ErrIsBareRepository) + s.Nil(w) } -func (s *RepositorySuite) TestResolveRevision(c *C) { +func (s *RepositorySuite) TestResolveRevision() { f := fixtures.ByURL("https://github.com/git-fixtures/basic.git").One() sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) r, err := Open(sto, f.DotGit()) - c.Assert(err, IsNil) + s.NoError(err) datas := map[string]string{ "HEAD": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", @@ -3192,16 +3228,16 @@ func (s *RepositorySuite) TestResolveRevision(c *C) { for rev, hash := range datas { h, err := r.ResolveRevision(plumbing.Revision(rev)) - c.Assert(err, IsNil, Commentf("while checking %s", rev)) - c.Check(h.String(), Equals, hash, Commentf("while checking %s", rev)) + s.NoError(err, fmt.Sprintf("while checking %s", rev)) + s.Equal(hash, h.String(), fmt.Sprintf("while checking %s", rev)) } } -func (s *RepositorySuite) TestResolveRevisionAnnotated(c *C) { +func (s *RepositorySuite) TestResolveRevisionAnnotated() { f := fixtures.ByURL("https://github.com/git-fixtures/tags.git").One() sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault()) r, err := Open(sto, f.DotGit()) - c.Assert(err, IsNil) + s.NoError(err) datas := map[string]string{ "refs/tags/annotated-tag": "f7b877701fbf855b44c0a9e86f3fdce2c298b07f", @@ -3211,26 +3247,26 @@ func (s *RepositorySuite) TestResolveRevisionAnnotated(c *C) { for rev, hash := range datas { h, err := r.ResolveRevision(plumbing.Revision(rev)) - c.Assert(err, IsNil, Commentf("while checking %s", rev)) - c.Check(h.String(), Equals, hash, Commentf("while checking %s", rev)) + s.NoError(err, fmt.Sprintf("while checking %s", rev)) + s.Equal(hash, h.String(), fmt.Sprintf("while checking %s", rev)) } } -func (s *RepositorySuite) TestResolveRevisionWithErrors(c *C) { +func (s *RepositorySuite) TestResolveRevisionWithErrors() { url := s.GetLocalRepositoryURL( fixtures.ByURL("https://github.com/git-fixtures/basic.git").One(), ) r, _ := Init(memory.NewStorage(), nil) err := r.clone(context.Background(), &CloneOptions{URL: url}) - c.Assert(err, IsNil) + s.NoError(err) headRef, err := r.Head() - c.Assert(err, IsNil) + s.NoError(err) ref := plumbing.NewHashReference("refs/heads/918c48b83bd081e863dbe1b80f8998f058cd8294", headRef.Hash()) err = r.Storer.SetReference(ref) - c.Assert(err, IsNil) + s.NoError(err) datas := map[string]string{ "efs/heads/master~": "reference not found", @@ -3241,80 +3277,79 @@ func (s *RepositorySuite) TestResolveRevisionWithErrors(c *C) { for rev, rerr := range datas { _, err := r.ResolveRevision(plumbing.Revision(rev)) - c.Assert(err, NotNil) - c.Assert(err.Error(), Equals, rerr) + s.NotNil(err) + s.Equal(rerr, err.Error()) } } -func (s *RepositorySuite) testRepackObjects( - c *C, deleteTime time.Time, expectedPacks int) { +func (s *RepositorySuite) testRepackObjects(deleteTime time.Time, expectedPacks int) { srcFs := fixtures.ByTag("unpacked").One().DotGit() var sto storage.Storer var err error sto = filesystem.NewStorage(srcFs, cache.NewObjectLRUDefault()) los := sto.(storer.LooseObjectStorer) - c.Assert(los, NotNil) + s.NotNil(los) numLooseStart := 0 err = los.ForEachObjectHash(func(_ plumbing.Hash) error { numLooseStart++ return nil }) - c.Assert(err, IsNil) - c.Assert(numLooseStart > 0, Equals, true) + s.NoError(err) + s.True(numLooseStart > 0) pos := sto.(storer.PackedObjectStorer) - c.Assert(los, NotNil) + s.NotNil(los) packs, err := pos.ObjectPacks() - c.Assert(err, IsNil) + s.NoError(err) numPacksStart := len(packs) - c.Assert(numPacksStart > 1, Equals, true) + s.True(numPacksStart > 1) r, err := Open(sto, srcFs) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) err = r.RepackObjects(&RepackConfig{ OnlyDeletePacksOlderThan: deleteTime, }) - c.Assert(err, IsNil) + s.NoError(err) numLooseEnd := 0 err = los.ForEachObjectHash(func(_ plumbing.Hash) error { numLooseEnd++ return nil }) - c.Assert(err, IsNil) - c.Assert(numLooseEnd, Equals, 0) + s.NoError(err) + s.Equal(0, numLooseEnd) packs, err = pos.ObjectPacks() - c.Assert(err, IsNil) + s.NoError(err) numPacksEnd := len(packs) - c.Assert(numPacksEnd, Equals, expectedPacks) + s.Equal(expectedPacks, numPacksEnd) } -func (s *RepositorySuite) TestRepackObjects(c *C) { +func (s *RepositorySuite) TestRepackObjects() { if testing.Short() { - c.Skip("skipping test in short mode.") + s.T().Skip("skipping test in short mode.") } - s.testRepackObjects(c, time.Time{}, 1) + s.testRepackObjects(time.Time{}, 1) } -func (s *RepositorySuite) TestRepackObjectsWithNoDelete(c *C) { +func (s *RepositorySuite) TestRepackObjectsWithNoDelete() { if testing.Short() { - c.Skip("skipping test in short mode.") + s.T().Skip("skipping test in short mode.") } - s.testRepackObjects(c, time.Unix(0, 1), 3) + s.testRepackObjects(time.Unix(0, 1), 3) } -func ExecuteOnPath(c *C, path string, cmds ...string) error { +func ExecuteOnPath(t *testing.T, path string, cmds ...string) error { for _, cmd := range cmds { err := executeOnPath(path, cmd) - c.Assert(err, IsNil) + assert.NoError(t, err) } return nil @@ -3333,28 +3368,28 @@ func executeOnPath(path, cmd string) error { return c.Run() } -func (s *RepositorySuite) TestBrokenMultipleShallowFetch(c *C) { +func (s *RepositorySuite) TestBrokenMultipleShallowFetch() { r, _ := Init(memory.NewStorage(), nil) _, err := r.CreateRemote(&config.RemoteConfig{ Name: DefaultRemoteName, URLs: []string{s.GetBasicLocalRepositoryURL()}, }) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(r.Fetch(&FetchOptions{ + s.NoError(r.Fetch(&FetchOptions{ Depth: 2, RefSpecs: []config.RefSpec{config.RefSpec("refs/heads/master:refs/heads/master")}, - }), IsNil) + })) shallows, err := r.Storer.Shallow() - c.Assert(err, IsNil) - c.Assert(len(shallows), Equals, 1) + s.NoError(err) + s.Len(shallows, 1) ref, err := r.Reference("refs/heads/master", true) - c.Assert(err, IsNil) + s.NoError(err) cobj, err := r.CommitObject(ref.Hash()) - c.Assert(err, IsNil) - c.Assert(cobj, NotNil) + s.NoError(err) + s.NotNil(cobj) err = object.NewCommitPreorderIter(cobj, nil, nil).ForEach(func(c *object.Commit) error { for _, ph := range c.ParentHashes { for _, h := range shallows { @@ -3366,22 +3401,22 @@ func (s *RepositorySuite) TestBrokenMultipleShallowFetch(c *C) { return nil }) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(r.Fetch(&FetchOptions{ + s.NoError(r.Fetch(&FetchOptions{ Depth: 5, RefSpecs: []config.RefSpec{config.RefSpec("refs/heads/*:refs/heads/*")}, - }), IsNil) + })) shallows, err = r.Storer.Shallow() - c.Assert(err, IsNil) - c.Assert(len(shallows), Equals, 3) + s.NoError(err) + s.Len(shallows, 3) ref, err = r.Reference("refs/heads/master", true) - c.Assert(err, IsNil) + s.NoError(err) cobj, err = r.CommitObject(ref.Hash()) - c.Assert(err, IsNil) - c.Assert(cobj, NotNil) + s.NoError(err) + s.NotNil(cobj) err = object.NewCommitPreorderIter(cobj, nil, nil).ForEach(func(c *object.Commit) error { for _, ph := range c.ParentHashes { for _, h := range shallows { @@ -3393,21 +3428,21 @@ func (s *RepositorySuite) TestBrokenMultipleShallowFetch(c *C) { return nil }) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *RepositorySuite) TestDotGitToOSFilesystemsInvalidPath(c *C) { +func (s *RepositorySuite) TestDotGitToOSFilesystemsInvalidPath() { _, _, err := dotGitToOSFilesystems("\000", false) - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *RepositorySuite) TestIssue674(c *C) { +func (s *RepositorySuite) TestIssue674() { r, _ := Init(memory.NewStorage(), nil) h, err := r.ResolveRevision(plumbing.Revision("")) - c.Assert(err, NotNil) - c.Assert(h, NotNil) - c.Check(h.IsZero(), Equals, true) + s.NotNil(err) + s.NotNil(h) + s.True(h.IsZero()) } func BenchmarkObjects(b *testing.B) { @@ -3461,7 +3496,7 @@ func BenchmarkPlainClone(b *testing.B) { _, err := PlainClone(b.TempDir(), true, &CloneOptions{ URL: "https://github.com/go-git/go-git.git", Depth: 1, - Tags: NoTags, + Tags: plumbing.NoTags, SingleBranch: true, }) if err != nil { diff --git a/repository_windows_test.go b/repository_windows_test.go index e7c1ac7b9..ecfbc521b 100644 --- a/repository_windows_test.go +++ b/repository_windows_test.go @@ -5,8 +5,7 @@ import ( "strings" "github.com/go-git/go-billy/v5/util" - "github.com/go-git/go-git/v5/storage/memory" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/storage/memory" ) // preReceiveHook returns the bytes of a pre-receive hook script @@ -15,33 +14,32 @@ func preReceiveHook(m string) []byte { return []byte(fmt.Sprintf("#!C:/Program\\ Files/Git/usr/bin/sh.exe\nprintf '%s'\n", m)) } -func (s *RepositorySuite) TestCloneFileUrlWindows(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *RepositorySuite) TestCloneFileUrlWindows() { + dir := s.T().TempDir() r, err := PlainInit(dir, false) - c.Assert(err, IsNil) + s.NoError(err) err = util.WriteFile(r.wt, "foo", nil, 0755) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Add("foo") - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Commit("foo", &CommitOptions{ Author: defaultSignature(), Committer: defaultSignature(), }) - c.Assert(err, IsNil) + s.NoError(err) url := "file:///" + strings.ReplaceAll(dir, "\\", "/") - c.Assert(url, Matches, "file:///[A-Za-z]:/.*") + s.Regexp("file:///[A-Za-z]:/.*", url) _, err = Clone(memory.NewStorage(), nil, &CloneOptions{ URL: url, }) - c.Assert(err, IsNil) + s.NoError(err) } diff --git a/signer.go b/signer.go index e3ef7ebd3..ccc4c6092 100644 --- a/signer.go +++ b/signer.go @@ -3,7 +3,7 @@ package git import ( "io" - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" ) // signableObject is an object which can be signed. diff --git a/signer_test.go b/signer_test.go index eba0922d7..805ac72e7 100644 --- a/signer_test.go +++ b/signer_test.go @@ -7,8 +7,8 @@ import ( "time" "github.com/go-git/go-billy/v5/memfs" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/storage/memory" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/storage/memory" ) type b64signer struct{} diff --git a/status.go b/status.go index d14f7e657..537d82148 100644 --- a/status.go +++ b/status.go @@ -5,8 +5,8 @@ import ( "fmt" "path/filepath" - mindex "github.com/go-git/go-git/v5/utils/merkletrie/index" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" + mindex "github.com/jesseduffield/go-git/v5/utils/merkletrie/index" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" ) // Status represents the current status of a Worktree. diff --git a/storage/filesystem/config.go b/storage/filesystem/config.go index 78a646465..fa28d5af8 100644 --- a/storage/filesystem/config.go +++ b/storage/filesystem/config.go @@ -3,9 +3,9 @@ package filesystem import ( "os" - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/storage/filesystem/dotgit" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/storage/filesystem/dotgit" + "github.com/jesseduffield/go-git/v5/utils/ioutil" ) type ConfigStorage struct { diff --git a/storage/filesystem/config_test.go b/storage/filesystem/config_test.go index ce6a9591b..45e492252 100644 --- a/storage/filesystem/config_test.go +++ b/storage/filesystem/config_test.go @@ -2,47 +2,55 @@ package filesystem import ( "os" + "testing" "github.com/go-git/go-billy/v5/osfs" "github.com/go-git/go-billy/v5/util" fixtures "github.com/go-git/go-git-fixtures/v4" - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/storage/filesystem/dotgit" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/storage/filesystem/dotgit" + "github.com/stretchr/testify/suite" ) -type ConfigSuite struct { +type ConfigFixtureSuite struct { fixtures.Suite +} + +type ConfigSuite struct { + suite.Suite + ConfigFixtureSuite dir *dotgit.DotGit path string } -var _ = Suite(&ConfigSuite{}) +func TestConfigSuite(t *testing.T) { + suite.Run(t, new(ConfigSuite)) +} -func (s *ConfigSuite) SetUpTest(c *C) { +func (s *ConfigSuite) SetupTest() { tmp, err := util.TempDir(osfs.Default, "", "go-git-filestystem-config") - c.Assert(err, IsNil) + s.NoError(err) s.dir = dotgit.New(osfs.New(tmp)) s.path = tmp } -func (s *ConfigSuite) TestRemotes(c *C) { +func (s *ConfigSuite) TestRemotes() { dir := dotgit.New(fixtures.Basic().ByTag(".git").One().DotGit()) storer := &ConfigStorage{dir} cfg, err := storer.Config() - c.Assert(err, IsNil) + s.NoError(err) remotes := cfg.Remotes - c.Assert(remotes, HasLen, 1) + s.Len(remotes, 1) remote := remotes["origin"] - c.Assert(remote.Name, Equals, "origin") - c.Assert(remote.URLs, DeepEquals, []string{"https://github.com/git-fixtures/basic"}) - c.Assert(remote.Fetch, DeepEquals, []config.RefSpec{config.RefSpec("+refs/heads/*:refs/remotes/origin/*")}) + s.Equal("origin", remote.Name) + s.Equal([]string{"https://github.com/git-fixtures/basic"}, remote.URLs) + s.Equal([]config.RefSpec{config.RefSpec("+refs/heads/*:refs/remotes/origin/*")}, remote.Fetch) } -func (s *ConfigSuite) TearDownTest(c *C) { +func (s *ConfigSuite) TearDownTest() { defer os.RemoveAll(s.path) } diff --git a/storage/filesystem/deltaobject.go b/storage/filesystem/deltaobject.go index 6ab2cdf38..65bf0d5e7 100644 --- a/storage/filesystem/deltaobject.go +++ b/storage/filesystem/deltaobject.go @@ -1,7 +1,7 @@ package filesystem import ( - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" ) type deltaObject struct { diff --git a/storage/filesystem/dotgit/dotgit.go b/storage/filesystem/dotgit/dotgit.go index 72c9ccfc1..dd1bdafc7 100644 --- a/storage/filesystem/dotgit/dotgit.go +++ b/storage/filesystem/dotgit/dotgit.go @@ -16,10 +16,10 @@ import ( "strings" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/hash" - "github.com/go-git/go-git/v5/storage" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/hash" + "github.com/jesseduffield/go-git/v5/storage" + "github.com/jesseduffield/go-git/v5/utils/ioutil" "github.com/go-git/go-billy/v5" "github.com/go-git/go-billy/v5/helper/chroot" @@ -850,9 +850,15 @@ func (d *DotGit) openAndLockPackedRefs(doCreate bool) ( openFlags |= os.O_CREATE } + start := time.Now() // Keep trying to open and lock the file until we're sure the file // didn't change between the open and the lock. for { + // The arbitrary timeout should eventually be replaced with + // context-based check. + if time.Since(start) > 15*time.Second { + return nil, errors.New("timeout trying to lock packed refs") + } f, err = d.fs.OpenFile(packedRefsPath, openFlags, 0600) if err != nil { if os.IsNotExist(err) && !doCreate { diff --git a/storage/filesystem/dotgit/dotgit_rewrite_packed_refs.go b/storage/filesystem/dotgit/dotgit_rewrite_packed_refs.go index 43263eadf..d0ee2f3d9 100644 --- a/storage/filesystem/dotgit/dotgit_rewrite_packed_refs.go +++ b/storage/filesystem/dotgit/dotgit_rewrite_packed_refs.go @@ -6,7 +6,7 @@ import ( "runtime" "github.com/go-git/go-billy/v5" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/utils/ioutil" ) func (d *DotGit) openAndLockPackedRefsMode() int { diff --git a/storage/filesystem/dotgit/dotgit_setref.go b/storage/filesystem/dotgit/dotgit_setref.go index c057f5c48..31a81dddb 100644 --- a/storage/filesystem/dotgit/dotgit_setref.go +++ b/storage/filesystem/dotgit/dotgit_setref.go @@ -4,8 +4,8 @@ import ( "fmt" "os" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/utils/ioutil" "github.com/go-git/go-billy/v5" ) diff --git a/storage/filesystem/dotgit/dotgit_test.go b/storage/filesystem/dotgit/dotgit_test.go index fdb8a575e..7981d638a 100644 --- a/storage/filesystem/dotgit/dotgit_test.go +++ b/storage/filesystem/dotgit/dotgit_test.go @@ -15,22 +15,30 @@ import ( "github.com/go-git/go-billy/v5/osfs" "github.com/go-git/go-billy/v5/util" fixtures "github.com/go-git/go-git-fixtures/v4" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/storage" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/storage" "github.com/stretchr/testify/assert" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } +type SuiteDotGitFixture struct { + fixtures.Suite +} type SuiteDotGit struct { - fixtures.Suite + suite.Suite + SuiteDotGitFixture } -var _ = Suite(&SuiteDotGit{}) +func TestSuiteDotGit(t *testing.T) { + suite.Run(t, new(SuiteDotGit)) +} + +func (s *SuiteDotGit) TemporalFilesystem() (fs billy.Filesystem) { + tmpDir, err := os.MkdirTemp("", "") + s.NoError(err) -func (s *SuiteDotGit) TemporalFilesystem() (fs billy.Filesystem, clean func()) { - fs = osfs.New(os.TempDir()) + fs = osfs.New(tmpDir) path, err := util.TempDir(fs, "", "") if err != nil { panic(err) @@ -41,130 +49,125 @@ func (s *SuiteDotGit) TemporalFilesystem() (fs billy.Filesystem, clean func()) { panic(err) } - return fs, func() { - util.RemoveAll(fs, path) - } + return fs } -func (s *SuiteDotGit) TestInitialize(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *SuiteDotGit) TestInitialize() { + fs := s.TemporalFilesystem() dir := New(fs) err := dir.Initialize() - c.Assert(err, IsNil) + s.NoError(err) _, err = fs.Stat(fs.Join("objects", "info")) - c.Assert(err, IsNil) + s.NoError(err) _, err = fs.Stat(fs.Join("objects", "pack")) - c.Assert(err, IsNil) + s.NoError(err) _, err = fs.Stat(fs.Join("refs", "heads")) - c.Assert(err, IsNil) + s.NoError(err) _, err = fs.Stat(fs.Join("refs", "tags")) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *SuiteDotGit) TestSetRefs(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *SuiteDotGit) TestSetRefs() { + fs := s.TemporalFilesystem() dir := New(fs) - testSetRefs(c, dir) + testSetRefs(s, dir) } -func (s *SuiteDotGit) TestSetRefsNorwfs(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *SuiteDotGit) TestSetRefsNorwfs() { + fs := s.TemporalFilesystem() dir := New(&norwfs{fs}) - testSetRefs(c, dir) + testSetRefs(s, dir) } -func (s *SuiteDotGit) TestRefsHeadFirst(c *C) { +func (s *SuiteDotGit) TestRefsHeadFirst() { fs := fixtures.Basic().ByTag(".git").One().DotGit() dir := New(fs) refs, err := dir.Refs() - c.Assert(err, IsNil) - c.Assert(len(refs), Not(Equals), 0) - c.Assert(refs[0].Name().String(), Equals, "HEAD") + s.NoError(err) + s.NotEqual(0, len(refs)) + s.Equal("HEAD", refs[0].Name().String()) } -func testSetRefs(c *C, dir *DotGit) { +func testSetRefs(s *SuiteDotGit, dir *DotGit) { firstFoo := plumbing.NewReferenceFromStrings( "refs/heads/foo", "e8d3ffab552895c19b9fcf7aa264d277cde33881", ) err := dir.SetRef(firstFoo, nil) - c.Assert(err, IsNil) + s.NoError(err) err = dir.SetRef(plumbing.NewReferenceFromStrings( "refs/heads/symbolic", "ref: refs/heads/foo", ), nil) - c.Assert(err, IsNil) + s.NoError(err) err = dir.SetRef(plumbing.NewReferenceFromStrings( "bar", "e8d3ffab552895c19b9fcf7aa264d277cde33881", ), nil) - c.Assert(err, IsNil) + s.NoError(err) err = dir.SetRef(plumbing.NewReferenceFromStrings( "refs/heads/feature/baz", "e8d3ffab552895c19b9fcf7aa264d277cde33881", ), nil) - c.Assert(err, IsNil) + s.NoError(err) refs, err := dir.Refs() - c.Assert(err, IsNil) - c.Assert(refs, HasLen, 3) + s.NoError(err) + s.Len(refs, 3) ref := findReference(refs, "refs/heads/foo") - c.Assert(ref, NotNil) - c.Assert(ref.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881") + s.NotNil(ref) + s.Equal("e8d3ffab552895c19b9fcf7aa264d277cde33881", ref.Hash().String()) ref = findReference(refs, "refs/heads/symbolic") - c.Assert(ref, NotNil) - c.Assert(ref.Target().String(), Equals, "refs/heads/foo") + s.NotNil(ref) + s.Equal("refs/heads/foo", ref.Target().String()) ref = findReference(refs, "bar") - c.Assert(ref, IsNil) + s.Nil(ref) _, err = dir.readReferenceFile(".", "refs/heads/feature/baz") - c.Assert(err, IsNil) + s.NoError(err) _, err = dir.readReferenceFile(".", "refs/heads/feature") - c.Assert(err, Equals, ErrIsDir) + s.ErrorIs(err, ErrIsDir) ref, err = dir.Ref("refs/heads/foo") - c.Assert(err, IsNil) - c.Assert(ref, NotNil) - c.Assert(ref.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881") + s.NoError(err) + s.NotNil(ref) + s.Equal("e8d3ffab552895c19b9fcf7aa264d277cde33881", ref.Hash().String()) ref, err = dir.Ref("refs/heads/symbolic") - c.Assert(err, IsNil) - c.Assert(ref, NotNil) - c.Assert(ref.Target().String(), Equals, "refs/heads/foo") + s.NoError(err) + s.NotNil(ref) + s.Equal("refs/heads/foo", ref.Target().String()) ref, err = dir.Ref("bar") - c.Assert(err, IsNil) - c.Assert(ref, NotNil) - c.Assert(ref.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881") + s.NoError(err) + s.NotNil(ref) + s.Equal("e8d3ffab552895c19b9fcf7aa264d277cde33881", ref.Hash().String()) // Check that SetRef with a non-nil `old` works. err = dir.SetRef(plumbing.NewReferenceFromStrings( "refs/heads/foo", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", ), firstFoo) - c.Assert(err, IsNil) + s.NoError(err) // `firstFoo` is no longer the right `old` reference, so this // should fail. @@ -172,32 +175,32 @@ func testSetRefs(c *C, dir *DotGit) { "refs/heads/foo", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", ), firstFoo) - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *SuiteDotGit) TestRefsFromPackedRefs(c *C) { +func (s *SuiteDotGit) TestRefsFromPackedRefs() { fs := fixtures.Basic().ByTag(".git").One().DotGit() dir := New(fs) refs, err := dir.Refs() - c.Assert(err, IsNil) + s.NoError(err) ref := findReference(refs, "refs/remotes/origin/branch") - c.Assert(ref, NotNil) - c.Assert(ref.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881") + s.NotNil(ref) + s.Equal("e8d3ffab552895c19b9fcf7aa264d277cde33881", ref.Hash().String()) } -func (s *SuiteDotGit) TestRefsFromReferenceFile(c *C) { +func (s *SuiteDotGit) TestRefsFromReferenceFile() { fs := fixtures.Basic().ByTag(".git").One().DotGit() dir := New(fs) refs, err := dir.Refs() - c.Assert(err, IsNil) + s.NoError(err) ref := findReference(refs, "refs/remotes/origin/HEAD") - c.Assert(ref, NotNil) - c.Assert(ref.Type(), Equals, plumbing.SymbolicReference) - c.Assert(string(ref.Target()), Equals, "refs/remotes/origin/master") + s.NotNil(ref) + s.Equal(plumbing.SymbolicReference, ref.Type()) + s.Equal("refs/remotes/origin/master", string(ref.Target())) } func BenchmarkRefMultipleTimes(b *testing.B) { @@ -218,39 +221,40 @@ func BenchmarkRefMultipleTimes(b *testing.B) { } } -func (s *SuiteDotGit) TestRemoveRefFromReferenceFile(c *C) { +func (s *SuiteDotGit) TestRemoveRefFromReferenceFile() { fs := fixtures.Basic().ByTag(".git").One().DotGit() dir := New(fs) name := plumbing.ReferenceName("refs/remotes/origin/HEAD") err := dir.RemoveRef(name) - c.Assert(err, IsNil) + s.NoError(err) refs, err := dir.Refs() - c.Assert(err, IsNil) + s.NoError(err) ref := findReference(refs, string(name)) - c.Assert(ref, IsNil) + s.Nil(ref) } -func (s *SuiteDotGit) TestRemoveRefFromPackedRefs(c *C) { +func (s *SuiteDotGit) TestRemoveRefFromPackedRefs() { fs := fixtures.Basic().ByTag(".git").One().DotGit() dir := New(fs) name := plumbing.ReferenceName("refs/remotes/origin/master") err := dir.RemoveRef(name) - c.Assert(err, IsNil) + s.NoError(err) b, err := util.ReadFile(fs, packedRefsPath) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(string(b), Equals, ""+ + s.Equal(""+ "# pack-refs with: peeled fully-peeled \n"+ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 refs/heads/master\n"+ - "e8d3ffab552895c19b9fcf7aa264d277cde33881 refs/remotes/origin/branch\n") + "e8d3ffab552895c19b9fcf7aa264d277cde33881 refs/remotes/origin/branch\n", + string(b)) } -func (s *SuiteDotGit) TestRemoveRefFromReferenceFileAndPackedRefs(c *C) { +func (s *SuiteDotGit) TestRemoveRefFromReferenceFileAndPackedRefs() { fs := fixtures.Basic().ByTag(".git").One().DotGit() dir := New(fs) @@ -259,194 +263,192 @@ func (s *SuiteDotGit) TestRemoveRefFromReferenceFileAndPackedRefs(c *C) { "refs/remotes/origin/branch", "e8d3ffab552895c19b9fcf7aa264d277cde33881", ), nil) - c.Assert(err, IsNil) + s.NoError(err) // Make sure it only appears once in the refs list. refs, err := dir.Refs() - c.Assert(err, IsNil) + s.NoError(err) found := false for _, ref := range refs { if ref.Name() == "refs/remotes/origin/branch" { - c.Assert(found, Equals, false) + s.False(found) found = true } } name := plumbing.ReferenceName("refs/remotes/origin/branch") err = dir.RemoveRef(name) - c.Assert(err, IsNil) + s.NoError(err) b, err := util.ReadFile(fs, packedRefsPath) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(string(b), Equals, ""+ + s.Equal(""+ "# pack-refs with: peeled fully-peeled \n"+ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 refs/heads/master\n"+ - "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 refs/remotes/origin/master\n") + "6ecf0ef2c2dffb796033e5a02219af86ec6584e5 refs/remotes/origin/master\n", + string(b)) refs, err = dir.Refs() - c.Assert(err, IsNil) + s.NoError(err) ref := findReference(refs, string(name)) - c.Assert(ref, IsNil) + s.Nil(ref) } -func (s *SuiteDotGit) TestRemoveRefNonExistent(c *C) { +func (s *SuiteDotGit) TestRemoveRefNonExistent() { fs := fixtures.Basic().ByTag(".git").One().DotGit() dir := New(fs) before, err := util.ReadFile(fs, packedRefsPath) - c.Assert(err, IsNil) + s.NoError(err) name := plumbing.ReferenceName("refs/heads/nonexistent") err = dir.RemoveRef(name) - c.Assert(err, IsNil) + s.NoError(err) after, err := util.ReadFile(fs, packedRefsPath) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(string(before), Equals, string(after)) + s.Equal(string(after), string(before)) } -func (s *SuiteDotGit) TestRemoveRefInvalidPackedRefs(c *C) { +func (s *SuiteDotGit) TestRemoveRefInvalidPackedRefs() { fs := fixtures.Basic().ByTag(".git").One().DotGit() dir := New(fs) brokenContent := "BROKEN STUFF REALLY BROKEN" err := util.WriteFile(fs, packedRefsPath, []byte(brokenContent), os.FileMode(0755)) - c.Assert(err, IsNil) + s.NoError(err) name := plumbing.ReferenceName("refs/heads/nonexistent") err = dir.RemoveRef(name) - c.Assert(err, NotNil) + s.NotNil(err) after, err := util.ReadFile(fs, packedRefsPath) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(brokenContent, Equals, string(after)) + s.Equal(string(after), brokenContent) } -func (s *SuiteDotGit) TestRemoveRefInvalidPackedRefs2(c *C) { +func (s *SuiteDotGit) TestRemoveRefInvalidPackedRefs2() { fs := fixtures.Basic().ByTag(".git").One().DotGit() dir := New(fs) brokenContent := strings.Repeat("a", bufio.MaxScanTokenSize*2) err := util.WriteFile(fs, packedRefsPath, []byte(brokenContent), os.FileMode(0755)) - c.Assert(err, IsNil) + s.NoError(err) name := plumbing.ReferenceName("refs/heads/nonexistent") err = dir.RemoveRef(name) - c.Assert(err, NotNil) + s.NotNil(err) after, err := util.ReadFile(fs, packedRefsPath) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(brokenContent, Equals, string(after)) + s.Equal(string(after), brokenContent) } -func (s *SuiteDotGit) TestRefsFromHEADFile(c *C) { +func (s *SuiteDotGit) TestRefsFromHEADFile() { fs := fixtures.Basic().ByTag(".git").One().DotGit() dir := New(fs) refs, err := dir.Refs() - c.Assert(err, IsNil) + s.NoError(err) ref := findReference(refs, "HEAD") - c.Assert(ref, NotNil) - c.Assert(ref.Type(), Equals, plumbing.SymbolicReference) - c.Assert(string(ref.Target()), Equals, "refs/heads/master") + s.NotNil(ref) + s.Equal(plumbing.SymbolicReference, ref.Type()) + s.Equal("refs/heads/master", string(ref.Target())) } -func (s *SuiteDotGit) TestConfig(c *C) { +func (s *SuiteDotGit) TestConfig() { fs := fixtures.Basic().ByTag(".git").One().DotGit() dir := New(fs) file, err := dir.Config() - c.Assert(err, IsNil) - c.Assert(filepath.Base(file.Name()), Equals, "config") + s.NoError(err) + s.Equal("config", filepath.Base(file.Name())) } -func (s *SuiteDotGit) TestConfigWriteAndConfig(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *SuiteDotGit) TestConfigWriteAndConfig() { + fs := s.TemporalFilesystem() dir := New(fs) f, err := dir.ConfigWriter() - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("foo")) - c.Assert(err, IsNil) + s.NoError(err) f, err = dir.Config() - c.Assert(err, IsNil) + s.NoError(err) cnt, err := io.ReadAll(f) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(string(cnt), Equals, "foo") + s.Equal("foo", string(cnt)) } -func (s *SuiteDotGit) TestIndex(c *C) { +func (s *SuiteDotGit) TestIndex() { fs := fixtures.Basic().ByTag(".git").One().DotGit() dir := New(fs) idx, err := dir.Index() - c.Assert(err, IsNil) - c.Assert(idx, NotNil) + s.NoError(err) + s.NotNil(idx) } -func (s *SuiteDotGit) TestIndexWriteAndIndex(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *SuiteDotGit) TestIndexWriteAndIndex() { + fs := s.TemporalFilesystem() dir := New(fs) f, err := dir.IndexWriter() - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("foo")) - c.Assert(err, IsNil) + s.NoError(err) f, err = dir.Index() - c.Assert(err, IsNil) + s.NoError(err) cnt, err := io.ReadAll(f) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(string(cnt), Equals, "foo") + s.Equal("foo", string(cnt)) } -func (s *SuiteDotGit) TestShallow(c *C) { +func (s *SuiteDotGit) TestShallow() { fs := fixtures.Basic().ByTag(".git").One().DotGit() dir := New(fs) file, err := dir.Shallow() - c.Assert(err, IsNil) - c.Assert(file, IsNil) + s.NoError(err) + s.Nil(file) } -func (s *SuiteDotGit) TestShallowWriteAndShallow(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *SuiteDotGit) TestShallowWriteAndShallow() { + fs := s.TemporalFilesystem() dir := New(fs) f, err := dir.ShallowWriter() - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("foo")) - c.Assert(err, IsNil) + s.NoError(err) f, err = dir.Shallow() - c.Assert(err, IsNil) + s.NoError(err) cnt, err := io.ReadAll(f) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(string(cnt), Equals, "foo") + s.Equal("foo", string(cnt)) } func findReference(refs []*plumbing.Reference, name string) *plumbing.Reference { @@ -460,201 +462,198 @@ func findReference(refs []*plumbing.Reference, name string) *plumbing.Reference return nil } -func (s *SuiteDotGit) TestObjectPacks(c *C) { +func (s *SuiteDotGit) TestObjectPacks() { f := fixtures.Basic().ByTag(".git").One() fs := f.DotGit() dir := New(fs) - testObjectPacks(c, fs, dir, f) + testObjectPacks(s, fs, dir, f) } -func (s *SuiteDotGit) TestObjectPacksExclusive(c *C) { +func (s *SuiteDotGit) TestObjectPacksExclusive() { f := fixtures.Basic().ByTag(".git").One() fs := f.DotGit() dir := NewWithOptions(fs, Options{ExclusiveAccess: true}) - testObjectPacks(c, fs, dir, f) + testObjectPacks(s, fs, dir, f) } -func testObjectPacks(c *C, fs billy.Filesystem, dir *DotGit, f *fixtures.Fixture) { +func testObjectPacks(s *SuiteDotGit, fs billy.Filesystem, dir *DotGit, f *fixtures.Fixture) { hashes, err := dir.ObjectPacks() - c.Assert(err, IsNil) - c.Assert(hashes, HasLen, 1) - c.Assert(hashes[0], Equals, plumbing.NewHash(f.PackfileHash)) + s.NoError(err) + s.Len(hashes, 1) + s.Equal(plumbing.NewHash(f.PackfileHash), hashes[0]) // Make sure that a random file in the pack directory doesn't // break everything. badFile, err := fs.Create("objects/pack/OOPS_THIS_IS_NOT_RIGHT.pack") - c.Assert(err, IsNil) + s.NoError(err) err = badFile.Close() - c.Assert(err, IsNil) + s.NoError(err) // temporary file generated by git gc tmpFile, err := fs.Create("objects/pack/.tmp-11111-pack-58rf8y4wm1b1k52bpe0kdlx6lpreg6ahso8n3ylc.pack") - c.Assert(err, IsNil) + s.NoError(err) err = tmpFile.Close() - c.Assert(err, IsNil) + s.NoError(err) hashes2, err := dir.ObjectPacks() - c.Assert(err, IsNil) - c.Assert(hashes2, HasLen, 1) - c.Assert(hashes[0], Equals, hashes2[0]) + s.NoError(err) + s.Len(hashes2, 1) + s.Equal(hashes2[0], hashes[0]) } -func (s *SuiteDotGit) TestObjectPack(c *C) { +func (s *SuiteDotGit) TestObjectPack() { f := fixtures.Basic().ByTag(".git").One() fs := f.DotGit() dir := New(fs) pack, err := dir.ObjectPack(plumbing.NewHash(f.PackfileHash)) - c.Assert(err, IsNil) - c.Assert(filepath.Ext(pack.Name()), Equals, ".pack") + s.NoError(err) + s.Equal(".pack", filepath.Ext(pack.Name())) } -func (s *SuiteDotGit) TestObjectPackWithKeepDescriptors(c *C) { +func (s *SuiteDotGit) TestObjectPackWithKeepDescriptors() { f := fixtures.Basic().ByTag(".git").One() fs := f.DotGit() dir := NewWithOptions(fs, Options{KeepDescriptors: true}) pack, err := dir.ObjectPack(plumbing.NewHash(f.PackfileHash)) - c.Assert(err, IsNil) - c.Assert(filepath.Ext(pack.Name()), Equals, ".pack") + s.NoError(err) + s.Equal(".pack", filepath.Ext(pack.Name())) // Move to an specific offset pack.Seek(42, io.SeekStart) pack2, err := dir.ObjectPack(plumbing.NewHash(f.PackfileHash)) - c.Assert(err, IsNil) + s.NoError(err) // If the file is the same the offset should be the same offset, err := pack2.Seek(0, io.SeekCurrent) - c.Assert(err, IsNil) - c.Assert(offset, Equals, int64(42)) + s.NoError(err) + s.Equal(int64(42), offset) err = dir.Close() - c.Assert(err, IsNil) + s.NoError(err) pack2, err = dir.ObjectPack(plumbing.NewHash(f.PackfileHash)) - c.Assert(err, IsNil) + s.NoError(err) // If the file is opened again its offset should be 0 offset, err = pack2.Seek(0, io.SeekCurrent) - c.Assert(err, IsNil) - c.Assert(offset, Equals, int64(0)) + s.NoError(err) + s.Equal(int64(0), offset) err = pack2.Close() - c.Assert(err, IsNil) + s.NoError(err) err = dir.Close() - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *SuiteDotGit) TestObjectPackIdx(c *C) { +func (s *SuiteDotGit) TestObjectPackIdx() { f := fixtures.Basic().ByTag(".git").One() fs := f.DotGit() dir := New(fs) idx, err := dir.ObjectPackIdx(plumbing.NewHash(f.PackfileHash)) - c.Assert(err, IsNil) - c.Assert(filepath.Ext(idx.Name()), Equals, ".idx") - c.Assert(idx.Close(), IsNil) + s.NoError(err) + s.Equal(".idx", filepath.Ext(idx.Name())) + s.Nil(idx.Close()) } -func (s *SuiteDotGit) TestObjectPackNotFound(c *C) { +func (s *SuiteDotGit) TestObjectPackNotFound() { fs := fixtures.Basic().ByTag(".git").One().DotGit() dir := New(fs) pack, err := dir.ObjectPack(plumbing.ZeroHash) - c.Assert(err, Equals, ErrPackfileNotFound) - c.Assert(pack, IsNil) + s.ErrorIs(err, ErrPackfileNotFound) + s.Nil(pack) idx, err := dir.ObjectPackIdx(plumbing.ZeroHash) - c.Assert(err, Equals, ErrPackfileNotFound) - c.Assert(idx, IsNil) + s.ErrorIs(err, ErrPackfileNotFound) + s.Nil(idx) } -func (s *SuiteDotGit) TestNewObject(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *SuiteDotGit) TestNewObject() { + fs := s.TemporalFilesystem() dir := New(fs) w, err := dir.NewObject() - c.Assert(err, IsNil) + s.NoError(err) err = w.WriteHeader(plumbing.BlobObject, 14) - c.Assert(err, IsNil) + s.NoError(err) n, err := w.Write([]byte("this is a test")) - c.Assert(err, IsNil) - c.Assert(n, Equals, 14) + s.NoError(err) + s.Equal(14, n) - c.Assert(w.Hash().String(), Equals, "a8a940627d132695a9769df883f85992f0ff4a43") + s.Equal("a8a940627d132695a9769df883f85992f0ff4a43", w.Hash().String()) err = w.Close() - c.Assert(err, IsNil) + s.NoError(err) i, err := fs.Stat("objects/a8/a940627d132695a9769df883f85992f0ff4a43") - c.Assert(err, IsNil) - c.Assert(i.Size(), Equals, int64(34)) + s.NoError(err) + s.Equal(int64(34), i.Size()) } -func (s *SuiteDotGit) TestObjects(c *C) { +func (s *SuiteDotGit) TestObjects() { fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit() dir := New(fs) - testObjects(c, fs, dir) - testObjectsWithPrefix(c, fs, dir) + testObjects(s, fs, dir) + testObjectsWithPrefix(s, fs, dir) } -func (s *SuiteDotGit) TestObjectsExclusive(c *C) { +func (s *SuiteDotGit) TestObjectsExclusive() { fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit() dir := NewWithOptions(fs, Options{ExclusiveAccess: true}) - testObjects(c, fs, dir) - testObjectsWithPrefix(c, fs, dir) + testObjects(s, fs, dir) + testObjectsWithPrefix(s, fs, dir) } -func testObjects(c *C, _ billy.Filesystem, dir *DotGit) { +func testObjects(s *SuiteDotGit, _ billy.Filesystem, dir *DotGit) { hashes, err := dir.Objects() - c.Assert(err, IsNil) - c.Assert(hashes, HasLen, 187) - c.Assert(hashes[0].String(), Equals, "0097821d427a3c3385898eb13b50dcbc8702b8a3") - c.Assert(hashes[1].String(), Equals, "01d5fa556c33743006de7e76e67a2dfcd994ca04") - c.Assert(hashes[2].String(), Equals, "03db8e1fbe133a480f2867aac478fd866686d69e") + s.NoError(err) + s.Len(hashes, 187) + s.Equal("0097821d427a3c3385898eb13b50dcbc8702b8a3", hashes[0].String()) + s.Equal("01d5fa556c33743006de7e76e67a2dfcd994ca04", hashes[1].String()) + s.Equal("03db8e1fbe133a480f2867aac478fd866686d69e", hashes[2].String()) } -func testObjectsWithPrefix(c *C, _ billy.Filesystem, dir *DotGit) { +func testObjectsWithPrefix(s *SuiteDotGit, _ billy.Filesystem, dir *DotGit) { prefix, _ := hex.DecodeString("01d5") hashes, err := dir.ObjectsWithPrefix(prefix) - c.Assert(err, IsNil) - c.Assert(hashes, HasLen, 1) - c.Assert(hashes[0].String(), Equals, "01d5fa556c33743006de7e76e67a2dfcd994ca04") + s.NoError(err) + s.Len(hashes, 1) + s.Equal("01d5fa556c33743006de7e76e67a2dfcd994ca04", hashes[0].String()) // Empty prefix should yield all objects. // (subset of testObjects) hashes, err = dir.ObjectsWithPrefix(nil) - c.Assert(err, IsNil) - c.Assert(hashes, HasLen, 187) + s.NoError(err) + s.Len(hashes, 187) } -func (s *SuiteDotGit) TestObjectsNoFolder(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *SuiteDotGit) TestObjectsNoFolder() { + fs := s.TemporalFilesystem() dir := New(fs) hash, err := dir.Objects() - c.Assert(err, IsNil) - c.Assert(hash, HasLen, 0) + s.NoError(err) + s.Len(hash, 0) } -func (s *SuiteDotGit) TestObject(c *C) { +func (s *SuiteDotGit) TestObject() { fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit() dir := New(fs) hash := plumbing.NewHash("03db8e1fbe133a480f2867aac478fd866686d69e") file, err := dir.Object(hash) - c.Assert(err, IsNil) - c.Assert(strings.HasSuffix( + s.NoError(err) + s.True(strings.HasSuffix( file.Name(), fs.Join("objects", "03", "db8e1fbe133a480f2867aac478fd866686d69e")), - Equals, true, ) incomingHash := "9d25e0f9bde9f82882b49fe29117b9411cb157b7" // made up hash incomingDirPath := fs.Join("objects", "tmp_objdir-incoming-123456") @@ -663,19 +662,18 @@ func (s *SuiteDotGit) TestObject(c *C) { fs.Create(incomingFilePath) _, err = dir.Object(plumbing.NewHash(incomingHash)) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *SuiteDotGit) TestPreGit235Object(c *C) { +func (s *SuiteDotGit) TestPreGit235Object() { fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit() dir := New(fs) hash := plumbing.NewHash("03db8e1fbe133a480f2867aac478fd866686d69e") file, err := dir.Object(hash) - c.Assert(err, IsNil) - c.Assert(strings.HasSuffix( + s.NoError(err) + s.True(strings.HasSuffix( file.Name(), fs.Join("objects", "03", "db8e1fbe133a480f2867aac478fd866686d69e")), - Equals, true, ) incomingHash := "9d25e0f9bde9f82882b49fe29117b9411cb157b7" // made up hash incomingDirPath := fs.Join("objects", "incoming-123456") @@ -684,16 +682,16 @@ func (s *SuiteDotGit) TestPreGit235Object(c *C) { fs.Create(incomingFilePath) _, err = dir.Object(plumbing.NewHash(incomingHash)) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *SuiteDotGit) TestObjectStat(c *C) { +func (s *SuiteDotGit) TestObjectStat() { fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit() dir := New(fs) hash := plumbing.NewHash("03db8e1fbe133a480f2867aac478fd866686d69e") _, err := dir.ObjectStat(hash) - c.Assert(err, IsNil) + s.NoError(err) incomingHash := "9d25e0f9bde9f82882b49fe29117b9411cb157b7" // made up hash incomingDirPath := fs.Join("objects", "tmp_objdir-incoming-123456") incomingFilePath := fs.Join(incomingDirPath, incomingHash[0:2], incomingHash[2:40]) @@ -701,16 +699,16 @@ func (s *SuiteDotGit) TestObjectStat(c *C) { fs.Create(incomingFilePath) _, err = dir.ObjectStat(plumbing.NewHash(incomingHash)) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *SuiteDotGit) TestObjectDelete(c *C) { +func (s *SuiteDotGit) TestObjectDelete() { fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit() dir := New(fs) hash := plumbing.NewHash("03db8e1fbe133a480f2867aac478fd866686d69e") err := dir.ObjectDelete(hash) - c.Assert(err, IsNil) + s.NoError(err) incomingHash := "9d25e0f9bde9f82882b49fe29117b9411cb157b7" // made up hash incomingDirPath := fs.Join("objects", "tmp_objdir-incoming-123456") @@ -718,40 +716,39 @@ func (s *SuiteDotGit) TestObjectDelete(c *C) { incomingFilePath := fs.Join(incomingSubDirPath, incomingHash[2:40]) err = fs.MkdirAll(incomingSubDirPath, os.FileMode(0755)) - c.Assert(err, IsNil) + s.NoError(err) f, err := fs.Create(incomingFilePath) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) err = dir.ObjectDelete(plumbing.NewHash(incomingHash)) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *SuiteDotGit) TestObjectNotFound(c *C) { +func (s *SuiteDotGit) TestObjectNotFound() { fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit() dir := New(fs) hash := plumbing.NewHash("not-found-object") file, err := dir.Object(hash) - c.Assert(err, NotNil) - c.Assert(file, IsNil) + s.NotNil(err) + s.Nil(file) } -func (s *SuiteDotGit) TestSubmodules(c *C) { +func (s *SuiteDotGit) TestSubmodules() { fs := fixtures.ByTag("submodule").One().DotGit() dir := New(fs) m, err := dir.Module("basic") - c.Assert(err, IsNil) - c.Assert(strings.HasSuffix(m.Root(), m.Join(".git", "modules", "basic")), Equals, true) + s.NoError(err) + s.True(strings.HasSuffix(m.Root(), m.Join(".git", "modules", "basic"))) } -func (s *SuiteDotGit) TestPackRefs(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *SuiteDotGit) TestPackRefs() { + fs := s.TemporalFilesystem() dir := New(fs) @@ -759,64 +756,64 @@ func (s *SuiteDotGit) TestPackRefs(c *C) { "refs/heads/foo", "e8d3ffab552895c19b9fcf7aa264d277cde33881", ), nil) - c.Assert(err, IsNil) + s.NoError(err) err = dir.SetRef(plumbing.NewReferenceFromStrings( "refs/heads/bar", "a8d3ffab552895c19b9fcf7aa264d277cde33881", ), nil) - c.Assert(err, IsNil) + s.NoError(err) refs, err := dir.Refs() - c.Assert(err, IsNil) - c.Assert(refs, HasLen, 2) + s.NoError(err) + s.Len(refs, 2) looseCount, err := dir.CountLooseRefs() - c.Assert(err, IsNil) - c.Assert(looseCount, Equals, 2) + s.NoError(err) + s.Equal(2, looseCount) err = dir.PackRefs() - c.Assert(err, IsNil) + s.NoError(err) // Make sure the refs are still there, but no longer loose. refs, err = dir.Refs() - c.Assert(err, IsNil) - c.Assert(refs, HasLen, 2) + s.NoError(err) + s.Len(refs, 2) looseCount, err = dir.CountLooseRefs() - c.Assert(err, IsNil) - c.Assert(looseCount, Equals, 0) + s.NoError(err) + s.Equal(0, looseCount) ref, err := dir.Ref("refs/heads/foo") - c.Assert(err, IsNil) - c.Assert(ref, NotNil) - c.Assert(ref.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881") + s.NoError(err) + s.NotNil(ref) + s.Equal("e8d3ffab552895c19b9fcf7aa264d277cde33881", ref.Hash().String()) ref, err = dir.Ref("refs/heads/bar") - c.Assert(err, IsNil) - c.Assert(ref, NotNil) - c.Assert(ref.Hash().String(), Equals, "a8d3ffab552895c19b9fcf7aa264d277cde33881") + s.NoError(err) + s.NotNil(ref) + s.Equal("a8d3ffab552895c19b9fcf7aa264d277cde33881", ref.Hash().String()) // Now update one of them, re-pack, and check again. err = dir.SetRef(plumbing.NewReferenceFromStrings( "refs/heads/foo", "b8d3ffab552895c19b9fcf7aa264d277cde33881", ), nil) - c.Assert(err, IsNil) + s.NoError(err) looseCount, err = dir.CountLooseRefs() - c.Assert(err, IsNil) - c.Assert(looseCount, Equals, 1) + s.NoError(err) + s.Equal(1, looseCount) err = dir.PackRefs() - c.Assert(err, IsNil) + s.NoError(err) // Make sure the refs are still there, but no longer loose. refs, err = dir.Refs() - c.Assert(err, IsNil) - c.Assert(refs, HasLen, 2) + s.NoError(err) + s.Len(refs, 2) looseCount, err = dir.CountLooseRefs() - c.Assert(err, IsNil) - c.Assert(looseCount, Equals, 0) + s.NoError(err) + s.Equal(0, looseCount) ref, err = dir.Ref("refs/heads/foo") - c.Assert(err, IsNil) - c.Assert(ref, NotNil) - c.Assert(ref.Hash().String(), Equals, "b8d3ffab552895c19b9fcf7aa264d277cde33881") + s.NoError(err) + s.NotNil(ref) + s.Equal("b8d3ffab552895c19b9fcf7aa264d277cde33881", ref.Hash().String()) } func TestAlternatesDefault(t *testing.T) { @@ -962,7 +959,7 @@ func (f *norwfs) Capabilities() billy.Capability { return billy.Capabilities(f.Filesystem) &^ billy.ReadAndWriteCapability } -func (s *SuiteDotGit) TestIncBytes(c *C) { +func (s *SuiteDotGit) TestIncBytes() { tests := []struct { in []byte out []byte @@ -975,8 +972,8 @@ func (s *SuiteDotGit) TestIncBytes(c *C) { } for _, test := range tests { out, overflow := incBytes(test.in) - c.Assert(out, DeepEquals, test.out) - c.Assert(overflow, Equals, test.overflow) + s.Equal(test.out, out) + s.Equal(test.overflow, overflow) } } @@ -1014,9 +1011,8 @@ func (f *notExistsFS) ReadDir(path string) ([]os.FileInfo, error) { return f.Filesystem.ReadDir(path) } -func (s *SuiteDotGit) TestDeletedRefs(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *SuiteDotGit) TestDeletedRefs() { + fs := s.TemporalFilesystem() dir := New(¬ExistsFS{ Filesystem: fs, @@ -1030,28 +1026,27 @@ func (s *SuiteDotGit) TestDeletedRefs(c *C) { "refs/heads/foo", "e8d3ffab552895c19b9fcf7aa264d277cde33881", ), nil) - c.Assert(err, IsNil) + s.NoError(err) err = dir.SetRef(plumbing.NewReferenceFromStrings( "refs/heads/bar", "a8d3ffab552895c19b9fcf7aa264d277cde33881", ), nil) - c.Assert(err, IsNil) + s.NoError(err) err = dir.SetRef(plumbing.NewReferenceFromStrings( "refs/heads/baz/baz", "a8d3ffab552895c19b9fcf7aa264d277cde33881", ), nil) - c.Assert(err, IsNil) + s.NoError(err) refs, err := dir.Refs() - c.Assert(err, IsNil) - c.Assert(refs, HasLen, 1) - c.Assert(refs[0].Name(), Equals, plumbing.ReferenceName("refs/heads/foo")) + s.NoError(err) + s.Len(refs, 1) + s.Equal(plumbing.ReferenceName("refs/heads/foo"), refs[0].Name()) } -// Checks that seting a reference that has been packed and checking its old value is successful -func (s *SuiteDotGit) TestSetPackedRef(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +// Checks that setting a reference that has been packed and checking its old value is successful +func (s *SuiteDotGit) TestSetPackedRef() { + fs := s.TemporalFilesystem() dir := New(fs) @@ -1059,30 +1054,30 @@ func (s *SuiteDotGit) TestSetPackedRef(c *C) { "refs/heads/foo", "e8d3ffab552895c19b9fcf7aa264d277cde33881", ), nil) - c.Assert(err, IsNil) + s.NoError(err) refs, err := dir.Refs() - c.Assert(err, IsNil) - c.Assert(refs, HasLen, 1) + s.NoError(err) + s.Len(refs, 1) looseCount, err := dir.CountLooseRefs() - c.Assert(err, IsNil) - c.Assert(looseCount, Equals, 1) + s.NoError(err) + s.Equal(1, looseCount) err = dir.PackRefs() - c.Assert(err, IsNil) + s.NoError(err) // Make sure the refs are still there, but no longer loose. refs, err = dir.Refs() - c.Assert(err, IsNil) - c.Assert(refs, HasLen, 1) + s.NoError(err) + s.Len(refs, 1) looseCount, err = dir.CountLooseRefs() - c.Assert(err, IsNil) - c.Assert(looseCount, Equals, 0) + s.NoError(err) + s.Equal(0, looseCount) ref, err := dir.Ref("refs/heads/foo") - c.Assert(err, IsNil) - c.Assert(ref, NotNil) - c.Assert(ref.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881") + s.NoError(err) + s.NotNil(ref) + s.Equal("e8d3ffab552895c19b9fcf7aa264d277cde33881", ref.Hash().String()) // Attempt to update the reference using an invalid old reference value err = dir.SetRef(plumbing.NewReferenceFromStrings( @@ -1092,7 +1087,7 @@ func (s *SuiteDotGit) TestSetPackedRef(c *C) { "refs/heads/foo", "e8d3ffab552895c19b9fcf7aa264d277cde33882", )) - c.Assert(err, Equals, storage.ErrReferenceHasChanged) + s.ErrorIs(err, storage.ErrReferenceHasChanged) // Now update the reference and it should pass err = dir.SetRef(plumbing.NewReferenceFromStrings( @@ -1102,8 +1097,8 @@ func (s *SuiteDotGit) TestSetPackedRef(c *C) { "refs/heads/foo", "e8d3ffab552895c19b9fcf7aa264d277cde33881", )) - c.Assert(err, IsNil) + s.NoError(err) looseCount, err = dir.CountLooseRefs() - c.Assert(err, IsNil) - c.Assert(looseCount, Equals, 1) + s.NoError(err) + s.Equal(1, looseCount) } diff --git a/storage/filesystem/dotgit/reader.go b/storage/filesystem/dotgit/reader.go index 975f92ac6..28f3f1cf7 100644 --- a/storage/filesystem/dotgit/reader.go +++ b/storage/filesystem/dotgit/reader.go @@ -5,9 +5,9 @@ import ( "io" "os" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/objfile" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/objfile" + "github.com/jesseduffield/go-git/v5/utils/ioutil" ) var _ (plumbing.EncodedObject) = &EncodedObject{} diff --git a/storage/filesystem/dotgit/repository_filesystem_test.go b/storage/filesystem/dotgit/repository_filesystem_test.go index 022bde75f..9bb0ee388 100644 --- a/storage/filesystem/dotgit/repository_filesystem_test.go +++ b/storage/filesystem/dotgit/repository_filesystem_test.go @@ -2,114 +2,111 @@ package dotgit import ( "os" - - . "gopkg.in/check.v1" ) -func (s *SuiteDotGit) TestRepositoryFilesystem(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *SuiteDotGit) TestRepositoryFilesystem() { + fs := s.TemporalFilesystem() err := fs.MkdirAll("dotGit", 0777) - c.Assert(err, IsNil) + s.NoError(err) dotGitFs, err := fs.Chroot("dotGit") - c.Assert(err, IsNil) + s.NoError(err) err = fs.MkdirAll("commonDotGit", 0777) - c.Assert(err, IsNil) + s.NoError(err) commonDotGitFs, err := fs.Chroot("commonDotGit") - c.Assert(err, IsNil) + s.NoError(err) repositoryFs := NewRepositoryFilesystem(dotGitFs, commonDotGitFs) - c.Assert(repositoryFs.Root(), Equals, dotGitFs.Root()) + s.Equal(dotGitFs.Root(), repositoryFs.Root()) somedir, err := repositoryFs.Chroot("somedir") - c.Assert(err, IsNil) - c.Assert(somedir.Root(), Equals, repositoryFs.Join(dotGitFs.Root(), "somedir")) + s.NoError(err) + s.Equal(repositoryFs.Join(dotGitFs.Root(), "somedir"), somedir.Root()) _, err = repositoryFs.Create("somefile") - c.Assert(err, IsNil) + s.NoError(err) _, err = repositoryFs.Stat("somefile") - c.Assert(err, IsNil) + s.NoError(err) file, err := repositoryFs.Open("somefile") - c.Assert(err, IsNil) + s.NoError(err) err = file.Close() - c.Assert(err, IsNil) + s.NoError(err) file, err = repositoryFs.OpenFile("somefile", os.O_RDONLY, 0666) - c.Assert(err, IsNil) + s.NoError(err) err = file.Close() - c.Assert(err, IsNil) + s.NoError(err) file, err = repositoryFs.Create("somefile2") - c.Assert(err, IsNil) + s.NoError(err) err = file.Close() - c.Assert(err, IsNil) + s.NoError(err) _, err = repositoryFs.Stat("somefile2") - c.Assert(err, IsNil) + s.NoError(err) err = repositoryFs.Rename("somefile2", "newfile") - c.Assert(err, IsNil) + s.NoError(err) tempDir, err := repositoryFs.TempFile("tmp", "myprefix") - c.Assert(err, IsNil) - c.Assert(repositoryFs.Join(repositoryFs.Root(), "tmp", tempDir.Name()), Equals, repositoryFs.Join(dotGitFs.Root(), "tmp", tempDir.Name())) + s.NoError(err) + s.Equal(repositoryFs.Join(dotGitFs.Root(), "tmp", tempDir.Name()), repositoryFs.Join(repositoryFs.Root(), "tmp", tempDir.Name())) err = repositoryFs.Symlink("newfile", "somelink") - c.Assert(err, IsNil) + s.NoError(err) _, err = repositoryFs.Lstat("somelink") - c.Assert(err, IsNil) + s.NoError(err) link, err := repositoryFs.Readlink("somelink") - c.Assert(err, IsNil) - c.Assert(link, Equals, "newfile") + s.NoError(err) + s.Equal("newfile", link) err = repositoryFs.Remove("somelink") - c.Assert(err, IsNil) + s.NoError(err) _, err = repositoryFs.Stat("somelink") - c.Assert(os.IsNotExist(err), Equals, true) + s.True(os.IsNotExist(err)) dirs := []string{objectsPath, refsPath, packedRefsPath, configPath, branchesPath, hooksPath, infoPath, remotesPath, logsPath, shallowPath, worktreesPath} for _, dir := range dirs { err := repositoryFs.MkdirAll(dir, 0777) - c.Assert(err, IsNil) + s.NoError(err) _, err = commonDotGitFs.Stat(dir) - c.Assert(err, IsNil) + s.NoError(err) _, err = dotGitFs.Stat(dir) - c.Assert(os.IsNotExist(err), Equals, true) + s.True(os.IsNotExist(err)) } exceptionsPaths := []string{repositoryFs.Join(logsPath, "HEAD"), repositoryFs.Join(refsPath, "bisect"), repositoryFs.Join(refsPath, "rewritten"), repositoryFs.Join(refsPath, "worktree")} for _, path := range exceptionsPaths { _, err := repositoryFs.Create(path) - c.Assert(err, IsNil) + s.NoError(err) _, err = commonDotGitFs.Stat(path) - c.Assert(os.IsNotExist(err), Equals, true) + s.True(os.IsNotExist(err)) _, err = dotGitFs.Stat(path) - c.Assert(err, IsNil) + s.NoError(err) } err = repositoryFs.MkdirAll("refs/heads", 0777) - c.Assert(err, IsNil) + s.NoError(err) _, err = commonDotGitFs.Stat("refs/heads") - c.Assert(err, IsNil) + s.NoError(err) _, err = dotGitFs.Stat("refs/heads") - c.Assert(os.IsNotExist(err), Equals, true) + s.True(os.IsNotExist(err)) err = repositoryFs.MkdirAll("objects/pack", 0777) - c.Assert(err, IsNil) + s.NoError(err) _, err = commonDotGitFs.Stat("objects/pack") - c.Assert(err, IsNil) + s.NoError(err) _, err = dotGitFs.Stat("objects/pack") - c.Assert(os.IsNotExist(err), Equals, true) + s.True(os.IsNotExist(err)) err = repositoryFs.MkdirAll("a/b/c", 0777) - c.Assert(err, IsNil) + s.NoError(err) _, err = commonDotGitFs.Stat("a/b/c") - c.Assert(os.IsNotExist(err), Equals, true) + s.True(os.IsNotExist(err)) _, err = dotGitFs.Stat("a/b/c") - c.Assert(err, IsNil) + s.NoError(err) } diff --git a/storage/filesystem/dotgit/writers.go b/storage/filesystem/dotgit/writers.go index 849b7a176..723fa4a44 100644 --- a/storage/filesystem/dotgit/writers.go +++ b/storage/filesystem/dotgit/writers.go @@ -5,11 +5,11 @@ import ( "io" "sync/atomic" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/idxfile" - "github.com/go-git/go-git/v5/plumbing/format/objfile" - "github.com/go-git/go-git/v5/plumbing/format/packfile" - "github.com/go-git/go-git/v5/plumbing/hash" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/idxfile" + "github.com/jesseduffield/go-git/v5/plumbing/format/objfile" + "github.com/jesseduffield/go-git/v5/plumbing/format/packfile" + "github.com/jesseduffield/go-git/v5/plumbing/hash" "github.com/go-git/go-billy/v5" ) @@ -19,7 +19,7 @@ import ( // this operation is synchronized with the write operations. // The packfile is written in a temp file, when Close is called this file // is renamed/moved (depends on the Filesystem implementation) to the final -// location, if the PackWriter is not used, nothing is written +// location, if the PackWriter is not used, nothing is written. type PackWriter struct { Notify func(plumbing.Hash, *idxfile.Writer) @@ -56,23 +56,19 @@ func newPackWrite(fs billy.Filesystem) (*PackWriter, error) { } func (w *PackWriter) buildIndex() { - s := packfile.NewScanner(w.synced) w.writer = new(idxfile.Writer) var err error - w.parser, err = packfile.NewParser(s, w.writer) - if err != nil { - w.result <- err - return - } - checksum, err := w.parser.Parse() + w.parser = packfile.NewParser(w.synced, packfile.WithScannerObservers(w.writer)) + + h, err := w.parser.Parse() if err != nil { w.result <- err return } - w.checksum = checksum - w.result <- err + w.checksum = h + w.result <- nil } // waitBuildIndex waits until buildIndex function finishes, this can terminate diff --git a/storage/filesystem/dotgit/writers_test.go b/storage/filesystem/dotgit/writers_test.go index a2517ccb1..92d541006 100644 --- a/storage/filesystem/dotgit/writers_test.go +++ b/storage/filesystem/dotgit/writers_test.go @@ -5,88 +5,111 @@ import ( "io" "os" "strconv" + "testing" "github.com/go-git/go-billy/v5/osfs" "github.com/go-git/go-billy/v5/util" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/idxfile" - "github.com/go-git/go-git/v5/plumbing/format/packfile" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/idxfile" + "github.com/jesseduffield/go-git/v5/plumbing/format/packfile" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" - fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" + fixtures "github.com/go-git/go-git-fixtures/v5" ) -func (s *SuiteDotGit) TestNewObjectPack(c *C) { - f := fixtures.Basic().One() +func BenchmarkNewObjectPack(b *testing.B) { + f := fixtures.ByURL("https://github.com/src-d/go-git.git").One() + fs := osfs.New(b.TempDir()) + + for i := 0; i < b.N; i++ { + w, err := newPackWrite(fs) + + require.NoError(b, err) + _, err = io.Copy(w, f.Packfile()) + + require.NoError(b, err) + require.NoError(b, w.Close()) + } +} - fs, clean := s.TemporalFilesystem() - defer clean() +func TestNewObjectPack(t *testing.T) { + t.Parallel() + f := fixtures.Basic().One() + + fs := osfs.New(t.TempDir()) dot := New(fs) w, err := dot.NewObjectPack() - c.Assert(err, IsNil) + require.NoError(t, err) _, err = io.Copy(w, f.Packfile()) - c.Assert(err, IsNil) + require.NoError(t, err) - c.Assert(w.Close(), IsNil) + require.NoError(t, w.Close()) pfPath := fmt.Sprintf("objects/pack/pack-%s.pack", f.PackfileHash) idxPath := fmt.Sprintf("objects/pack/pack-%s.idx", f.PackfileHash) stat, err := fs.Stat(pfPath) - c.Assert(err, IsNil) - c.Assert(stat.Size(), Equals, int64(84794)) + require.NoError(t, err) + assert.Equal(t, int64(84794), stat.Size()) stat, err = fs.Stat(idxPath) - c.Assert(err, IsNil) - c.Assert(stat.Size(), Equals, int64(1940)) + require.NoError(t, err) + assert.Equal(t, int64(1940), stat.Size()) pf, err := fs.Open(pfPath) - c.Assert(err, IsNil) + assert.NoError(t, err) + + objFound := false pfs := packfile.NewScanner(pf) - _, objects, err := pfs.Header() - c.Assert(err, IsNil) - for i := uint32(0); i < objects; i++ { - _, err := pfs.NextObjectHeader() - if err != nil { - c.Assert(err, IsNil) - break + for pfs.Scan() { + data := pfs.Data() + if data.Section != packfile.ObjectSection { + continue } + + objFound = true + assert.NotNil(t, data.Value()) } - c.Assert(pfs.Close(), IsNil) + + assert.NoError(t, pf.Close()) + assert.True(t, objFound) } -func (s *SuiteDotGit) TestNewObjectPackUnused(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func TestNewObjectPackUnused(t *testing.T) { + t.Parallel() + fs := osfs.New(t.TempDir()) dot := New(fs) w, err := dot.NewObjectPack() - c.Assert(err, IsNil) + require.NoError(t, err) - c.Assert(w.Close(), IsNil) + assert.NoError(t, w.Close()) info, err := fs.ReadDir("objects/pack") - c.Assert(err, IsNil) - c.Assert(info, HasLen, 0) + require.NoError(t, err) + assert.Len(t, info, 0) // check clean up of temporary files info, err = fs.ReadDir("") - c.Assert(err, IsNil) + require.NoError(t, err) for _, fi := range info { - c.Assert(fi.IsDir(), Equals, true) + assert.True(t, fi.IsDir()) } } -func (s *SuiteDotGit) TestSyncedReader(c *C) { +func TestSyncedReader(t *testing.T) { + t.Parallel() + tmpw, err := util.TempFile(osfs.Default, "", "example") - c.Assert(err, IsNil) + require.NoError(t, err) tmpr, err := osfs.Default.Open(tmpw.Name()) - c.Assert(err, IsNil) + require.NoError(t, err) defer func() { tmpw.Close() @@ -99,42 +122,41 @@ func (s *SuiteDotGit) TestSyncedReader(c *C) { go func() { for i := 0; i < 281; i++ { _, err := synced.Write([]byte(strconv.Itoa(i) + "\n")) - c.Assert(err, IsNil) + require.NoError(t, err) } synced.Close() }() o, err := synced.Seek(1002, io.SeekStart) - c.Assert(err, IsNil) - c.Assert(o, Equals, int64(1002)) + require.NoError(t, err) + assert.Equal(t, int64(1002), o) head := make([]byte, 3) n, err := io.ReadFull(synced, head) - c.Assert(err, IsNil) - c.Assert(n, Equals, 3) - c.Assert(string(head), Equals, "278") + require.NoError(t, err) + assert.Equal(t, 3, n) + assert.Equal(t, "278", string(head)) o, err = synced.Seek(1010, io.SeekStart) - c.Assert(err, IsNil) - c.Assert(o, Equals, int64(1010)) + require.NoError(t, err) + assert.Equal(t, int64(1010), o) n, err = io.ReadFull(synced, head) - c.Assert(err, IsNil) - c.Assert(n, Equals, 3) - c.Assert(string(head), Equals, "280") + require.NoError(t, err) + assert.Equal(t, 3, n) + assert.Equal(t, "280", string(head)) } -func (s *SuiteDotGit) TestPackWriterUnusedNotify(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func TestPackWriterUnusedNotify(t *testing.T) { + fs := osfs.New(t.TempDir()) - w, err := newPackWrite(fs) - c.Assert(err, IsNil) + w, err := newPackWrite(fs) + require.NoError(t, err) w.Notify = func(h plumbing.Hash, idx *idxfile.Writer) { - c.Fatal("unexpected call to PackWriter.Notify") + t.Fatal("unexpected call to PackWriter.Notify") } - c.Assert(w.Close(), IsNil) + assert.NoError(t, w.Close()) } diff --git a/storage/filesystem/index.go b/storage/filesystem/index.go index a86ef3e2e..8c10e4788 100644 --- a/storage/filesystem/index.go +++ b/storage/filesystem/index.go @@ -4,9 +4,9 @@ import ( "bufio" "os" - "github.com/go-git/go-git/v5/plumbing/format/index" - "github.com/go-git/go-git/v5/storage/filesystem/dotgit" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/plumbing/format/index" + "github.com/jesseduffield/go-git/v5/storage/filesystem/dotgit" + "github.com/jesseduffield/go-git/v5/utils/ioutil" ) type IndexStorage struct { diff --git a/storage/filesystem/module.go b/storage/filesystem/module.go index 20336c118..77de7dbab 100644 --- a/storage/filesystem/module.go +++ b/storage/filesystem/module.go @@ -1,9 +1,9 @@ package filesystem import ( - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/storage" - "github.com/go-git/go-git/v5/storage/filesystem/dotgit" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/storage" + "github.com/jesseduffield/go-git/v5/storage/filesystem/dotgit" ) type ModuleStorage struct { diff --git a/storage/filesystem/object.go b/storage/filesystem/object.go index 91b4aceae..ee226e63d 100644 --- a/storage/filesystem/object.go +++ b/storage/filesystem/object.go @@ -2,28 +2,27 @@ package filesystem import ( "bytes" + "fmt" "io" "os" "sync" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/format/idxfile" - "github.com/go-git/go-git/v5/plumbing/format/objfile" - "github.com/go-git/go-git/v5/plumbing/format/packfile" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage/filesystem/dotgit" - "github.com/go-git/go-git/v5/utils/ioutil" - - "github.com/go-git/go-billy/v5" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/format/idxfile" + "github.com/jesseduffield/go-git/v5/plumbing/format/objfile" + "github.com/jesseduffield/go-git/v5/plumbing/format/packfile" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage/filesystem/dotgit" + "github.com/jesseduffield/go-git/v5/utils/ioutil" ) type ObjectStorage struct { options Options - // objectCache is an object cache uses to cache delta's bases and also recently - // loaded loose objects + // objectCache is an object cache used to cache delta's bases and also recently + // loaded loose objects. objectCache cache.Object dir *dotgit.DotGit @@ -32,6 +31,8 @@ type ObjectStorage struct { packList []plumbing.Hash packListIdx int packfiles map[plumbing.Hash]*packfile.Packfile + muI sync.RWMutex + muP sync.RWMutex } // NewObjectStorage creates a new ObjectStorage with the given .git directory and cache. @@ -91,6 +92,20 @@ func (s *ObjectStorage) loadIdxFile(h plumbing.Hash) (err error) { return err } +func (s *ObjectStorage) RawObjectWriter(typ plumbing.ObjectType, sz int64) (w io.WriteCloser, err error) { + ow, err := s.dir.NewObject() + if err != nil { + return nil, err + } + + err = ow.WriteHeader(typ, sz) + if err != nil { + return nil, err + } + + return ow, nil +} + func (s *ObjectStorage) NewEncodedObject() plumbing.EncodedObject { return &plumbing.MemoryObject{} } @@ -216,17 +231,18 @@ func (s *ObjectStorage) packfile(idx idxfile.Index, pack plumbing.Hash) (*packfi return nil, err } - var p *packfile.Packfile - if s.objectCache != nil { - p = packfile.NewPackfileWithCache(idx, s.dir.Fs(), f, s.objectCache, s.options.LargeObjectThreshold) - } else { - p = packfile.NewPackfile(idx, s.dir.Fs(), f, s.options.LargeObjectThreshold) - } - + p := packfile.NewPackfile(f, + packfile.WithIdx(idx), + packfile.WithFs(s.dir.Fs()), + packfile.WithCache(s.objectCache), + ) return p, s.storePackfileInCache(pack, p) } func (s *ObjectStorage) packfileFromCache(hash plumbing.Hash) *packfile.Packfile { + s.muP.Lock() + defer s.muP.Unlock() + if s.packfiles == nil { if s.options.KeepDescriptors { s.packfiles = make(map[plumbing.Hash]*packfile.Packfile) @@ -240,6 +256,9 @@ func (s *ObjectStorage) packfileFromCache(hash plumbing.Hash) *packfile.Packfile } func (s *ObjectStorage) storePackfileInCache(hash plumbing.Hash, p *packfile.Packfile) error { + s.muP.Lock() + defer s.muP.Unlock() + if s.options.KeepDescriptors { s.packfiles[hash] = p return nil @@ -361,7 +380,7 @@ func (s *ObjectStorage) EncodedObject(t plumbing.ObjectType, h plumbing.Hash) (p return nil, err } - if plumbing.AnyObject != t && obj.Type() != t { + if obj == nil || (plumbing.AnyObject != t && obj.Type() != t) { return nil, plumbing.ErrObjectNotFound } @@ -462,7 +481,10 @@ func (s *ObjectStorage) getFromPackfile(h plumbing.Hash, canBeDelta bool) ( return nil, plumbing.ErrObjectNotFound } + s.muI.RLock() idx := s.index[pack] + s.muI.RUnlock() + p, err := s.packfile(idx, pack) if err != nil { return nil, err @@ -476,38 +498,29 @@ func (s *ObjectStorage) getFromPackfile(h plumbing.Hash, canBeDelta bool) ( return s.decodeDeltaObjectAt(p, offset, hash) } - return s.decodeObjectAt(p, offset) -} - -func (s *ObjectStorage) decodeObjectAt( - p *packfile.Packfile, - offset int64, -) (plumbing.EncodedObject, error) { - hash, err := p.FindHash(offset) - if err == nil { - obj, ok := s.objectCache.Get(hash) - if ok { - return obj, nil - } - } - - if err != nil && err != plumbing.ErrObjectNotFound { - return nil, err - } - return p.GetByOffset(offset) } +// TODO: refactor this logic into packfile package. func (s *ObjectStorage) decodeDeltaObjectAt( p *packfile.Packfile, offset int64, hash plumbing.Hash, ) (plumbing.EncodedObject, error) { - scan := p.Scanner() - header, err := scan.SeekObjectHeader(offset) + scan, err := p.Scanner() if err != nil { return nil, err } + err = scan.SeekFromStart(offset) + if err != nil { + return nil, err + } + + if !scan.Scan() { + return nil, fmt.Errorf("failed to decode delta object") + } + + header := scan.Data().Value().(packfile.ObjectHeader) var ( base plumbing.Hash @@ -522,7 +535,7 @@ func (s *ObjectStorage) decodeDeltaObjectAt( return nil, err } default: - return s.decodeObjectAt(p, offset) + return p.GetByOffset(offset) } obj := &plumbing.MemoryObject{} @@ -532,14 +545,17 @@ func (s *ObjectStorage) decodeDeltaObjectAt( return nil, err } - if _, _, err := scan.NextObject(w); err != nil { + if err := scan.WriteObject(&header, w); err != nil { return nil, err } - return newDeltaObject(obj, hash, base, header.Length), nil + return newDeltaObject(obj, hash, base, header.Size), nil } func (s *ObjectStorage) findObjectInPackfile(h plumbing.Hash) (plumbing.Hash, plumbing.Hash, int64) { + defer s.muI.Unlock() + s.muI.Lock() + for packfile, index := range s.index { offset, err := index.FindOffset(h) if err == nil { @@ -636,7 +652,6 @@ func (s *ObjectStorage) buildPackfileIters( return newPackfileIter( s.dir.Fs(), pack, t, seen, s.index[h], s.objectCache, s.options.KeepDescriptors, - s.options.LargeObjectThreshold, ) }, }, nil @@ -645,6 +660,10 @@ func (s *ObjectStorage) buildPackfileIters( // Close closes all opened files. func (s *ObjectStorage) Close() error { var firstError error + + s.muP.RLock() + defer s.muP.RUnlock() + if s.options.KeepDescriptors || s.options.MaxOpenDescriptors > 0 { for _, packfile := range s.packfiles { err := packfile.Close() @@ -660,201 +679,6 @@ func (s *ObjectStorage) Close() error { return firstError } -type lazyPackfilesIter struct { - hashes []plumbing.Hash - open func(h plumbing.Hash) (storer.EncodedObjectIter, error) - cur storer.EncodedObjectIter -} - -func (it *lazyPackfilesIter) Next() (plumbing.EncodedObject, error) { - for { - if it.cur == nil { - if len(it.hashes) == 0 { - return nil, io.EOF - } - h := it.hashes[0] - it.hashes = it.hashes[1:] - - sub, err := it.open(h) - if err == io.EOF { - continue - } else if err != nil { - return nil, err - } - it.cur = sub - } - ob, err := it.cur.Next() - if err == io.EOF { - it.cur.Close() - it.cur = nil - continue - } else if err != nil { - return nil, err - } - return ob, nil - } -} - -func (it *lazyPackfilesIter) ForEach(cb func(plumbing.EncodedObject) error) error { - return storer.ForEachIterator(it, cb) -} - -func (it *lazyPackfilesIter) Close() { - if it.cur != nil { - it.cur.Close() - it.cur = nil - } - it.hashes = nil -} - -type packfileIter struct { - pack billy.File - iter storer.EncodedObjectIter - seen map[plumbing.Hash]struct{} - - // tells whether the pack file should be left open after iteration or not - keepPack bool -} - -// NewPackfileIter returns a new EncodedObjectIter for the provided packfile -// and object type. Packfile and index file will be closed after they're -// used. If keepPack is true the packfile won't be closed after the iteration -// finished. -func NewPackfileIter( - fs billy.Filesystem, - f billy.File, - idxFile billy.File, - t plumbing.ObjectType, - keepPack bool, - largeObjectThreshold int64, -) (storer.EncodedObjectIter, error) { - idx := idxfile.NewMemoryIndex() - if err := idxfile.NewDecoder(idxFile).Decode(idx); err != nil { - return nil, err - } - - if err := idxFile.Close(); err != nil { - return nil, err - } - - seen := make(map[plumbing.Hash]struct{}) - return newPackfileIter(fs, f, t, seen, idx, nil, keepPack, largeObjectThreshold) -} - -func newPackfileIter( - fs billy.Filesystem, - f billy.File, - t plumbing.ObjectType, - seen map[plumbing.Hash]struct{}, - index idxfile.Index, - cache cache.Object, - keepPack bool, - largeObjectThreshold int64, -) (storer.EncodedObjectIter, error) { - var p *packfile.Packfile - if cache != nil { - p = packfile.NewPackfileWithCache(index, fs, f, cache, largeObjectThreshold) - } else { - p = packfile.NewPackfile(index, fs, f, largeObjectThreshold) - } - - iter, err := p.GetByType(t) - if err != nil { - return nil, err - } - - return &packfileIter{ - pack: f, - iter: iter, - seen: seen, - keepPack: keepPack, - }, nil -} - -func (iter *packfileIter) Next() (plumbing.EncodedObject, error) { - for { - obj, err := iter.iter.Next() - if err != nil { - return nil, err - } - - if _, ok := iter.seen[obj.Hash()]; ok { - continue - } - - return obj, nil - } -} - -func (iter *packfileIter) ForEach(cb func(plumbing.EncodedObject) error) error { - for { - o, err := iter.Next() - if err != nil { - if err == io.EOF { - iter.Close() - return nil - } - return err - } - - if err := cb(o); err != nil { - return err - } - } -} - -func (iter *packfileIter) Close() { - iter.iter.Close() - if !iter.keepPack { - _ = iter.pack.Close() - } -} - -type objectsIter struct { - s *ObjectStorage - t plumbing.ObjectType - h []plumbing.Hash -} - -func (iter *objectsIter) Next() (plumbing.EncodedObject, error) { - if len(iter.h) == 0 { - return nil, io.EOF - } - - obj, err := iter.s.getFromUnpacked(iter.h[0]) - iter.h = iter.h[1:] - - if err != nil { - return nil, err - } - - if iter.t != plumbing.AnyObject && iter.t != obj.Type() { - return iter.Next() - } - - return obj, err -} - -func (iter *objectsIter) ForEach(cb func(plumbing.EncodedObject) error) error { - for { - o, err := iter.Next() - if err != nil { - if err == io.EOF { - return nil - } - return err - } - - if err := cb(o); err != nil { - return err - } - } -} - -func (iter *objectsIter) Close() { - iter.h = []plumbing.Hash{} -} - func hashListAsMap(l []plumbing.Hash) map[plumbing.Hash]struct{} { m := make(map[plumbing.Hash]struct{}, len(l)) for _, h := range l { diff --git a/storage/filesystem/object_iter.go b/storage/filesystem/object_iter.go new file mode 100644 index 000000000..41e7c0969 --- /dev/null +++ b/storage/filesystem/object_iter.go @@ -0,0 +1,205 @@ +package filesystem + +import ( + "io" + + "github.com/go-git/go-billy/v5" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/format/idxfile" + "github.com/jesseduffield/go-git/v5/plumbing/format/packfile" + "github.com/jesseduffield/go-git/v5/plumbing/storer" +) + +type lazyPackfilesIter struct { + hashes []plumbing.Hash + open func(h plumbing.Hash) (storer.EncodedObjectIter, error) + cur storer.EncodedObjectIter +} + +func (it *lazyPackfilesIter) Next() (plumbing.EncodedObject, error) { + for { + if it.cur == nil { + if len(it.hashes) == 0 { + return nil, io.EOF + } + h := it.hashes[0] + it.hashes = it.hashes[1:] + + sub, err := it.open(h) + if err == io.EOF { + continue + } else if err != nil { + return nil, err + } + it.cur = sub + } + ob, err := it.cur.Next() + if err == io.EOF { + it.cur.Close() + it.cur = nil + continue + } else if err != nil { + return nil, err + } + return ob, nil + } +} + +func (it *lazyPackfilesIter) ForEach(cb func(plumbing.EncodedObject) error) error { + return storer.ForEachIterator(it, cb) +} + +func (it *lazyPackfilesIter) Close() { + if it.cur != nil { + it.cur.Close() + it.cur = nil + } + it.hashes = nil +} + +type packfileIter struct { + pack billy.File + iter storer.EncodedObjectIter + seen map[plumbing.Hash]struct{} + + // tells whether the pack file should be left open after iteration or not + keepPack bool +} + +// NewPackfileIter returns a new EncodedObjectIter for the provided packfile +// and object type. Packfile and index file will be closed after they're +// used. If keepPack is true the packfile won't be closed after the iteration +// finished. +func NewPackfileIter( + fs billy.Filesystem, + f billy.File, + idxFile billy.File, + t plumbing.ObjectType, + keepPack bool, + largeObjectThreshold int64, +) (storer.EncodedObjectIter, error) { + idx := idxfile.NewMemoryIndex() + if err := idxfile.NewDecoder(idxFile).Decode(idx); err != nil { + return nil, err + } + + if err := idxFile.Close(); err != nil { + return nil, err + } + + seen := make(map[plumbing.Hash]struct{}) + return newPackfileIter(fs, f, t, seen, idx, nil, keepPack) +} + +func newPackfileIter( + fs billy.Filesystem, + f billy.File, + t plumbing.ObjectType, + seen map[plumbing.Hash]struct{}, + index idxfile.Index, + cache cache.Object, + keepPack bool, +) (storer.EncodedObjectIter, error) { + p := packfile.NewPackfile(f, + packfile.WithFs(fs), + packfile.WithCache(cache), + packfile.WithIdx(index), + ) + + iter, err := p.GetByType(t) + if err != nil { + return nil, err + } + + return &packfileIter{ + pack: f, + iter: iter, + seen: seen, + keepPack: keepPack, + }, nil +} + +func (iter *packfileIter) Next() (plumbing.EncodedObject, error) { + for { + obj, err := iter.iter.Next() + if err != nil { + return nil, err + } + + if _, ok := iter.seen[obj.Hash()]; ok { + continue + } + + return obj, nil + } +} + +func (iter *packfileIter) ForEach(cb func(plumbing.EncodedObject) error) error { + for { + o, err := iter.Next() + if err != nil { + if err == io.EOF { + iter.Close() + return nil + } + return err + } + + if err := cb(o); err != nil { + return err + } + } +} + +func (iter *packfileIter) Close() { + iter.iter.Close() + if !iter.keepPack { + _ = iter.pack.Close() + } +} + +type objectsIter struct { + s *ObjectStorage + t plumbing.ObjectType + h []plumbing.Hash +} + +func (iter *objectsIter) Next() (plumbing.EncodedObject, error) { + if len(iter.h) == 0 { + return nil, io.EOF + } + + obj, err := iter.s.getFromUnpacked(iter.h[0]) + iter.h = iter.h[1:] + + if err != nil { + return nil, err + } + + if iter.t != plumbing.AnyObject && iter.t != obj.Type() { + return iter.Next() + } + + return obj, err +} + +func (iter *objectsIter) ForEach(cb func(plumbing.EncodedObject) error) error { + for { + o, err := iter.Next() + if err != nil { + if err == io.EOF { + return nil + } + return err + } + + if err := cb(o); err != nil { + return err + } + } +} + +func (iter *objectsIter) Close() { + iter.h = []plumbing.Hash{} +} diff --git a/storage/filesystem/object_test.go b/storage/filesystem/object_test.go index 4f98458c4..d3c06025f 100644 --- a/storage/filesystem/object_test.go +++ b/storage/filesystem/object_test.go @@ -10,18 +10,23 @@ import ( "github.com/go-git/go-billy/v5" "github.com/go-git/go-billy/v5/osfs" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/storage/filesystem/dotgit" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/storage/filesystem/dotgit" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) -type FsSuite struct { +type FsFixtureSuite struct { fixtures.Suite } +type FsSuite struct { + suite.Suite + FsFixtureSuite +} + var objectTypes = []plumbing.ObjectType{ plumbing.CommitObject, plumbing.TagObject, @@ -29,84 +34,86 @@ var objectTypes = []plumbing.ObjectType{ plumbing.BlobObject, } -var _ = Suite(&FsSuite{}) +func TestFsSuite(t *testing.T) { + suite.Run(t, new(FsSuite)) +} -func (s *FsSuite) TestGetFromObjectFile(c *C) { +func (s *FsSuite) TestGetFromObjectFile() { fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit() o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault()) expected := plumbing.NewHash("f3dfe29d268303fc6e1bbce268605fc99573406e") obj, err := o.EncodedObject(plumbing.AnyObject, expected) - c.Assert(err, IsNil) - c.Assert(obj.Hash(), Equals, expected) + s.NoError(err) + s.Equal(expected, obj.Hash()) } -func (s *FsSuite) TestGetFromPackfile(c *C) { - fixtures.Basic().ByTag(".git").Test(c, func(f *fixtures.Fixture) { +func (s *FsSuite) TestGetFromPackfile() { + for _, f := range fixtures.Basic().ByTag(".git") { fs := f.DotGit() o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault()) expected := plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5") obj, err := o.EncodedObject(plumbing.AnyObject, expected) - c.Assert(err, IsNil) - c.Assert(obj.Hash(), Equals, expected) - }) + s.NoError(err) + s.Equal(expected, obj.Hash()) + } } -func (s *FsSuite) TestGetFromPackfileKeepDescriptors(c *C) { - fixtures.Basic().ByTag(".git").Test(c, func(f *fixtures.Fixture) { +func (s *FsSuite) TestGetFromPackfileKeepDescriptors() { + for _, f := range fixtures.Basic().ByTag(".git") { fs := f.DotGit() dg := dotgit.NewWithOptions(fs, dotgit.Options{KeepDescriptors: true}) o := NewObjectStorageWithOptions(dg, cache.NewObjectLRUDefault(), Options{KeepDescriptors: true}) expected := plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5") obj, err := o.EncodedObject(plumbing.AnyObject, expected) - c.Assert(err, IsNil) - c.Assert(obj.Hash(), Equals, expected) + s.NoError(err) + s.Equal(expected, obj.Hash()) packfiles, err := dg.ObjectPacks() - c.Assert(err, IsNil) + s.NoError(err) pack1, err := dg.ObjectPack(packfiles[0]) - c.Assert(err, IsNil) + s.NoError(err) pack1.Seek(42, io.SeekStart) err = o.Close() - c.Assert(err, IsNil) + s.NoError(err) pack2, err := dg.ObjectPack(packfiles[0]) - c.Assert(err, IsNil) + s.NoError(err) offset, err := pack2.Seek(0, io.SeekCurrent) - c.Assert(err, IsNil) - c.Assert(offset, Equals, int64(0)) + s.NoError(err) + s.Equal(int64(0), offset) err = o.Close() - c.Assert(err, IsNil) + s.NoError(err) - }) + } } -func (s *FsSuite) TestGetFromPackfileMaxOpenDescriptors(c *C) { +func (s *FsSuite) TestGetFromPackfileMaxOpenDescriptors() { fs := fixtures.ByTag(".git").ByTag("multi-packfile").One().DotGit() o := NewObjectStorageWithOptions(dotgit.New(fs), cache.NewObjectLRUDefault(), Options{MaxOpenDescriptors: 1}) expected := plumbing.NewHash("8d45a34641d73851e01d3754320b33bb5be3c4d3") obj, err := o.getFromPackfile(expected, false) - c.Assert(err, IsNil) - c.Assert(obj.Hash(), Equals, expected) + s.NoError(err) + s.Equal(expected, obj.Hash()) expected = plumbing.NewHash("e9cfa4c9ca160546efd7e8582ec77952a27b17db") obj, err = o.getFromPackfile(expected, false) - c.Assert(err, IsNil) - c.Assert(obj.Hash(), Equals, expected) + s.NoError(err) + s.Equal(expected, obj.Hash()) err = o.Close() - c.Assert(err, IsNil) + s.NoError(err) } -func (s *FsSuite) TestGetFromPackfileMaxOpenDescriptorsLargeObjectThreshold(c *C) { +func (s *FsSuite) TestGetFromPackfileMaxOpenDescriptorsLargeObjectThreshold() { fs := fixtures.ByTag(".git").ByTag("multi-packfile").One().DotGit() o := NewObjectStorageWithOptions(dotgit.New(fs), cache.NewObjectLRUDefault(), Options{ MaxOpenDescriptors: 1, @@ -115,93 +122,93 @@ func (s *FsSuite) TestGetFromPackfileMaxOpenDescriptorsLargeObjectThreshold(c *C expected := plumbing.NewHash("8d45a34641d73851e01d3754320b33bb5be3c4d3") obj, err := o.getFromPackfile(expected, false) - c.Assert(err, IsNil) - c.Assert(obj.Hash(), Equals, expected) + s.NoError(err) + s.Equal(expected, obj.Hash()) expected = plumbing.NewHash("e9cfa4c9ca160546efd7e8582ec77952a27b17db") obj, err = o.getFromPackfile(expected, false) - c.Assert(err, IsNil) - c.Assert(obj.Hash(), Equals, expected) + s.NoError(err) + s.Equal(expected, obj.Hash()) err = o.Close() - c.Assert(err, IsNil) + s.NoError(err) } -func (s *FsSuite) TestGetSizeOfObjectFile(c *C) { +func (s *FsSuite) TestGetSizeOfObjectFile() { fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit() o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault()) // Get the size of `tree_walker.go`. expected := plumbing.NewHash("cbd81c47be12341eb1185b379d1c82675aeded6a") size, err := o.EncodedObjectSize(expected) - c.Assert(err, IsNil) - c.Assert(size, Equals, int64(2412)) + s.NoError(err) + s.Equal(int64(2412), size) } -func (s *FsSuite) TestGetSizeFromPackfile(c *C) { - fixtures.Basic().ByTag(".git").Test(c, func(f *fixtures.Fixture) { +func (s *FsSuite) TestGetSizeFromPackfile() { + for _, f := range fixtures.Basic().ByTag(".git") { fs := f.DotGit() o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault()) // Get the size of `binary.jpg`. expected := plumbing.NewHash("d5c0f4ab811897cadf03aec358ae60d21f91c50d") size, err := o.EncodedObjectSize(expected) - c.Assert(err, IsNil) - c.Assert(size, Equals, int64(76110)) - }) + s.NoError(err) + s.Equal(int64(76110), size) + } } -func (s *FsSuite) TestGetSizeOfAllObjectFiles(c *C) { +func (s *FsSuite) TestGetSizeOfAllObjectFiles() { fs := fixtures.ByTag(".git").One().DotGit() o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault()) // Get the size of `tree_walker.go`. err := o.ForEachObjectHash(func(h plumbing.Hash) error { size, err := o.EncodedObjectSize(h) - c.Assert(err, IsNil) - c.Assert(size, Not(Equals), int64(0)) + s.NoError(err) + s.NotEqual(int64(0), size) return nil }) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *FsSuite) TestGetFromPackfileMultiplePackfiles(c *C) { +func (s *FsSuite) TestGetFromPackfileMultiplePackfiles() { fs := fixtures.ByTag(".git").ByTag("multi-packfile").One().DotGit() o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault()) expected := plumbing.NewHash("8d45a34641d73851e01d3754320b33bb5be3c4d3") obj, err := o.getFromPackfile(expected, false) - c.Assert(err, IsNil) - c.Assert(obj.Hash(), Equals, expected) + s.NoError(err) + s.Equal(expected, obj.Hash()) expected = plumbing.NewHash("e9cfa4c9ca160546efd7e8582ec77952a27b17db") obj, err = o.getFromPackfile(expected, false) - c.Assert(err, IsNil) - c.Assert(obj.Hash(), Equals, expected) + s.NoError(err) + s.Equal(expected, obj.Hash()) } -func (s *FsSuite) TestGetFromPackfileMultiplePackfilesLargeObjectThreshold(c *C) { +func (s *FsSuite) TestGetFromPackfileMultiplePackfilesLargeObjectThreshold() { fs := fixtures.ByTag(".git").ByTag("multi-packfile").One().DotGit() o := NewObjectStorageWithOptions(dotgit.New(fs), cache.NewObjectLRUDefault(), Options{LargeObjectThreshold: 1}) expected := plumbing.NewHash("8d45a34641d73851e01d3754320b33bb5be3c4d3") obj, err := o.getFromPackfile(expected, false) - c.Assert(err, IsNil) - c.Assert(obj.Hash(), Equals, expected) + s.NoError(err) + s.Equal(expected, obj.Hash()) expected = plumbing.NewHash("e9cfa4c9ca160546efd7e8582ec77952a27b17db") obj, err = o.getFromPackfile(expected, false) - c.Assert(err, IsNil) - c.Assert(obj.Hash(), Equals, expected) + s.NoError(err) + s.Equal(expected, obj.Hash()) } -func (s *FsSuite) TestIter(c *C) { - fixtures.ByTag(".git").ByTag("packfile").Test(c, func(f *fixtures.Fixture) { +func (s *FsSuite) TestIter() { + for _, f := range fixtures.ByTag(".git").ByTag("packfile") { fs := f.DotGit() o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault()) iter, err := o.IterEncodedObjects(plumbing.AnyObject) - c.Assert(err, IsNil) + s.NoError(err) var count int32 err = iter.ForEach(func(o plumbing.EncodedObject) error { @@ -209,18 +216,18 @@ func (s *FsSuite) TestIter(c *C) { return nil }) - c.Assert(err, IsNil) - c.Assert(count, Equals, f.ObjectsCount) - }) + s.NoError(err) + s.Equal(f.ObjectsCount, count) + } } -func (s *FsSuite) TestIterLargeObjectThreshold(c *C) { - fixtures.ByTag(".git").ByTag("packfile").Test(c, func(f *fixtures.Fixture) { +func (s *FsSuite) TestIterLargeObjectThreshold() { + for _, f := range fixtures.ByTag(".git").ByTag("packfile") { fs := f.DotGit() o := NewObjectStorageWithOptions(dotgit.New(fs), cache.NewObjectLRUDefault(), Options{LargeObjectThreshold: 1}) iter, err := o.IterEncodedObjects(plumbing.AnyObject) - c.Assert(err, IsNil) + s.NoError(err) var count int32 err = iter.ForEach(func(o plumbing.EncodedObject) error { @@ -228,78 +235,78 @@ func (s *FsSuite) TestIterLargeObjectThreshold(c *C) { return nil }) - c.Assert(err, IsNil) - c.Assert(count, Equals, f.ObjectsCount) - }) + s.NoError(err) + s.Equal(f.ObjectsCount, count) + } } -func (s *FsSuite) TestIterWithType(c *C) { - fixtures.ByTag(".git").Test(c, func(f *fixtures.Fixture) { +func (s *FsSuite) TestIterWithType() { + for _, f := range fixtures.ByTag(".git") { for _, t := range objectTypes { fs := f.DotGit() o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault()) iter, err := o.IterEncodedObjects(t) - c.Assert(err, IsNil) + s.NoError(err) err = iter.ForEach(func(o plumbing.EncodedObject) error { - c.Assert(o.Type(), Equals, t) + s.Equal(t, o.Type()) return nil }) - c.Assert(err, IsNil) + s.NoError(err) } - }) + } } -func (s *FsSuite) TestPackfileIter(c *C) { - fixtures.ByTag(".git").Test(c, func(f *fixtures.Fixture) { +func (s *FsSuite) TestPackfileIter() { + for _, f := range fixtures.ByTag(".git") { fs := f.DotGit() dg := dotgit.New(fs) for _, t := range objectTypes { ph, err := dg.ObjectPacks() - c.Assert(err, IsNil) + s.NoError(err) for _, h := range ph { f, err := dg.ObjectPack(h) - c.Assert(err, IsNil) + s.NoError(err) idxf, err := dg.ObjectPackIdx(h) - c.Assert(err, IsNil) + s.NoError(err) iter, err := NewPackfileIter(fs, f, idxf, t, false, 0) - c.Assert(err, IsNil) + s.NoError(err) err = iter.ForEach(func(o plumbing.EncodedObject) error { - c.Assert(o.Type(), Equals, t) + s.Equal(t, o.Type()) return nil }) - c.Assert(err, IsNil) + s.NoError(err) } } - }) + } } -func copyFile(c *C, dstDir, dstFilename string, srcFile billy.File) { +func copyFile(s *FsSuite, dstDir, dstFilename string, srcFile billy.File) { _, err := srcFile.Seek(0, 0) - c.Assert(err, IsNil) + s.NoError(err) err = osfs.Default.MkdirAll(dstDir, 0750|os.ModeDir) - c.Assert(err, IsNil) + s.NoError(err) dst, err := osfs.Default.OpenFile(filepath.Join(dstDir, dstFilename), os.O_CREATE|os.O_WRONLY, 0666) - c.Assert(err, IsNil) + s.NoError(err) defer dst.Close() _, err = io.Copy(dst, srcFile) - c.Assert(err, IsNil) + s.NoError(err) } // TestPackfileReindex tests that externally-added packfiles are considered by go-git // after calling the Reindex method -func (s *FsSuite) TestPackfileReindex(c *C) { +func (s *FsSuite) TestPackfileReindex() { // obtain a standalone packfile that is not part of any other repository // in the fixtures: packFixture := fixtures.ByTag("packfile").ByTag("standalone").One() @@ -307,72 +314,78 @@ func (s *FsSuite) TestPackfileReindex(c *C) { idxFile := packFixture.Idx() packFilename := packFixture.PackfileHash testObjectHash := plumbing.NewHash("a771b1e94141480861332fd0e4684d33071306c6") // this is an object we know exists in the standalone packfile - fixtures.ByTag(".git").Test(c, func(f *fixtures.Fixture) { + for _, f := range fixtures.ByTag(".git") { fs := f.DotGit() storer := NewStorage(fs, cache.NewObjectLRUDefault()) // check that our test object is NOT found _, err := storer.EncodedObject(plumbing.CommitObject, testObjectHash) - c.Assert(err, Equals, plumbing.ErrObjectNotFound) + s.ErrorIs(err, plumbing.ErrObjectNotFound) // add the external packfile+idx to the packs folder // this simulates a git bundle unbundle command, or a repack, for example. - copyFile(c, filepath.Join(storer.Filesystem().Root(), "objects", "pack"), + copyFile(s, filepath.Join(storer.Filesystem().Root(), "objects", "pack"), fmt.Sprintf("pack-%s.pack", packFilename), packFile) - copyFile(c, filepath.Join(storer.Filesystem().Root(), "objects", "pack"), + copyFile(s, filepath.Join(storer.Filesystem().Root(), "objects", "pack"), fmt.Sprintf("pack-%s.idx", packFilename), idxFile) // check that we cannot still retrieve the test object _, err = storer.EncodedObject(plumbing.CommitObject, testObjectHash) - c.Assert(err, Equals, plumbing.ErrObjectNotFound) + s.ErrorIs(err, plumbing.ErrObjectNotFound) storer.Reindex() // actually reindex // Now check that the test object can be retrieved _, err = storer.EncodedObject(plumbing.CommitObject, testObjectHash) - c.Assert(err, IsNil) + s.NoError(err) - }) + } } -func (s *FsSuite) TestPackfileIterKeepDescriptors(c *C) { - fixtures.ByTag(".git").Test(c, func(f *fixtures.Fixture) { +func (s *FsSuite) TestPackfileIterKeepDescriptors() { + s.T().Skip("packfileIter with keep descriptors is currently broken") + + for _, f := range fixtures.ByTag(".git") { fs := f.DotGit() ops := dotgit.Options{KeepDescriptors: true} dg := dotgit.NewWithOptions(fs, ops) for _, t := range objectTypes { ph, err := dg.ObjectPacks() - c.Assert(err, IsNil) + s.NoError(err) for _, h := range ph { f, err := dg.ObjectPack(h) - c.Assert(err, IsNil) + s.NoError(err) idxf, err := dg.ObjectPackIdx(h) - c.Assert(err, IsNil) + s.NoError(err) iter, err := NewPackfileIter(fs, f, idxf, t, true, 0) - c.Assert(err, IsNil) + s.NoError(err) + + if err != nil { + continue + } err = iter.ForEach(func(o plumbing.EncodedObject) error { - c.Assert(o.Type(), Equals, t) + s.Equal(t, o.Type()) return nil }) - c.Assert(err, IsNil) + s.NoError(err) // test twice to check that packfiles are not closed err = iter.ForEach(func(o plumbing.EncodedObject) error { - c.Assert(o.Type(), Equals, t) + s.Equal(t, o.Type()) return nil }) - c.Assert(err, IsNil) + s.NoError(err) } } - }) + } } -func (s *FsSuite) TestGetFromObjectFileSharedCache(c *C) { +func (s *FsSuite) TestGetFromObjectFileSharedCache() { f1 := fixtures.ByTag("worktree").One().DotGit() f2 := fixtures.ByTag("worktree").ByTag("submodule").One().DotGit() @@ -382,42 +395,42 @@ func (s *FsSuite) TestGetFromObjectFileSharedCache(c *C) { expected := plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a") obj, err := o1.EncodedObject(plumbing.CommitObject, expected) - c.Assert(err, IsNil) - c.Assert(obj.Hash(), Equals, expected) + s.NoError(err) + s.Equal(expected, obj.Hash()) _, err = o2.EncodedObject(plumbing.CommitObject, expected) - c.Assert(err, Equals, plumbing.ErrObjectNotFound) + s.ErrorIs(err, plumbing.ErrObjectNotFound) } -func (s *FsSuite) TestHashesWithPrefix(c *C) { +func (s *FsSuite) TestHashesWithPrefix() { // Same setup as TestGetFromObjectFile. fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit() o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault()) expected := plumbing.NewHash("f3dfe29d268303fc6e1bbce268605fc99573406e") obj, err := o.EncodedObject(plumbing.AnyObject, expected) - c.Assert(err, IsNil) - c.Assert(obj.Hash(), Equals, expected) + s.NoError(err) + s.Equal(expected, obj.Hash()) prefix, _ := hex.DecodeString("f3dfe2") hashes, err := o.HashesWithPrefix(prefix) - c.Assert(err, IsNil) - c.Assert(hashes, HasLen, 1) - c.Assert(hashes[0].String(), Equals, "f3dfe29d268303fc6e1bbce268605fc99573406e") + s.NoError(err) + s.Len(hashes, 1) + s.Equal("f3dfe29d268303fc6e1bbce268605fc99573406e", hashes[0].String()) } -func (s *FsSuite) TestHashesWithPrefixFromPackfile(c *C) { +func (s *FsSuite) TestHashesWithPrefixFromPackfile() { // Same setup as TestGetFromPackfile - fixtures.Basic().ByTag(".git").Test(c, func(f *fixtures.Fixture) { + for _, f := range fixtures.Basic().ByTag(".git") { fs := f.DotGit() o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault()) expected := plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5") // Only pass the first 8 bytes hashes, err := o.HashesWithPrefix(expected[:8]) - c.Assert(err, IsNil) - c.Assert(hashes, HasLen, 1) - c.Assert(hashes[0], Equals, expected) - }) + s.NoError(err) + s.Len(hashes, 1) + s.Equal(expected, hashes[0]) + } } func BenchmarkPackfileIter(b *testing.B) { @@ -548,7 +561,7 @@ func BenchmarkGetObjectFromPackfile(b *testing.B) { } } -func (s *FsSuite) TestGetFromUnpackedCachesObjects(c *C) { +func (s *FsSuite) TestGetFromUnpackedCachesObjects() { fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit() objectCache := cache.NewObjectLRUDefault() objectStorage := NewObjectStorage(dotgit.New(fs), objectCache) @@ -556,40 +569,40 @@ func (s *FsSuite) TestGetFromUnpackedCachesObjects(c *C) { // Assert the cache is empty initially _, ok := objectCache.Get(hash) - c.Assert(ok, Equals, false) + s.False(ok) // Load the object obj, err := objectStorage.EncodedObject(plumbing.AnyObject, hash) - c.Assert(err, IsNil) - c.Assert(obj.Hash(), Equals, hash) + s.NoError(err) + s.Equal(hash, obj.Hash()) // The object should've been cached during the load cachedObj, ok := objectCache.Get(hash) - c.Assert(ok, Equals, true) - c.Assert(cachedObj, DeepEquals, obj) + s.True(ok) + s.Equal(obj, cachedObj) // Assert that both objects can be read and that they both produce the same bytes objReader, err := obj.Reader() - c.Assert(err, IsNil) + s.NoError(err) objBytes, err := io.ReadAll(objReader) - c.Assert(err, IsNil) - c.Assert(len(objBytes), Not(Equals), 0) + s.NoError(err) + s.NotEqual(0, len(objBytes)) err = objReader.Close() - c.Assert(err, IsNil) + s.NoError(err) cachedObjReader, err := cachedObj.Reader() - c.Assert(err, IsNil) + s.NoError(err) cachedObjBytes, err := io.ReadAll(cachedObjReader) - c.Assert(len(cachedObjBytes), Not(Equals), 0) - c.Assert(err, IsNil) + s.NotEqual(0, len(cachedObjBytes)) + s.NoError(err) err = cachedObjReader.Close() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(cachedObjBytes, DeepEquals, objBytes) + s.Equal(objBytes, cachedObjBytes) } -func (s *FsSuite) TestGetFromUnpackedDoesNotCacheLargeObjects(c *C) { +func (s *FsSuite) TestGetFromUnpackedDoesNotCacheLargeObjects() { fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit() objectCache := cache.NewObjectLRUDefault() objectStorage := NewObjectStorageWithOptions(dotgit.New(fs), objectCache, Options{LargeObjectThreshold: 1}) @@ -597,14 +610,14 @@ func (s *FsSuite) TestGetFromUnpackedDoesNotCacheLargeObjects(c *C) { // Assert the cache is empty initially _, ok := objectCache.Get(hash) - c.Assert(ok, Equals, false) + s.False(ok) // Load the object obj, err := objectStorage.EncodedObject(plumbing.AnyObject, hash) - c.Assert(err, IsNil) - c.Assert(obj.Hash(), Equals, hash) + s.NoError(err) + s.Equal(hash, obj.Hash()) // The object should not have been cached during the load _, ok = objectCache.Get(hash) - c.Assert(ok, Equals, false) + s.False(ok) } diff --git a/storage/filesystem/reference.go b/storage/filesystem/reference.go index aabcd7308..d6a79fce5 100644 --- a/storage/filesystem/reference.go +++ b/storage/filesystem/reference.go @@ -1,9 +1,9 @@ package filesystem import ( - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage/filesystem/dotgit" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage/filesystem/dotgit" ) type ReferenceStorage struct { diff --git a/storage/filesystem/shallow.go b/storage/filesystem/shallow.go index ac48fdfbb..5f898fc1c 100644 --- a/storage/filesystem/shallow.go +++ b/storage/filesystem/shallow.go @@ -4,9 +4,9 @@ import ( "bufio" "fmt" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/storage/filesystem/dotgit" - "github.com/go-git/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/storage/filesystem/dotgit" + "github.com/jesseduffield/go-git/v5/utils/ioutil" ) // ShallowStorage where the shallow commits are stored, an internal to diff --git a/storage/filesystem/storage.go b/storage/filesystem/storage.go index 951ea00c8..83271094e 100644 --- a/storage/filesystem/storage.go +++ b/storage/filesystem/storage.go @@ -2,8 +2,8 @@ package filesystem import ( - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/storage/filesystem/dotgit" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/storage/filesystem/dotgit" "github.com/go-git/go-billy/v5" ) @@ -50,18 +50,22 @@ func NewStorage(fs billy.Filesystem, cache cache.Object) *Storage { // NewStorageWithOptions returns a new Storage with extra options, // backed by a given `fs.Filesystem` and cache. -func NewStorageWithOptions(fs billy.Filesystem, cache cache.Object, ops Options) *Storage { +func NewStorageWithOptions(fs billy.Filesystem, c cache.Object, ops Options) *Storage { dirOps := dotgit.Options{ ExclusiveAccess: ops.ExclusiveAccess, AlternatesFS: ops.AlternatesFS, } dir := dotgit.NewWithOptions(fs, dirOps) + if c == nil { + c = cache.NewObjectLRUDefault() + } + return &Storage{ fs: fs, dir: dir, - ObjectStorage: *NewObjectStorageWithOptions(dir, cache, ops), + ObjectStorage: *NewObjectStorageWithOptions(dir, c, ops), ReferenceStorage: ReferenceStorage{dir: dir}, IndexStorage: IndexStorage{dir: dir}, ShallowStorage: ShallowStorage{dir: dir}, diff --git a/storage/filesystem/storage_test.go b/storage/filesystem/storage_test.go index 096c37af6..c63a5f5e4 100644 --- a/storage/filesystem/storage_test.go +++ b/storage/filesystem/storage_test.go @@ -1,82 +1,44 @@ -package filesystem +package filesystem_test import ( "testing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage/test" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/stretchr/testify/assert" - "github.com/go-git/go-billy/v5" "github.com/go-git/go-billy/v5/memfs" "github.com/go-git/go-billy/v5/osfs" - "github.com/go-git/go-billy/v5/util" - . "gopkg.in/check.v1" ) -func Test(t *testing.T) { TestingT(t) } - -type StorageSuite struct { - test.BaseStorageSuite - dir string - fs billy.Filesystem -} - -var _ = Suite(&StorageSuite{}) - -func (s *StorageSuite) SetUpTest(c *C) { - tmp, err := util.TempDir(osfs.Default, "", "go-git-filestystem-config") - c.Assert(err, IsNil) - - s.dir = tmp - s.fs = osfs.New(s.dir) - storage := NewStorage(s.fs, cache.NewObjectLRUDefault()) - - setUpTest(s, c, storage) -} - -func setUpTest(s *StorageSuite, c *C, storage *Storage) { - // ensure that right interfaces are implemented - var _ storer.EncodedObjectStorer = storage - var _ storer.IndexStorer = storage - var _ storer.ReferenceStorer = storage - var _ storer.ShallowStorer = storage - var _ storer.DeltaObjectStorer = storage - var _ storer.PackfileWriter = storage - - s.BaseStorageSuite = test.NewBaseStorageSuite(storage) -} - -func (s *StorageSuite) TestFilesystem(c *C) { - fs := memfs.New() - storage := NewStorage(fs, cache.NewObjectLRUDefault()) - - c.Assert(storage.Filesystem(), Equals, fs) -} - -func (s *StorageSuite) TestNewStorageShouldNotAddAnyContentsToDir(c *C) { - fis, err := s.fs.ReadDir("/") - c.Assert(err, IsNil) - c.Assert(fis, HasLen, 0) -} +var ( + fs = memfs.New() + sto = filesystem.NewStorage(fs, cache.NewObjectLRUDefault()) + + // Ensure interfaces are implemented. + _ storer.EncodedObjectStorer = sto + _ storer.IndexStorer = sto + _ storer.ReferenceStorer = sto + _ storer.ShallowStorer = sto + _ storer.DeltaObjectStorer = sto + _ storer.PackfileWriter = sto +) -type StorageExclusiveSuite struct { - StorageSuite +func TestFilesystem(t *testing.T) { + assert.Same(t, fs, sto.Filesystem()) } -var _ = Suite(&StorageExclusiveSuite{}) - -func (s *StorageExclusiveSuite) SetUpTest(c *C) { - tmp, err := util.TempDir(osfs.Default, "", "go-git-filestystem-config") - c.Assert(err, IsNil) - - s.dir = tmp - s.fs = osfs.New(s.dir) +func TestNewStorageShouldNotAddAnyContentsToDir(t *testing.T) { + fs := osfs.New(t.TempDir()) - storage := NewStorageWithOptions( - s.fs, + sto := filesystem.NewStorageWithOptions( + fs, cache.NewObjectLRUDefault(), - Options{ExclusiveAccess: true}) + filesystem.Options{ExclusiveAccess: true}) + assert.NotNil(t, sto) - setUpTest(&s.StorageSuite, c, storage) + fis, err := fs.ReadDir("/") + assert.NoError(t, err) + assert.Len(t, fis, 0) } diff --git a/storage/memory/storage.go b/storage/memory/storage.go index 79211c7c0..2092012fd 100644 --- a/storage/memory/storage.go +++ b/storage/memory/storage.go @@ -3,13 +3,15 @@ package memory import ( "fmt" + "io" "time" - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/index" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/index" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage" + "github.com/jesseduffield/go-git/v5/utils/ioutil" ) var ErrUnsupportedObjectType = fmt.Errorf("unsupported object type") @@ -90,6 +92,39 @@ type ObjectStorage struct { Tags map[plumbing.Hash]plumbing.EncodedObject } +type lazyCloser struct { + storage *ObjectStorage + obj plumbing.EncodedObject + closer io.Closer +} + +func (c *lazyCloser) Close() error { + err := c.closer.Close() + if err != nil { + return fmt.Errorf("failed to close memory encoded object: %w", err) + } + + _, err = c.storage.SetEncodedObject(c.obj) + return err +} + +func (o *ObjectStorage) RawObjectWriter(typ plumbing.ObjectType, sz int64) (w io.WriteCloser, err error) { + obj := o.NewEncodedObject() + obj.SetType(typ) + obj.SetSize(sz) + + w, err = obj.Writer() + if err != nil { + return nil, err + } + + wc := ioutil.NewWriteCloser(w, + &lazyCloser{storage: o, obj: obj, closer: w}, + ) + + return wc, nil +} + func (o *ObjectStorage) NewEncodedObject() plumbing.EncodedObject { return &plumbing.MemoryObject{} } diff --git a/storage/memory/storage_test.go b/storage/memory/storage_test.go deleted file mode 100644 index a634d5d75..000000000 --- a/storage/memory/storage_test.go +++ /dev/null @@ -1,20 +0,0 @@ -package memory - -import ( - "testing" - - "github.com/go-git/go-git/v5/storage/test" - . "gopkg.in/check.v1" -) - -func Test(t *testing.T) { TestingT(t) } - -type StorageSuite struct { - test.BaseStorageSuite -} - -var _ = Suite(&StorageSuite{}) - -func (s *StorageSuite) SetUpTest(c *C) { - s.BaseStorageSuite = test.NewBaseStorageSuite(NewStorage()) -} diff --git a/storage/storer.go b/storage/storer.go index 4800ac7ba..4ae5ece4a 100644 --- a/storage/storer.go +++ b/storage/storer.go @@ -3,8 +3,8 @@ package storage import ( "errors" - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/plumbing/storer" ) var ErrReferenceHasChanged = errors.New("reference has changed concurrently") diff --git a/storage/test/storage_suite.go b/storage/test/storage_suite.go deleted file mode 100644 index ee67fc791..000000000 --- a/storage/test/storage_suite.go +++ /dev/null @@ -1,529 +0,0 @@ -package test - -import ( - "encoding/hex" - "errors" - "fmt" - "io" - - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/index" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage" - - fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" -) - -type Storer interface { - storer.EncodedObjectStorer - storer.ReferenceStorer - storer.ShallowStorer - storer.IndexStorer - config.ConfigStorer - storage.ModuleStorer -} - -type TestObject struct { - Object plumbing.EncodedObject - Hash string - Type plumbing.ObjectType -} - -type BaseStorageSuite struct { - Storer Storer - - validTypes []plumbing.ObjectType - testObjects map[plumbing.ObjectType]TestObject -} - -func NewBaseStorageSuite(s Storer) BaseStorageSuite { - commit := &plumbing.MemoryObject{} - commit.SetType(plumbing.CommitObject) - tree := &plumbing.MemoryObject{} - tree.SetType(plumbing.TreeObject) - blob := &plumbing.MemoryObject{} - blob.SetType(plumbing.BlobObject) - tag := &plumbing.MemoryObject{} - tag.SetType(plumbing.TagObject) - - return BaseStorageSuite{ - Storer: s, - validTypes: []plumbing.ObjectType{ - plumbing.CommitObject, - plumbing.BlobObject, - plumbing.TagObject, - plumbing.TreeObject, - }, - testObjects: map[plumbing.ObjectType]TestObject{ - plumbing.CommitObject: {commit, "dcf5b16e76cce7425d0beaef62d79a7d10fce1f5", plumbing.CommitObject}, - plumbing.TreeObject: {tree, "4b825dc642cb6eb9a060e54bf8d69288fbee4904", plumbing.TreeObject}, - plumbing.BlobObject: {blob, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", plumbing.BlobObject}, - plumbing.TagObject: {tag, "d994c6bb648123a17e8f70a966857c546b2a6f94", plumbing.TagObject}, - }} -} - -func (s *BaseStorageSuite) TearDownTest(c *C) { - fixtures.Clean() -} - -func (s *BaseStorageSuite) TestSetEncodedObjectAndEncodedObject(c *C) { - for _, to := range s.testObjects { - comment := Commentf("failed for type %s", to.Type.String()) - - h, err := s.Storer.SetEncodedObject(to.Object) - c.Assert(err, IsNil) - c.Assert(h.String(), Equals, to.Hash, comment) - - o, err := s.Storer.EncodedObject(to.Type, h) - c.Assert(err, IsNil) - c.Assert(objectEquals(o, to.Object), IsNil) - - o, err = s.Storer.EncodedObject(plumbing.AnyObject, h) - c.Assert(err, IsNil) - c.Assert(objectEquals(o, to.Object), IsNil) - - for _, t := range s.validTypes { - if t == to.Type { - continue - } - - o, err = s.Storer.EncodedObject(t, h) - c.Assert(o, IsNil) - c.Assert(err, Equals, plumbing.ErrObjectNotFound) - } - } -} - -func (s *BaseStorageSuite) TestSetEncodedObjectInvalid(c *C) { - o := s.Storer.NewEncodedObject() - o.SetType(plumbing.REFDeltaObject) - - _, err := s.Storer.SetEncodedObject(o) - c.Assert(err, NotNil) -} - -func (s *BaseStorageSuite) TestIterEncodedObjects(c *C) { - for _, o := range s.testObjects { - h, err := s.Storer.SetEncodedObject(o.Object) - c.Assert(err, IsNil) - c.Assert(h, Equals, o.Object.Hash()) - } - - for _, t := range s.validTypes { - comment := Commentf("failed for type %s)", t.String()) - i, err := s.Storer.IterEncodedObjects(t) - c.Assert(err, IsNil, comment) - - o, err := i.Next() - c.Assert(err, IsNil) - c.Assert(objectEquals(o, s.testObjects[t].Object), IsNil) - - o, err = i.Next() - c.Assert(o, IsNil) - c.Assert(err, Equals, io.EOF, comment) - } - - i, err := s.Storer.IterEncodedObjects(plumbing.AnyObject) - c.Assert(err, IsNil) - - foundObjects := []plumbing.EncodedObject{} - i.ForEach(func(o plumbing.EncodedObject) error { - foundObjects = append(foundObjects, o) - return nil - }) - - c.Assert(foundObjects, HasLen, len(s.testObjects)) - for _, to := range s.testObjects { - found := false - for _, o := range foundObjects { - if to.Object.Hash() == o.Hash() { - found = true - break - } - } - c.Assert(found, Equals, true, Commentf("Object of type %s not found", to.Type.String())) - } -} - -func (s *BaseStorageSuite) TestPackfileWriter(c *C) { - pwr, ok := s.Storer.(storer.PackfileWriter) - if !ok { - c.Skip("not a storer.PackWriter") - } - - pw, err := pwr.PackfileWriter() - c.Assert(err, IsNil) - - f := fixtures.Basic().One() - _, err = io.Copy(pw, f.Packfile()) - c.Assert(err, IsNil) - - err = pw.Close() - c.Assert(err, IsNil) - - iter, err := s.Storer.IterEncodedObjects(plumbing.AnyObject) - c.Assert(err, IsNil) - objects := 0 - err = iter.ForEach(func(plumbing.EncodedObject) error { - objects++ - return nil - }) - c.Assert(err, IsNil) - c.Assert(objects, Equals, 31) -} - -func (s *BaseStorageSuite) TestObjectStorerTxSetEncodedObjectAndCommit(c *C) { - storer, ok := s.Storer.(storer.Transactioner) - if !ok { - c.Skip("not a plumbing.ObjectStorerTx") - } - - tx := storer.Begin() - for _, o := range s.testObjects { - h, err := tx.SetEncodedObject(o.Object) - c.Assert(err, IsNil) - c.Assert(h.String(), Equals, o.Hash) - } - - iter, err := s.Storer.IterEncodedObjects(plumbing.AnyObject) - c.Assert(err, IsNil) - _, err = iter.Next() - c.Assert(err, Equals, io.EOF) - - err = tx.Commit() - c.Assert(err, IsNil) - - iter, err = s.Storer.IterEncodedObjects(plumbing.AnyObject) - c.Assert(err, IsNil) - - var count int - iter.ForEach(func(o plumbing.EncodedObject) error { - count++ - return nil - }) - - c.Assert(count, Equals, 4) -} - -func (s *BaseStorageSuite) TestObjectStorerTxSetObjectAndGetObject(c *C) { - storer, ok := s.Storer.(storer.Transactioner) - if !ok { - c.Skip("not a plumbing.ObjectStorerTx") - } - - tx := storer.Begin() - for _, expected := range s.testObjects { - h, err := tx.SetEncodedObject(expected.Object) - c.Assert(err, IsNil) - c.Assert(h.String(), Equals, expected.Hash) - - o, err := tx.EncodedObject(expected.Type, plumbing.NewHash(expected.Hash)) - c.Assert(err, IsNil) - c.Assert(o.Hash().String(), DeepEquals, expected.Hash) - } -} - -func (s *BaseStorageSuite) TestObjectStorerTxGetObjectNotFound(c *C) { - storer, ok := s.Storer.(storer.Transactioner) - if !ok { - c.Skip("not a plumbing.ObjectStorerTx") - } - - tx := storer.Begin() - o, err := tx.EncodedObject(plumbing.AnyObject, plumbing.ZeroHash) - c.Assert(o, IsNil) - c.Assert(err, Equals, plumbing.ErrObjectNotFound) -} - -func (s *BaseStorageSuite) TestObjectStorerTxSetObjectAndRollback(c *C) { - storer, ok := s.Storer.(storer.Transactioner) - if !ok { - c.Skip("not a plumbing.ObjectStorerTx") - } - - tx := storer.Begin() - for _, o := range s.testObjects { - h, err := tx.SetEncodedObject(o.Object) - c.Assert(err, IsNil) - c.Assert(h.String(), Equals, o.Hash) - } - - err := tx.Rollback() - c.Assert(err, IsNil) - - iter, err := s.Storer.IterEncodedObjects(plumbing.AnyObject) - c.Assert(err, IsNil) - _, err = iter.Next() - c.Assert(err, Equals, io.EOF) -} - -func (s *BaseStorageSuite) TestSetReferenceAndGetReference(c *C) { - err := s.Storer.SetReference( - plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"), - ) - c.Assert(err, IsNil) - - err = s.Storer.SetReference( - plumbing.NewReferenceFromStrings("bar", "482e0eada5de4039e6f216b45b3c9b683b83bfa"), - ) - c.Assert(err, IsNil) - - e, err := s.Storer.Reference(plumbing.ReferenceName("foo")) - c.Assert(err, IsNil) - c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52") -} - -func (s *BaseStorageSuite) TestCheckAndSetReference(c *C) { - err := s.Storer.SetReference( - plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"), - ) - c.Assert(err, IsNil) - - err = s.Storer.CheckAndSetReference( - plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"), - plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"), - ) - c.Assert(err, IsNil) - - e, err := s.Storer.Reference(plumbing.ReferenceName("foo")) - c.Assert(err, IsNil) - c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52") -} - -func (s *BaseStorageSuite) TestCheckAndSetReferenceNil(c *C) { - err := s.Storer.SetReference( - plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"), - ) - c.Assert(err, IsNil) - - err = s.Storer.CheckAndSetReference( - plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"), - nil, - ) - c.Assert(err, IsNil) - - e, err := s.Storer.Reference(plumbing.ReferenceName("foo")) - c.Assert(err, IsNil) - c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52") -} - -func (s *BaseStorageSuite) TestCheckAndSetReferenceError(c *C) { - err := s.Storer.SetReference( - plumbing.NewReferenceFromStrings("foo", "c3f4688a08fd86f1bf8e055724c84b7a40a09733"), - ) - c.Assert(err, IsNil) - - err = s.Storer.CheckAndSetReference( - plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"), - plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"), - ) - c.Assert(err, Equals, storage.ErrReferenceHasChanged) - - e, err := s.Storer.Reference(plumbing.ReferenceName("foo")) - c.Assert(err, IsNil) - c.Assert(e.Hash().String(), Equals, "c3f4688a08fd86f1bf8e055724c84b7a40a09733") -} - -func (s *BaseStorageSuite) TestRemoveReference(c *C) { - err := s.Storer.SetReference( - plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"), - ) - c.Assert(err, IsNil) - - err = s.Storer.RemoveReference(plumbing.ReferenceName("foo")) - c.Assert(err, IsNil) - - _, err = s.Storer.Reference(plumbing.ReferenceName("foo")) - c.Assert(err, Equals, plumbing.ErrReferenceNotFound) -} - -func (s *BaseStorageSuite) TestRemoveReferenceNonExistent(c *C) { - err := s.Storer.SetReference( - plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"), - ) - c.Assert(err, IsNil) - - err = s.Storer.RemoveReference(plumbing.ReferenceName("nonexistent")) - c.Assert(err, IsNil) - - e, err := s.Storer.Reference(plumbing.ReferenceName("foo")) - c.Assert(err, IsNil) - c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52") -} - -func (s *BaseStorageSuite) TestGetReferenceNotFound(c *C) { - r, err := s.Storer.Reference(plumbing.ReferenceName("bar")) - c.Assert(err, Equals, plumbing.ErrReferenceNotFound) - c.Assert(r, IsNil) -} - -func (s *BaseStorageSuite) TestIterReferences(c *C) { - err := s.Storer.SetReference( - plumbing.NewReferenceFromStrings("refs/foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"), - ) - c.Assert(err, IsNil) - - i, err := s.Storer.IterReferences() - c.Assert(err, IsNil) - - e, err := i.Next() - c.Assert(err, IsNil) - c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52") - - e, err = i.Next() - c.Assert(e, IsNil) - c.Assert(err, Equals, io.EOF) -} - -func (s *BaseStorageSuite) TestSetShallowAndShallow(c *C) { - expected := []plumbing.Hash{ - plumbing.NewHash("b66c08ba28aa1f81eb06a1127aa3936ff77e5e2c"), - plumbing.NewHash("c3f4688a08fd86f1bf8e055724c84b7a40a09733"), - plumbing.NewHash("c78874f116be67ecf54df225a613162b84cc6ebf"), - } - - err := s.Storer.SetShallow(expected) - c.Assert(err, IsNil) - - result, err := s.Storer.Shallow() - c.Assert(err, IsNil) - c.Assert(result, DeepEquals, expected) -} - -func (s *BaseStorageSuite) TestSetConfigAndConfig(c *C) { - expected := config.NewConfig() - expected.Core.IsBare = true - expected.Remotes["foo"] = &config.RemoteConfig{ - Name: "foo", - URLs: []string{"http://foo/bar.git"}, - } - - err := s.Storer.SetConfig(expected) - c.Assert(err, IsNil) - - cfg, err := s.Storer.Config() - c.Assert(err, IsNil) - - c.Assert(cfg.Core.IsBare, DeepEquals, expected.Core.IsBare) - c.Assert(cfg.Remotes, DeepEquals, expected.Remotes) -} - -func (s *BaseStorageSuite) TestIndex(c *C) { - expected := &index.Index{} - expected.Version = 2 - - idx, err := s.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx, DeepEquals, expected) -} - -func (s *BaseStorageSuite) TestSetIndexAndIndex(c *C) { - expected := &index.Index{} - expected.Version = 2 - - err := s.Storer.SetIndex(expected) - c.Assert(err, IsNil) - - idx, err := s.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx, DeepEquals, expected) -} - -func (s *BaseStorageSuite) TestSetConfigInvalid(c *C) { - cfg := config.NewConfig() - cfg.Remotes["foo"] = &config.RemoteConfig{} - - err := s.Storer.SetConfig(cfg) - c.Assert(err, NotNil) -} - -func (s *BaseStorageSuite) TestModule(c *C) { - storer, err := s.Storer.Module("foo") - c.Assert(err, IsNil) - c.Assert(storer, NotNil) - - storer, err = s.Storer.Module("foo") - c.Assert(err, IsNil) - c.Assert(storer, NotNil) -} - -func (s *BaseStorageSuite) TestDeltaObjectStorer(c *C) { - dos, ok := s.Storer.(storer.DeltaObjectStorer) - if !ok { - c.Skip("not an DeltaObjectStorer") - } - - pwr, ok := s.Storer.(storer.PackfileWriter) - if !ok { - c.Skip("not a storer.PackWriter") - } - - pw, err := pwr.PackfileWriter() - c.Assert(err, IsNil) - - f := fixtures.Basic().One() - _, err = io.Copy(pw, f.Packfile()) - c.Assert(err, IsNil) - - err = pw.Close() - c.Assert(err, IsNil) - - h := plumbing.NewHash("32858aad3c383ed1ff0a0f9bdf231d54a00c9e88") - obj, err := dos.DeltaObject(plumbing.AnyObject, h) - c.Assert(err, IsNil) - c.Assert(obj.Type(), Equals, plumbing.BlobObject) - - h = plumbing.NewHash("aa9b383c260e1d05fbbf6b30a02914555e20c725") - obj, err = dos.DeltaObject(plumbing.AnyObject, h) - c.Assert(err, IsNil) - c.Assert(obj.Type(), Equals, plumbing.OFSDeltaObject) - _, ok = obj.(plumbing.DeltaObject) - c.Assert(ok, Equals, true) -} - -func objectEquals(a plumbing.EncodedObject, b plumbing.EncodedObject) error { - ha := a.Hash() - hb := b.Hash() - if ha != hb { - return fmt.Errorf("hashes do not match: %s != %s", - ha.String(), hb.String()) - } - - ra, err := a.Reader() - if err != nil { - return fmt.Errorf("can't get reader on a: %q", err) - } - - rb, err := b.Reader() - if err != nil { - return fmt.Errorf("can't get reader on b: %q", err) - } - - ca, err := io.ReadAll(ra) - if err != nil { - return fmt.Errorf("error reading a: %q", err) - } - - cb, err := io.ReadAll(rb) - if err != nil { - return fmt.Errorf("error reading b: %q", err) - } - - if hex.EncodeToString(ca) != hex.EncodeToString(cb) { - return errors.New("content does not match") - } - - err = rb.Close() - if err != nil { - return fmt.Errorf("can't close reader on b: %q", err) - } - - err = ra.Close() - if err != nil { - return fmt.Errorf("can't close reader on a: %q", err) - } - - return nil -} diff --git a/storage/tests/storage_test.go b/storage/tests/storage_test.go new file mode 100644 index 000000000..c39cd7a7c --- /dev/null +++ b/storage/tests/storage_test.go @@ -0,0 +1,598 @@ +package tests + +import ( + "fmt" + "io" + "testing" + + "github.com/go-git/go-billy/v5/memfs" + "github.com/go-git/go-billy/v5/osfs" + fixtures "github.com/go-git/go-git-fixtures/v5" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/format/index" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/jesseduffield/go-git/v5/storage/transactional" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +type Storer interface { + storer.EncodedObjectStorer + storer.ReferenceStorer + storer.ShallowStorer + storer.IndexStorer + config.ConfigStorer + storage.ModuleStorer +} + +type TestObject struct { + Object plumbing.EncodedObject + Hash string + Type plumbing.ObjectType +} + +func testObjects() map[plumbing.ObjectType]TestObject { + commit := &plumbing.MemoryObject{} + commit.SetType(plumbing.CommitObject) + tree := &plumbing.MemoryObject{} + tree.SetType(plumbing.TreeObject) + blob := &plumbing.MemoryObject{} + blob.SetType(plumbing.BlobObject) + tag := &plumbing.MemoryObject{} + tag.SetType(plumbing.TagObject) + + return map[plumbing.ObjectType]TestObject{ + plumbing.CommitObject: {commit, "dcf5b16e76cce7425d0beaef62d79a7d10fce1f5", plumbing.CommitObject}, + plumbing.TreeObject: {tree, "4b825dc642cb6eb9a060e54bf8d69288fbee4904", plumbing.TreeObject}, + plumbing.BlobObject: {blob, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", plumbing.BlobObject}, + plumbing.TagObject: {tag, "d994c6bb648123a17e8f70a966857c546b2a6f94", plumbing.TagObject}, + } +} + +func validTypes() []plumbing.ObjectType { + return []plumbing.ObjectType{ + plumbing.CommitObject, + plumbing.BlobObject, + plumbing.TagObject, + plumbing.TreeObject, + } +} + +var storageFactories = []func(t *testing.T) (Storer, string){ + func(_ *testing.T) (Storer, string) { return memory.NewStorage(), "memory" }, + func(t *testing.T) (Storer, string) { + return filesystem.NewStorage(osfs.New(t.TempDir()), nil), "filesystem" + }, + func(t *testing.T) (Storer, string) { + temporal := filesystem.NewStorage(memfs.New(), cache.NewObjectLRUDefault()) + base := memory.NewStorage() + + return transactional.NewStorage(base, temporal), "transactional" + }, +} + +func forEachStorage(t *testing.T, tc func(sto Storer, t *testing.T)) { + for _, factory := range storageFactories { + sto, name := factory(t) + + t.Run(name, func(t *testing.T) { + tc(sto, t) + }) + } +} + +func TestPackfileWriter(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + pwr, ok := sto.(storer.PackfileWriter) + if !ok { + t.Skip("not a PackfileWriter") + } + + pw, err := pwr.PackfileWriter() + assert.NoError(t, err) + + f := fixtures.Basic().One() + _, err = io.Copy(pw, f.Packfile()) + assert.NoError(t, err) + + err = pw.Close() + assert.NoError(t, err) + + iter, err := sto.IterEncodedObjects(plumbing.AnyObject) + assert.NoError(t, err) + objects := 0 + + err = iter.ForEach(func(plumbing.EncodedObject) error { + objects++ + return nil + }) + + assert.NoError(t, err) + assert.Equal(t, 31, objects) + }) +} + +func TestDeltaObjectStorer(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + dos, ok := sto.(storer.DeltaObjectStorer) + if !ok { + t.Skip("not an DeltaObjectStorer") + } + + pwr, ok := sto.(storer.PackfileWriter) + if !ok { + t.Skip("not a storer.PackWriter") + } + + pw, err := pwr.PackfileWriter() + require.NoError(t, err) + + f := fixtures.Basic().One() + _, err = io.Copy(pw, f.Packfile()) + require.NoError(t, err) + + err = pw.Close() + require.NoError(t, err) + + h := plumbing.NewHash("32858aad3c383ed1ff0a0f9bdf231d54a00c9e88") + obj, err := dos.DeltaObject(plumbing.AnyObject, h) + require.NoError(t, err) + assert.Equal(t, plumbing.BlobObject, obj.Type()) + + h = plumbing.NewHash("aa9b383c260e1d05fbbf6b30a02914555e20c725") + obj, err = dos.DeltaObject(plumbing.AnyObject, h) + require.NoError(t, err) + assert.Equal(t, plumbing.OFSDeltaObject.String(), obj.Type().String()) + + _, ok = obj.(plumbing.DeltaObject) + assert.True(t, ok) + }) +} + +func TestSetEncodedObjectAndEncodedObject(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + for _, to := range testObjects() { + comment := fmt.Sprintf("failed for type %s", to.Type.String()) + + h, err := sto.SetEncodedObject(to.Object) + require.NoError(t, err) + require.Equal(t, to.Hash, h.String(), comment) + + o, err := sto.EncodedObject(to.Type, h) + require.NoError(t, err) + assert.Equal(t, to.Object, o) + + o, err = sto.EncodedObject(plumbing.AnyObject, h) + require.NoError(t, err) + assert.Equal(t, to.Object, o) + + for _, typ := range validTypes() { + if typ == to.Type { + continue + } + + o, err = sto.EncodedObject(typ, h) + assert.Nil(t, o) + assert.ErrorIs(t, err, plumbing.ErrObjectNotFound) + } + } + }) +} + +func TestSetEncodedObjectInvalid(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + o := sto.NewEncodedObject() + o.SetType(plumbing.REFDeltaObject) + + _, err := sto.SetEncodedObject(o) + assert.Error(t, err) + }) +} + +func TestIterEncodedObjects(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + objs := testObjects() + for _, o := range objs { + h, err := sto.SetEncodedObject(o.Object) + require.NoError(t, err) + assert.Equal(t, o.Object.Hash(), h) + } + + for _, typ := range validTypes() { + comment := fmt.Sprintf("failed for type %s)", typ.String()) + i, err := sto.IterEncodedObjects(typ) + require.NoError(t, err, comment) + + o, err := i.Next() + require.NoError(t, err) + assert.Equal(t, objs[typ].Object, o) + + o, err = i.Next() + assert.Nil(t, o) + assert.ErrorIs(t, err, io.EOF, comment) + } + + i, err := sto.IterEncodedObjects(plumbing.AnyObject) + require.NoError(t, err) + + foundObjects := []plumbing.EncodedObject{} + i.ForEach(func(o plumbing.EncodedObject) error { + foundObjects = append(foundObjects, o) + return nil + }) + + assert.Len(t, foundObjects, len(testObjects())) + for _, to := range testObjects() { + found := false + for _, o := range foundObjects { + if to.Object.Hash() == o.Hash() { + found = true + break + } + } + assert.True(t, found, "Object of type %s not found", to.Type.String()) + } + }) +} + +func TestObjectStorerTxSetEncodedObjectAndCommit(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + storer, ok := sto.(storer.Transactioner) + if !ok { + t.Skip("not a plumbing.ObjectStorerTx") + } + + tx := storer.Begin() + for _, o := range testObjects() { + h, err := tx.SetEncodedObject(o.Object) + require.NoError(t, err) + assert.Equal(t, o.Hash, h.String()) + } + + iter, err := sto.IterEncodedObjects(plumbing.AnyObject) + require.NoError(t, err) + _, err = iter.Next() + assert.ErrorIs(t, err, io.EOF) + + err = tx.Commit() + require.NoError(t, err) + + iter, err = sto.IterEncodedObjects(plumbing.AnyObject) + require.NoError(t, err) + + var count int + iter.ForEach(func(o plumbing.EncodedObject) error { + count++ + return nil + }) + + assert.Equal(t, 4, count) + }) +} + +func TestObjectStorerTxSetObjectAndGetObject(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + storer, ok := sto.(storer.Transactioner) + if !ok { + t.Skip("not a plumbing.ObjectStorerTx") + } + + tx := storer.Begin() + for _, expected := range testObjects() { + h, err := tx.SetEncodedObject(expected.Object) + require.NoError(t, err) + assert.Equal(t, expected.Hash, h.String()) + + o, err := tx.EncodedObject(expected.Type, plumbing.NewHash(expected.Hash)) + require.NoError(t, err) + assert.Equal(t, expected.Hash, o.Hash().String()) + } + }) +} + +func TestObjectStorerTxGetObjectNotFound(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + storer, ok := sto.(storer.Transactioner) + if !ok { + t.Skip("not a plumbing.ObjectStorerTx") + } + + tx := storer.Begin() + o, err := tx.EncodedObject(plumbing.AnyObject, plumbing.ZeroHash) + assert.Nil(t, o) + assert.ErrorIs(t, err, plumbing.ErrObjectNotFound) + }) +} + +func TestObjectStorerTxSetObjectAndRollback(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + storer, ok := sto.(storer.Transactioner) + if !ok { + t.Skip("not a plumbing.ObjectStorerTx") + } + + tx := storer.Begin() + for _, o := range testObjects() { + h, err := tx.SetEncodedObject(o.Object) + require.NoError(t, err) + assert.Equal(t, o.Hash, h.String()) + } + + err := tx.Rollback() + require.NoError(t, err) + + iter, err := sto.IterEncodedObjects(plumbing.AnyObject) + require.NoError(t, err) + _, err = iter.Next() + assert.ErrorIs(t, err, io.EOF) + }) +} + +func TestSetReferenceAndGetReference(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + err := sto.SetReference( + plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"), + ) + require.NoError(t, err) + + err = sto.SetReference( + plumbing.NewReferenceFromStrings("bar", "482e0eada5de4039e6f216b45b3c9b683b83bfa"), + ) + require.NoError(t, err) + + e, err := sto.Reference(plumbing.ReferenceName("foo")) + require.NoError(t, err) + assert.Equal(t, e.Hash().String(), "bc9968d75e48de59f0870ffb71f5e160bbbdcf52") + }) +} + +func TestCheckAndSetReference(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + err := sto.SetReference( + plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"), + ) + require.NoError(t, err) + + err = sto.CheckAndSetReference( + plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"), + plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"), + ) + require.NoError(t, err) + + e, err := sto.Reference(plumbing.ReferenceName("foo")) + require.NoError(t, err) + assert.Equal(t, e.Hash().String(), "bc9968d75e48de59f0870ffb71f5e160bbbdcf52") + }) +} + +func TestCheckAndSetReferenceNil(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + err := sto.SetReference( + plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"), + ) + require.NoError(t, err) + + err = sto.CheckAndSetReference( + plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"), + nil, + ) + require.NoError(t, err) + + e, err := sto.Reference(plumbing.ReferenceName("foo")) + require.NoError(t, err) + assert.Equal(t, e.Hash().String(), "bc9968d75e48de59f0870ffb71f5e160bbbdcf52") + }) +} + +func TestCheckAndSetReferenceError(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + err := sto.SetReference( + plumbing.NewReferenceFromStrings("foo", "c3f4688a08fd86f1bf8e055724c84b7a40a09733"), + ) + require.NoError(t, err) + + err = sto.CheckAndSetReference( + plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"), + plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"), + ) + assert.ErrorIs(t, err, storage.ErrReferenceHasChanged) + + e, err := sto.Reference(plumbing.ReferenceName("foo")) + require.NoError(t, err) + assert.Equal(t, e.Hash().String(), "c3f4688a08fd86f1bf8e055724c84b7a40a09733") + }) +} + +func TestRemoveReference(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + err := sto.SetReference( + plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"), + ) + require.NoError(t, err) + + err = sto.RemoveReference(plumbing.ReferenceName("foo")) + require.NoError(t, err) + + _, err = sto.Reference(plumbing.ReferenceName("foo")) + assert.ErrorIs(t, err, plumbing.ErrReferenceNotFound) + }) +} + +func TestRemoveReferenceNonExistent(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + err := sto.SetReference( + plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"), + ) + require.NoError(t, err) + + err = sto.RemoveReference(plumbing.ReferenceName("nonexistent")) + require.NoError(t, err) + + e, err := sto.Reference(plumbing.ReferenceName("foo")) + require.NoError(t, err) + assert.Equal(t, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52", e.Hash().String()) + }) +} + +func TestGetReferenceNotFound(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + r, err := sto.Reference(plumbing.ReferenceName("bar")) + assert.ErrorIs(t, err, plumbing.ErrReferenceNotFound) + assert.Nil(t, r) + }) +} + +func TestIterReferences(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + err := sto.SetReference( + plumbing.NewReferenceFromStrings("refs/foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"), + ) + require.NoError(t, err) + + i, err := sto.IterReferences() + require.NoError(t, err) + + e, err := i.Next() + require.NoError(t, err) + assert.Equal(t, e.Hash().String(), "bc9968d75e48de59f0870ffb71f5e160bbbdcf52") + + e, err = i.Next() + assert.Nil(t, e) + assert.ErrorIs(t, err, io.EOF) + }) +} + +func TestSetShallowAndShallow(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + expected := []plumbing.Hash{ + plumbing.NewHash("b66c08ba28aa1f81eb06a1127aa3936ff77e5e2c"), + plumbing.NewHash("c3f4688a08fd86f1bf8e055724c84b7a40a09733"), + plumbing.NewHash("c78874f116be67ecf54df225a613162b84cc6ebf"), + } + + err := sto.SetShallow(expected) + require.NoError(t, err) + + result, err := sto.Shallow() + require.NoError(t, err) + assert.Equal(t, expected, result) + }) +} + +func TestSetConfigAndConfig(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + expected := config.NewConfig() + expected.Core.IsBare = true + expected.Remotes["foo"] = &config.RemoteConfig{ + Name: "foo", + URLs: []string{"http://foo/bar.git"}, + } + + err := sto.SetConfig(expected) + require.NoError(t, err) + + cfg, err := sto.Config() + require.NoError(t, err) + + assert.Equal(t, expected.Core.IsBare, cfg.Core.IsBare) + assert.Equal(t, expected.Remotes, cfg.Remotes) + }) +} + +func TestIndex(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + expected := &index.Index{} + expected.Version = 2 + + idx, err := sto.Index() + assert.NoError(t, err) + assert.Equal(t, expected, idx) + }) +} + +func TestSetIndexAndIndex(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + expected := &index.Index{} + expected.Version = 2 + + err := sto.SetIndex(expected) + require.NoError(t, err) + + idx, err := sto.Index() + require.NoError(t, err) + assert.Equal(t, expected, idx) + }) +} + +func TestSetConfigInvalid(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + cfg := config.NewConfig() + cfg.Remotes["foo"] = &config.RemoteConfig{} + + err := sto.SetConfig(cfg) + assert.Error(t, err) + }) +} + +func TestModule(t *testing.T) { + t.Parallel() + + forEachStorage(t, func(sto Storer, t *testing.T) { + storer, err := sto.Module("foo") + require.NoError(t, err) + assert.NotNil(t, storer) + + storer, err = sto.Module("foo") + require.NoError(t, err) + assert.NotNil(t, storer) + }) +} diff --git a/storage/transactional/config.go b/storage/transactional/config.go index f8c3cc291..2366e540c 100644 --- a/storage/transactional/config.go +++ b/storage/transactional/config.go @@ -1,6 +1,6 @@ package transactional -import "github.com/go-git/go-git/v5/config" +import "github.com/jesseduffield/go-git/v5/config" // ConfigStorage implements the storer.ConfigStorage for the transactional package. type ConfigStorage struct { diff --git a/storage/transactional/config_test.go b/storage/transactional/config_test.go index 34d7763f6..f1221657c 100644 --- a/storage/transactional/config_test.go +++ b/storage/transactional/config_test.go @@ -1,39 +1,44 @@ package transactional import ( - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/storage/memory" + "testing" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/suite" ) -var _ = Suite(&ConfigSuite{}) +func TestConfigSuite(t *testing.T) { + suite.Run(t, new(ConfigSuite)) +} -type ConfigSuite struct{} +type ConfigSuite struct { + suite.Suite +} -func (s *ConfigSuite) TestSetConfigBase(c *C) { +func (s *ConfigSuite) TestSetConfigBase() { cfg := config.NewConfig() cfg.Core.Worktree = "foo" base := memory.NewStorage() err := base.SetConfig(cfg) - c.Assert(err, IsNil) + s.NoError(err) temporal := memory.NewStorage() cs := NewConfigStorage(base, temporal) cfg, err = cs.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Core.Worktree, Equals, "foo") + s.NoError(err) + s.Equal("foo", cfg.Core.Worktree) } -func (s *ConfigSuite) TestSetConfigTemporal(c *C) { +func (s *ConfigSuite) TestSetConfigTemporal() { cfg := config.NewConfig() cfg.Core.Worktree = "foo" base := memory.NewStorage() err := base.SetConfig(cfg) - c.Assert(err, IsNil) + s.NoError(err) temporal := memory.NewStorage() @@ -42,28 +47,28 @@ func (s *ConfigSuite) TestSetConfigTemporal(c *C) { cs := NewConfigStorage(base, temporal) err = cs.SetConfig(cfg) - c.Assert(err, IsNil) + s.NoError(err) baseCfg, err := base.Config() - c.Assert(err, IsNil) - c.Assert(baseCfg.Core.Worktree, Equals, "foo") + s.NoError(err) + s.Equal("foo", baseCfg.Core.Worktree) temporalCfg, err := temporal.Config() - c.Assert(err, IsNil) - c.Assert(temporalCfg.Core.Worktree, Equals, "bar") + s.NoError(err) + s.Equal("bar", temporalCfg.Core.Worktree) cfg, err = cs.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Core.Worktree, Equals, "bar") + s.NoError(err) + s.Equal("bar", cfg.Core.Worktree) } -func (s *ConfigSuite) TestCommit(c *C) { +func (s *ConfigSuite) TestCommit() { cfg := config.NewConfig() cfg.Core.Worktree = "foo" base := memory.NewStorage() err := base.SetConfig(cfg) - c.Assert(err, IsNil) + s.NoError(err) temporal := memory.NewStorage() @@ -72,12 +77,12 @@ func (s *ConfigSuite) TestCommit(c *C) { cs := NewConfigStorage(base, temporal) err = cs.SetConfig(cfg) - c.Assert(err, IsNil) + s.NoError(err) err = cs.Commit() - c.Assert(err, IsNil) + s.NoError(err) baseCfg, err := base.Config() - c.Assert(err, IsNil) - c.Assert(baseCfg.Core.Worktree, Equals, "bar") + s.NoError(err) + s.Equal("bar", baseCfg.Core.Worktree) } diff --git a/storage/transactional/index.go b/storage/transactional/index.go index 70641aca0..2e0e12e69 100644 --- a/storage/transactional/index.go +++ b/storage/transactional/index.go @@ -1,8 +1,8 @@ package transactional import ( - "github.com/go-git/go-git/v5/plumbing/format/index" - "github.com/go-git/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing/format/index" + "github.com/jesseduffield/go-git/v5/plumbing/storer" ) // IndexStorage implements the storer.IndexStorage for the transactional package. diff --git a/storage/transactional/index_test.go b/storage/transactional/index_test.go index 0028c0ee2..b3e5452c3 100644 --- a/storage/transactional/index_test.go +++ b/storage/transactional/index_test.go @@ -1,39 +1,44 @@ package transactional import ( - "github.com/go-git/go-git/v5/plumbing/format/index" - "github.com/go-git/go-git/v5/storage/memory" + "testing" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing/format/index" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/suite" ) -var _ = Suite(&IndexSuite{}) +func TestIndexSuite(t *testing.T) { + suite.Run(t, new(IndexSuite)) +} -type IndexSuite struct{} +type IndexSuite struct { + suite.Suite +} -func (s *IndexSuite) TestSetIndexBase(c *C) { +func (s *IndexSuite) TestSetIndexBase() { idx := &index.Index{} idx.Version = 2 base := memory.NewStorage() err := base.SetIndex(idx) - c.Assert(err, IsNil) + s.NoError(err) temporal := memory.NewStorage() cs := NewIndexStorage(base, temporal) idx, err = cs.Index() - c.Assert(err, IsNil) - c.Assert(idx.Version, Equals, uint32(2)) + s.NoError(err) + s.Equal(uint32(2), idx.Version) } -func (s *IndexSuite) TestCommit(c *C) { +func (s *IndexSuite) TestCommit() { idx := &index.Index{} idx.Version = 2 base := memory.NewStorage() err := base.SetIndex(idx) - c.Assert(err, IsNil) + s.NoError(err) temporal := memory.NewStorage() @@ -42,12 +47,12 @@ func (s *IndexSuite) TestCommit(c *C) { is := NewIndexStorage(base, temporal) err = is.SetIndex(idx) - c.Assert(err, IsNil) + s.NoError(err) err = is.Commit() - c.Assert(err, IsNil) + s.NoError(err) baseIndex, err := base.Index() - c.Assert(err, IsNil) - c.Assert(baseIndex.Version, Equals, uint32(3)) + s.NoError(err) + s.Equal(uint32(3), baseIndex.Version) } diff --git a/storage/transactional/object.go b/storage/transactional/object.go index b43c96d3b..161271332 100644 --- a/storage/transactional/object.go +++ b/storage/transactional/object.go @@ -1,8 +1,8 @@ package transactional import ( - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" ) // ObjectStorage implements the storer.EncodedObjectStorer for the transactional package. diff --git a/storage/transactional/object_test.go b/storage/transactional/object_test.go index df277c4a1..3d4938b7d 100644 --- a/storage/transactional/object_test.go +++ b/storage/transactional/object_test.go @@ -1,17 +1,22 @@ package transactional import ( - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/storage/memory" + "testing" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/suite" ) -var _ = Suite(&ObjectSuite{}) +func TestObjectSuite(t *testing.T) { + suite.Run(t, new(ObjectSuite)) +} -type ObjectSuite struct{} +type ObjectSuite struct { + suite.Suite +} -func (s *ObjectSuite) TestHasEncodedObject(c *C) { +func (s *ObjectSuite) TestHasEncodedObject() { base := memory.NewStorage() temporal := memory.NewStorage() @@ -21,27 +26,27 @@ func (s *ObjectSuite) TestHasEncodedObject(c *C) { commit.SetType(plumbing.CommitObject) ch, err := base.SetEncodedObject(commit) - c.Assert(ch.IsZero(), Equals, false) - c.Assert(err, IsNil) + s.False(ch.IsZero()) + s.NoError(err) tree := base.NewEncodedObject() tree.SetType(plumbing.TreeObject) th, err := os.SetEncodedObject(tree) - c.Assert(th.IsZero(), Equals, false) - c.Assert(err, IsNil) + s.False(th.IsZero()) + s.NoError(err) err = os.HasEncodedObject(th) - c.Assert(err, IsNil) + s.NoError(err) err = os.HasEncodedObject(ch) - c.Assert(err, IsNil) + s.NoError(err) err = base.HasEncodedObject(th) - c.Assert(err, Equals, plumbing.ErrObjectNotFound) + s.ErrorIs(err, plumbing.ErrObjectNotFound) } -func (s *ObjectSuite) TestEncodedObjectAndEncodedObjectSize(c *C) { +func (s *ObjectSuite) TestEncodedObjectAndEncodedObjectSize() { base := memory.NewStorage() temporal := memory.NewStorage() @@ -51,40 +56,40 @@ func (s *ObjectSuite) TestEncodedObjectAndEncodedObjectSize(c *C) { commit.SetType(plumbing.CommitObject) ch, err := base.SetEncodedObject(commit) - c.Assert(ch.IsZero(), Equals, false) - c.Assert(err, IsNil) + s.False(ch.IsZero()) + s.NoError(err) tree := base.NewEncodedObject() tree.SetType(plumbing.TreeObject) th, err := os.SetEncodedObject(tree) - c.Assert(th.IsZero(), Equals, false) - c.Assert(err, IsNil) + s.False(th.IsZero()) + s.NoError(err) otree, err := os.EncodedObject(plumbing.TreeObject, th) - c.Assert(err, IsNil) - c.Assert(otree.Hash(), Equals, tree.Hash()) + s.NoError(err) + s.Equal(tree.Hash(), otree.Hash()) treeSz, err := os.EncodedObjectSize(th) - c.Assert(err, IsNil) - c.Assert(treeSz, Equals, int64(0)) + s.NoError(err) + s.Equal(int64(0), treeSz) ocommit, err := os.EncodedObject(plumbing.CommitObject, ch) - c.Assert(err, IsNil) - c.Assert(ocommit.Hash(), Equals, commit.Hash()) + s.NoError(err) + s.Equal(commit.Hash(), ocommit.Hash()) commitSz, err := os.EncodedObjectSize(ch) - c.Assert(err, IsNil) - c.Assert(commitSz, Equals, int64(0)) + s.NoError(err) + s.Equal(int64(0), commitSz) _, err = base.EncodedObject(plumbing.TreeObject, th) - c.Assert(err, Equals, plumbing.ErrObjectNotFound) + s.ErrorIs(err, plumbing.ErrObjectNotFound) _, err = base.EncodedObjectSize(th) - c.Assert(err, Equals, plumbing.ErrObjectNotFound) + s.ErrorIs(err, plumbing.ErrObjectNotFound) } -func (s *ObjectSuite) TestIterEncodedObjects(c *C) { +func (s *ObjectSuite) TestIterEncodedObjects() { base := memory.NewStorage() temporal := memory.NewStorage() @@ -94,18 +99,18 @@ func (s *ObjectSuite) TestIterEncodedObjects(c *C) { commit.SetType(plumbing.CommitObject) ch, err := base.SetEncodedObject(commit) - c.Assert(ch.IsZero(), Equals, false) - c.Assert(err, IsNil) + s.False(ch.IsZero()) + s.NoError(err) tree := base.NewEncodedObject() tree.SetType(plumbing.TreeObject) th, err := os.SetEncodedObject(tree) - c.Assert(th.IsZero(), Equals, false) - c.Assert(err, IsNil) + s.False(th.IsZero()) + s.NoError(err) iter, err := os.IterEncodedObjects(plumbing.AnyObject) - c.Assert(err, IsNil) + s.NoError(err) var hashes []plumbing.Hash err = iter.ForEach(func(obj plumbing.EncodedObject) error { @@ -113,13 +118,13 @@ func (s *ObjectSuite) TestIterEncodedObjects(c *C) { return nil }) - c.Assert(err, IsNil) - c.Assert(hashes, HasLen, 2) - c.Assert(hashes[0], Equals, ch) - c.Assert(hashes[1], Equals, th) + s.NoError(err) + s.Len(hashes, 2) + s.Equal(ch, hashes[0]) + s.Equal(th, hashes[1]) } -func (s *ObjectSuite) TestCommit(c *C) { +func (s *ObjectSuite) TestCommit() { base := memory.NewStorage() temporal := memory.NewStorage() @@ -129,19 +134,19 @@ func (s *ObjectSuite) TestCommit(c *C) { commit.SetType(plumbing.CommitObject) _, err := os.SetEncodedObject(commit) - c.Assert(err, IsNil) + s.NoError(err) tree := base.NewEncodedObject() tree.SetType(plumbing.TreeObject) _, err = os.SetEncodedObject(tree) - c.Assert(err, IsNil) + s.NoError(err) err = os.Commit() - c.Assert(err, IsNil) + s.NoError(err) iter, err := base.IterEncodedObjects(plumbing.AnyObject) - c.Assert(err, IsNil) + s.NoError(err) var hashes []plumbing.Hash err = iter.ForEach(func(obj plumbing.EncodedObject) error { @@ -149,6 +154,6 @@ func (s *ObjectSuite) TestCommit(c *C) { return nil }) - c.Assert(err, IsNil) - c.Assert(hashes, HasLen, 2) + s.NoError(err) + s.Len(hashes, 2) } diff --git a/storage/transactional/reference.go b/storage/transactional/reference.go index 1c0930755..1b579c055 100644 --- a/storage/transactional/reference.go +++ b/storage/transactional/reference.go @@ -1,9 +1,9 @@ package transactional import ( - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage" ) // ReferenceStorage implements the storer.ReferenceStorage for the transactional package. diff --git a/storage/transactional/reference_test.go b/storage/transactional/reference_test.go index 05a4fcfc2..abce5cf52 100644 --- a/storage/transactional/reference_test.go +++ b/storage/transactional/reference_test.go @@ -1,17 +1,22 @@ package transactional import ( - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/storage/memory" + "testing" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/suite" ) -var _ = Suite(&ReferenceSuite{}) +func TestReferenceSuite(t *testing.T) { + suite.Run(t, new(ReferenceSuite)) +} -type ReferenceSuite struct{} +type ReferenceSuite struct { + suite.Suite +} -func (s *ReferenceSuite) TestReference(c *C) { +func (s *ReferenceSuite) TestReference() { base := memory.NewStorage() temporal := memory.NewStorage() @@ -21,22 +26,22 @@ func (s *ReferenceSuite) TestReference(c *C) { refB := plumbing.NewReferenceFromStrings("refs/b", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52") err := base.SetReference(refA) - c.Assert(err, IsNil) + s.NoError(err) err = rs.SetReference(refB) - c.Assert(err, IsNil) + s.NoError(err) _, err = rs.Reference("refs/a") - c.Assert(err, IsNil) + s.NoError(err) _, err = rs.Reference("refs/b") - c.Assert(err, IsNil) + s.NoError(err) _, err = base.Reference("refs/b") - c.Assert(err, Equals, plumbing.ErrReferenceNotFound) + s.ErrorIs(err, plumbing.ErrReferenceNotFound) } -func (s *ReferenceSuite) TestRemoveReferenceTemporal(c *C) { +func (s *ReferenceSuite) TestRemoveReferenceTemporal() { base := memory.NewStorage() temporal := memory.NewStorage() @@ -44,16 +49,16 @@ func (s *ReferenceSuite) TestRemoveReferenceTemporal(c *C) { rs := NewReferenceStorage(base, temporal) err := rs.SetReference(ref) - c.Assert(err, IsNil) + s.NoError(err) err = rs.RemoveReference("refs/a") - c.Assert(err, IsNil) + s.NoError(err) _, err = rs.Reference("refs/a") - c.Assert(err, Equals, plumbing.ErrReferenceNotFound) + s.ErrorIs(err, plumbing.ErrReferenceNotFound) } -func (s *ReferenceSuite) TestRemoveReferenceBase(c *C) { +func (s *ReferenceSuite) TestRemoveReferenceBase() { base := memory.NewStorage() temporal := memory.NewStorage() @@ -61,16 +66,16 @@ func (s *ReferenceSuite) TestRemoveReferenceBase(c *C) { rs := NewReferenceStorage(base, temporal) err := base.SetReference(ref) - c.Assert(err, IsNil) + s.NoError(err) err = rs.RemoveReference("refs/a") - c.Assert(err, IsNil) + s.NoError(err) _, err = rs.Reference("refs/a") - c.Assert(err, Equals, plumbing.ErrReferenceNotFound) + s.ErrorIs(err, plumbing.ErrReferenceNotFound) } -func (s *ReferenceSuite) TestCheckAndSetReferenceInBase(c *C) { +func (s *ReferenceSuite) TestCheckAndSetReferenceInBase() { base := memory.NewStorage() temporal := memory.NewStorage() rs := NewReferenceStorage(base, temporal) @@ -78,20 +83,20 @@ func (s *ReferenceSuite) TestCheckAndSetReferenceInBase(c *C) { err := base.SetReference( plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"), ) - c.Assert(err, IsNil) + s.NoError(err) err = rs.CheckAndSetReference( plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"), plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"), ) - c.Assert(err, IsNil) + s.NoError(err) e, err := rs.Reference(plumbing.ReferenceName("foo")) - c.Assert(err, IsNil) - c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52") + s.NoError(err) + s.Equal("bc9968d75e48de59f0870ffb71f5e160bbbdcf52", e.Hash().String()) } -func (s *ReferenceSuite) TestCommit(c *C) { +func (s *ReferenceSuite) TestCommit() { base := memory.NewStorage() temporal := memory.NewStorage() @@ -100,15 +105,15 @@ func (s *ReferenceSuite) TestCommit(c *C) { refC := plumbing.NewReferenceFromStrings("refs/c", "c3f4688a08fd86f1bf8e055724c84b7a40a09733") rs := NewReferenceStorage(base, temporal) - c.Assert(rs.SetReference(refA), IsNil) - c.Assert(rs.SetReference(refB), IsNil) - c.Assert(rs.SetReference(refC), IsNil) + s.Nil(rs.SetReference(refA)) + s.Nil(rs.SetReference(refB)) + s.Nil(rs.SetReference(refC)) err := rs.Commit() - c.Assert(err, IsNil) + s.NoError(err) iter, err := base.IterReferences() - c.Assert(err, IsNil) + s.NoError(err) var count int iter.ForEach(func(ref *plumbing.Reference) error { @@ -116,10 +121,10 @@ func (s *ReferenceSuite) TestCommit(c *C) { return nil }) - c.Assert(count, Equals, 3) + s.Equal(3, count) } -func (s *ReferenceSuite) TestCommitDelete(c *C) { +func (s *ReferenceSuite) TestCommitDelete() { base := memory.NewStorage() temporal := memory.NewStorage() @@ -128,20 +133,20 @@ func (s *ReferenceSuite) TestCommitDelete(c *C) { refC := plumbing.NewReferenceFromStrings("refs/c", "c3f4688a08fd86f1bf8e055724c84b7a40a09733") rs := NewReferenceStorage(base, temporal) - c.Assert(base.SetReference(refA), IsNil) - c.Assert(base.SetReference(refB), IsNil) - c.Assert(base.SetReference(refC), IsNil) + s.Nil(base.SetReference(refA)) + s.Nil(base.SetReference(refB)) + s.Nil(base.SetReference(refC)) - c.Assert(rs.RemoveReference(refA.Name()), IsNil) - c.Assert(rs.RemoveReference(refB.Name()), IsNil) - c.Assert(rs.RemoveReference(refC.Name()), IsNil) - c.Assert(rs.SetReference(refC), IsNil) + s.Nil(rs.RemoveReference(refA.Name())) + s.Nil(rs.RemoveReference(refB.Name())) + s.Nil(rs.RemoveReference(refC.Name())) + s.Nil(rs.SetReference(refC)) err := rs.Commit() - c.Assert(err, IsNil) + s.NoError(err) iter, err := base.IterReferences() - c.Assert(err, IsNil) + s.NoError(err) var count int iter.ForEach(func(ref *plumbing.Reference) error { @@ -149,10 +154,10 @@ func (s *ReferenceSuite) TestCommitDelete(c *C) { return nil }) - c.Assert(count, Equals, 1) + s.Equal(1, count) ref, err := rs.Reference(refC.Name()) - c.Assert(err, IsNil) - c.Assert(ref.Hash().String(), Equals, "c3f4688a08fd86f1bf8e055724c84b7a40a09733") + s.NoError(err) + s.Equal("c3f4688a08fd86f1bf8e055724c84b7a40a09733", ref.Hash().String()) } diff --git a/storage/transactional/shallow.go b/storage/transactional/shallow.go index 20b930ee0..e66c1c8ae 100644 --- a/storage/transactional/shallow.go +++ b/storage/transactional/shallow.go @@ -1,8 +1,8 @@ package transactional import ( - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/storer" ) // ShallowStorage implements the storer.ShallowStorer for the transactional package. diff --git a/storage/transactional/shallow_test.go b/storage/transactional/shallow_test.go index 15d423c00..23e8e2594 100644 --- a/storage/transactional/shallow_test.go +++ b/storage/transactional/shallow_test.go @@ -1,17 +1,22 @@ package transactional import ( - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/storage/memory" + "testing" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/suite" ) -var _ = Suite(&ShallowSuite{}) +func TestShallowSuite(t *testing.T) { + suite.Run(t, new(ShallowSuite)) +} -type ShallowSuite struct{} +type ShallowSuite struct { + suite.Suite +} -func (s *ShallowSuite) TestShallow(c *C) { +func (s *ShallowSuite) TestShallow() { base := memory.NewStorage() temporal := memory.NewStorage() @@ -21,23 +26,23 @@ func (s *ShallowSuite) TestShallow(c *C) { commitB := plumbing.NewHash("aa9968d75e48de59f0870ffb71f5e160bbbdcf52") err := base.SetShallow([]plumbing.Hash{commitA}) - c.Assert(err, IsNil) + s.NoError(err) err = rs.SetShallow([]plumbing.Hash{commitB}) - c.Assert(err, IsNil) + s.NoError(err) commits, err := rs.Shallow() - c.Assert(err, IsNil) - c.Assert(commits, HasLen, 1) - c.Assert(commits[0], Equals, commitB) + s.NoError(err) + s.Len(commits, 1) + s.Equal(commitB, commits[0]) commits, err = base.Shallow() - c.Assert(err, IsNil) - c.Assert(commits, HasLen, 1) - c.Assert(commits[0], Equals, commitA) + s.NoError(err) + s.Len(commits, 1) + s.Equal(commitA, commits[0]) } -func (s *ShallowSuite) TestCommit(c *C) { +func (s *ShallowSuite) TestCommit() { base := memory.NewStorage() temporal := memory.NewStorage() @@ -46,18 +51,18 @@ func (s *ShallowSuite) TestCommit(c *C) { commitA := plumbing.NewHash("bc9968d75e48de59f0870ffb71f5e160bbbdcf52") commitB := plumbing.NewHash("aa9968d75e48de59f0870ffb71f5e160bbbdcf52") - c.Assert(base.SetShallow([]plumbing.Hash{commitA}), IsNil) - c.Assert(rs.SetShallow([]plumbing.Hash{commitB}), IsNil) + s.Nil(base.SetShallow([]plumbing.Hash{commitA})) + s.Nil(rs.SetShallow([]plumbing.Hash{commitB})) - c.Assert(rs.Commit(), IsNil) + s.Nil(rs.Commit()) commits, err := rs.Shallow() - c.Assert(err, IsNil) - c.Assert(commits, HasLen, 1) - c.Assert(commits[0], Equals, commitB) + s.NoError(err) + s.Len(commits, 1) + s.Equal(commitB, commits[0]) commits, err = base.Shallow() - c.Assert(err, IsNil) - c.Assert(commits, HasLen, 1) - c.Assert(commits[0], Equals, commitB) + s.NoError(err) + s.Len(commits, 1) + s.Equal(commitB, commits[0]) } diff --git a/storage/transactional/storage.go b/storage/transactional/storage.go index d4c68cb4b..a76a3f08e 100644 --- a/storage/transactional/storage.go +++ b/storage/transactional/storage.go @@ -3,8 +3,8 @@ package transactional import ( "io" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage" ) // Storage is a transactional implementation of git.Storer, it demux the write diff --git a/storage/transactional/storage_test.go b/storage/transactional/storage_test.go index c620bdc41..c2b1334ce 100644 --- a/storage/transactional/storage_test.go +++ b/storage/transactional/storage_test.go @@ -4,75 +4,51 @@ import ( "testing" "github.com/go-git/go-billy/v5/memfs" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage" - "github.com/go-git/go-git/v5/storage/filesystem" - "github.com/go-git/go-git/v5/storage/memory" - "github.com/go-git/go-git/v5/storage/test" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) -func Test(t *testing.T) { TestingT(t) } - -type StorageSuite struct { - test.BaseStorageSuite - temporal func() storage.Storer -} - -var _ = Suite(&StorageSuite{ - temporal: func() storage.Storer { - return memory.NewStorage() - }, -}) - -var _ = Suite(&StorageSuite{ - temporal: func() storage.Storer { - fs := memfs.New() - return filesystem.NewStorage(fs, cache.NewObjectLRUDefault()) - }, -}) - -func (s *StorageSuite) SetUpTest(c *C) { +func TestCommit(t *testing.T) { base := memory.NewStorage() - temporal := s.temporal() - - s.BaseStorageSuite = test.NewBaseStorageSuite(NewStorage(base, temporal)) -} - -func (s *StorageSuite) TestCommit(c *C) { - base := memory.NewStorage() - temporal := s.temporal() + temporal := filesystem.NewStorage(memfs.New(), cache.NewObjectLRUDefault()) st := NewStorage(base, temporal) commit := base.NewEncodedObject() commit.SetType(plumbing.CommitObject) _, err := st.SetEncodedObject(commit) - c.Assert(err, IsNil) + require.NoError(t, err) ref := plumbing.NewHashReference("refs/a", commit.Hash()) - c.Assert(st.SetReference(ref), IsNil) + require.NoError(t, st.SetReference(ref)) err = st.Commit() - c.Assert(err, IsNil) + require.NoError(t, err) ref, err = base.Reference(ref.Name()) - c.Assert(err, IsNil) - c.Assert(ref.Hash(), Equals, commit.Hash()) + require.NoError(t, err) + assert.Equal(t, commit.Hash(), ref.Hash()) obj, err := base.EncodedObject(plumbing.AnyObject, commit.Hash()) - c.Assert(err, IsNil) - c.Assert(obj.Hash(), Equals, commit.Hash()) + require.NoError(t, err) + assert.Equal(t, commit.Hash(), obj.Hash()) } -func (s *StorageSuite) TestTransactionalPackfileWriter(c *C) { +func TestTransactionalPackfileWriter(t *testing.T) { base := memory.NewStorage() - temporal := s.temporal() + var temporal storage.Storer + + temporal = filesystem.NewStorage(memfs.New(), cache.NewObjectLRUDefault()) + st := NewStorage(base, temporal) _, tmpOK := temporal.(storer.PackfileWriter) _, ok := st.(storer.PackfileWriter) - c.Assert(ok, Equals, tmpOK) + assert.Equal(t, tmpOK, ok) } diff --git a/submodule.go b/submodule.go index 84f020dc7..8f16fef3c 100644 --- a/submodule.go +++ b/submodule.go @@ -8,10 +8,10 @@ import ( "path" "github.com/go-git/go-billy/v5" - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/index" - "github.com/go-git/go-git/v5/plumbing/transport" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/index" + "github.com/jesseduffield/go-git/v5/plumbing/transport" ) var ( @@ -214,10 +214,10 @@ func (s *Submodule) update(ctx context.Context, o *SubmoduleUpdateOptions, force return err } - return s.doRecursiveUpdate(r, o) + return s.doRecursiveUpdate(ctx, r, o) } -func (s *Submodule) doRecursiveUpdate(r *Repository, o *SubmoduleUpdateOptions) error { +func (s *Submodule) doRecursiveUpdate(ctx context.Context, r *Repository, o *SubmoduleUpdateOptions) error { if o.RecurseSubmodules == NoRecurseSubmodules { return nil } @@ -236,7 +236,7 @@ func (s *Submodule) doRecursiveUpdate(r *Repository, o *SubmoduleUpdateOptions) *new = *o new.RecurseSubmodules-- - return l.Update(new) + return l.UpdateContext(ctx, new) } func (s *Submodule) fetchAndCheckout( diff --git a/submodule_test.go b/submodule_test.go index 0e88391f4..32883215c 100644 --- a/submodule_test.go +++ b/submodule_test.go @@ -2,114 +2,113 @@ package git import ( "context" + "os" "path/filepath" "testing" "github.com/go-git/go-billy/v5/memfs" - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/storage/memory" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/suite" fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" ) type SubmoduleSuite struct { + suite.Suite BaseSuite Worktree *Worktree - clean func() } -var _ = Suite(&SubmoduleSuite{}) +func TestSubmoduleSuite(t *testing.T) { + suite.Run(t, new(SubmoduleSuite)) +} -func (s *SubmoduleSuite) SetUpTest(c *C) { +func (s *SubmoduleSuite) SetupTest() { path := fixtures.ByTag("submodule").One().Worktree().Root() - var dir string - dir, s.clean = s.TemporalDir() + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainClone(filepath.Join(dir, "worktree"), false, &CloneOptions{ URL: path, }) - c.Assert(err, IsNil) + s.NoError(err) s.Repository = r s.Worktree, err = r.Worktree() - c.Assert(err, IsNil) -} - -func (s *SubmoduleSuite) TearDownTest(_ *C) { - s.clean() + s.NoError(err) } -func (s *SubmoduleSuite) TestInit(c *C) { +func (s *SubmoduleSuite) TestInit() { sm, err := s.Worktree.Submodule("basic") - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(sm.initialized, Equals, false) + s.False(sm.initialized) err = sm.Init() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(sm.initialized, Equals, true) + s.True(sm.initialized) cfg, err := s.Repository.Config() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(cfg.Submodules, HasLen, 1) - c.Assert(cfg.Submodules["basic"], NotNil) + s.Len(cfg.Submodules, 1) + s.NotNil(cfg.Submodules["basic"]) status, err := sm.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, false) + s.NoError(err) + s.False(status.IsClean()) } -func (s *SubmoduleSuite) TestUpdate(c *C) { +func (s *SubmoduleSuite) TestUpdate() { if testing.Short() { - c.Skip("skipping test in short mode.") + s.T().Skip("skipping test in short mode.") } sm, err := s.Worktree.Submodule("basic") - c.Assert(err, IsNil) + s.NoError(err) err = sm.Update(&SubmoduleUpdateOptions{ Init: true, }) - c.Assert(err, IsNil) + s.NoError(err) r, err := sm.Repository() - c.Assert(err, IsNil) + s.NoError(err) ref, err := r.Reference(plumbing.HEAD, true) - c.Assert(err, IsNil) - c.Assert(ref.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") + s.NoError(err) + s.Equal("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", ref.Hash().String()) status, err := sm.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) + s.NoError(err) + s.True(status.IsClean()) } -func (s *SubmoduleSuite) TestRepositoryWithoutInit(c *C) { +func (s *SubmoduleSuite) TestRepositoryWithoutInit() { sm, err := s.Worktree.Submodule("basic") - c.Assert(err, IsNil) + s.NoError(err) r, err := sm.Repository() - c.Assert(err, Equals, ErrSubmoduleNotInitialized) - c.Assert(r, IsNil) + s.ErrorIs(err, ErrSubmoduleNotInitialized) + s.Nil(r) } -func (s *SubmoduleSuite) TestUpdateWithoutInit(c *C) { +func (s *SubmoduleSuite) TestUpdateWithoutInit() { sm, err := s.Worktree.Submodule("basic") - c.Assert(err, IsNil) + s.NoError(err) err = sm.Update(&SubmoduleUpdateOptions{}) - c.Assert(err, Equals, ErrSubmoduleNotInitialized) + s.ErrorIs(err, ErrSubmoduleNotInitialized) } -func (s *SubmoduleSuite) TestUpdateWithNotFetch(c *C) { +func (s *SubmoduleSuite) TestUpdateWithNotFetch() { sm, err := s.Worktree.Submodule("basic") - c.Assert(err, IsNil) + s.NoError(err) err = sm.Update(&SubmoduleUpdateOptions{ Init: true, @@ -117,44 +116,44 @@ func (s *SubmoduleSuite) TestUpdateWithNotFetch(c *C) { }) // Since we are not fetching, the object is not there - c.Assert(err, Equals, plumbing.ErrObjectNotFound) + s.ErrorIs(err, plumbing.ErrObjectNotFound) } -func (s *SubmoduleSuite) TestUpdateWithRecursion(c *C) { +func (s *SubmoduleSuite) TestUpdateWithRecursion() { if testing.Short() { - c.Skip("skipping test in short mode.") + s.T().Skip("skipping test in short mode.") } sm, err := s.Worktree.Submodule("itself") - c.Assert(err, IsNil) + s.NoError(err) err = sm.Update(&SubmoduleUpdateOptions{ Init: true, RecurseSubmodules: 2, }) - c.Assert(err, IsNil) + s.NoError(err) fs := s.Worktree.Filesystem _, err = fs.Stat(fs.Join("itself", "basic", "LICENSE")) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *SubmoduleSuite) TestUpdateWithInitAndUpdate(c *C) { +func (s *SubmoduleSuite) TestUpdateWithInitAndUpdate() { if testing.Short() { - c.Skip("skipping test in short mode.") + s.T().Skip("skipping test in short mode.") } sm, err := s.Worktree.Submodule("basic") - c.Assert(err, IsNil) + s.NoError(err) err = sm.Update(&SubmoduleUpdateOptions{ Init: true, }) - c.Assert(err, IsNil) + s.NoError(err) idx, err := s.Repository.Storer.Index() - c.Assert(err, IsNil) + s.NoError(err) for i, e := range idx.Entries { if e.Name == "basic" { @@ -165,104 +164,104 @@ func (s *SubmoduleSuite) TestUpdateWithInitAndUpdate(c *C) { } err = s.Repository.Storer.SetIndex(idx) - c.Assert(err, IsNil) + s.NoError(err) err = sm.Update(&SubmoduleUpdateOptions{}) - c.Assert(err, IsNil) + s.NoError(err) r, err := sm.Repository() - c.Assert(err, IsNil) + s.NoError(err) ref, err := r.Reference(plumbing.HEAD, true) - c.Assert(err, IsNil) - c.Assert(ref.Hash().String(), Equals, "b029517f6300c2da0f4b651b8642506cd6aaf45d") + s.NoError(err) + s.Equal("b029517f6300c2da0f4b651b8642506cd6aaf45d", ref.Hash().String()) } -func (s *SubmoduleSuite) TestSubmodulesInit(c *C) { +func (s *SubmoduleSuite) TestSubmodulesInit() { sm, err := s.Worktree.Submodules() - c.Assert(err, IsNil) + s.NoError(err) err = sm.Init() - c.Assert(err, IsNil) + s.NoError(err) sm, err = s.Worktree.Submodules() - c.Assert(err, IsNil) + s.NoError(err) for _, m := range sm { - c.Assert(m.initialized, Equals, true) + s.True(m.initialized) } } -func (s *SubmoduleSuite) TestGitSubmodulesSymlink(c *C) { +func (s *SubmoduleSuite) TestGitSubmodulesSymlink() { f, err := s.Worktree.Filesystem.Create("badfile") - c.Assert(err, IsNil) + s.NoError(err) defer func() { _ = f.Close() }() err = s.Worktree.Filesystem.Remove(gitmodulesFile) - c.Assert(err, IsNil) + s.NoError(err) err = s.Worktree.Filesystem.Symlink("badfile", gitmodulesFile) - c.Assert(err, IsNil) + s.NoError(err) _, err = s.Worktree.Submodules() - c.Assert(err, Equals, ErrGitModulesSymlink) + s.ErrorIs(err, ErrGitModulesSymlink) } -func (s *SubmoduleSuite) TestSubmodulesStatus(c *C) { +func (s *SubmoduleSuite) TestSubmodulesStatus() { sm, err := s.Worktree.Submodules() - c.Assert(err, IsNil) + s.NoError(err) status, err := sm.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 2) + s.NoError(err) + s.Len(status, 2) } -func (s *SubmoduleSuite) TestSubmodulesUpdateContext(c *C) { +func (s *SubmoduleSuite) TestSubmodulesUpdateContext() { if testing.Short() { - c.Skip("skipping test in short mode.") + s.T().Skip("skipping test in short mode.") } sm, err := s.Worktree.Submodules() - c.Assert(err, IsNil) + s.NoError(err) ctx, cancel := context.WithCancel(context.Background()) cancel() err = sm.UpdateContext(ctx, &SubmoduleUpdateOptions{Init: true}) - c.Assert(err, NotNil) + s.NotNil(err) } -func (s *SubmoduleSuite) TestSubmodulesFetchDepth(c *C) { +func (s *SubmoduleSuite) TestSubmodulesFetchDepth() { if testing.Short() { - c.Skip("skipping test in short mode.") + s.T().Skip("skipping test in short mode.") } sm, err := s.Worktree.Submodule("basic") - c.Assert(err, IsNil) + s.NoError(err) err = sm.Update(&SubmoduleUpdateOptions{ Init: true, Depth: 1, }) - c.Assert(err, IsNil) + s.NoError(err) r, err := sm.Repository() - c.Assert(err, IsNil) + s.NoError(err) lr, err := r.Log(&LogOptions{}) - c.Assert(err, IsNil) + s.NoError(err) commitCount := 0 for _, err := lr.Next(); err == nil; _, err = lr.Next() { commitCount++ } - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(commitCount, Equals, 1) + s.Equal(1, commitCount) } -func (s *SubmoduleSuite) TestSubmoduleParseScp(c *C) { +func (s *SubmoduleSuite) TestSubmoduleParseScp() { repo := &Repository{ Storer: memory.NewStorage(), wt: memfs.New(), @@ -282,5 +281,5 @@ func (s *SubmoduleSuite) TestSubmoduleParseScp(c *C) { } _, err := submodule.Repository() - c.Assert(err, IsNil) + s.NoError(err) } diff --git a/transport.go b/transport.go new file mode 100644 index 000000000..7d5ba204a --- /dev/null +++ b/transport.go @@ -0,0 +1,9 @@ +package git + +// Default supported transports. +import ( + _ "github.com/jesseduffield/go-git/v5/plumbing/transport/file" // file transport + _ "github.com/jesseduffield/go-git/v5/plumbing/transport/git" // git transport + _ "github.com/jesseduffield/go-git/v5/plumbing/transport/http" // http transport + _ "github.com/jesseduffield/go-git/v5/plumbing/transport/ssh" // ssh transport +) diff --git a/utils/binary/read.go b/utils/binary/read.go index b8f9df1a2..66970df39 100644 --- a/utils/binary/read.go +++ b/utils/binary/read.go @@ -7,7 +7,7 @@ import ( "encoding/binary" "io" - "github.com/go-git/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing" ) // Read reads structured binary data from r into data. Bytes are read and diff --git a/utils/binary/read_test.go b/utils/binary/read_test.go index bcd9dee09..71c3dc5e9 100644 --- a/utils/binary/read_test.go +++ b/utils/binary/read_test.go @@ -6,117 +6,118 @@ import ( "encoding/binary" "testing" - "github.com/go-git/go-git/v5/plumbing" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } - -type BinarySuite struct{} +type BinarySuite struct { + suite.Suite +} -var _ = Suite(&BinarySuite{}) +func TestBinarySuite(t *testing.T) { + suite.Run(t, new(BinarySuite)) +} -func (s *BinarySuite) TestRead(c *C) { +func (s *BinarySuite) TestRead() { buf := bytes.NewBuffer(nil) err := binary.Write(buf, binary.BigEndian, int64(42)) - c.Assert(err, IsNil) + s.NoError(err) err = binary.Write(buf, binary.BigEndian, int32(42)) - c.Assert(err, IsNil) + s.NoError(err) var i64 int64 var i32 int32 err = Read(buf, &i64, &i32) - c.Assert(err, IsNil) - c.Assert(i64, Equals, int64(42)) - c.Assert(i32, Equals, int32(42)) + s.NoError(err) + s.Equal(int64(42), i64) + s.Equal(int32(42), i32) } -func (s *BinarySuite) TestReadUntil(c *C) { +func (s *BinarySuite) TestReadUntil() { buf := bytes.NewBuffer([]byte("foo bar")) b, err := ReadUntil(buf, ' ') - c.Assert(err, IsNil) - c.Assert(b, HasLen, 3) - c.Assert(string(b), Equals, "foo") + s.NoError(err) + s.Len(b, 3) + s.Equal("foo", string(b)) } -func (s *BinarySuite) TestReadUntilFromBufioReader(c *C) { +func (s *BinarySuite) TestReadUntilFromBufioReader() { buf := bufio.NewReader(bytes.NewBuffer([]byte("foo bar"))) b, err := ReadUntilFromBufioReader(buf, ' ') - c.Assert(err, IsNil) - c.Assert(b, HasLen, 3) - c.Assert(string(b), Equals, "foo") + s.NoError(err) + s.Len(b, 3) + s.Equal("foo", string(b)) } -func (s *BinarySuite) TestReadVariableWidthInt(c *C) { +func (s *BinarySuite) TestReadVariableWidthInt() { buf := bytes.NewBuffer([]byte{129, 110}) i, err := ReadVariableWidthInt(buf) - c.Assert(err, IsNil) - c.Assert(i, Equals, int64(366)) + s.NoError(err) + s.Equal(int64(366), i) } -func (s *BinarySuite) TestReadVariableWidthIntShort(c *C) { +func (s *BinarySuite) TestReadVariableWidthIntShort() { buf := bytes.NewBuffer([]byte{19}) i, err := ReadVariableWidthInt(buf) - c.Assert(err, IsNil) - c.Assert(i, Equals, int64(19)) + s.NoError(err) + s.Equal(int64(19), i) } -func (s *BinarySuite) TestReadUint32(c *C) { +func (s *BinarySuite) TestReadUint32() { buf := bytes.NewBuffer(nil) err := binary.Write(buf, binary.BigEndian, uint32(42)) - c.Assert(err, IsNil) + s.NoError(err) i32, err := ReadUint32(buf) - c.Assert(err, IsNil) - c.Assert(i32, Equals, uint32(42)) + s.NoError(err) + s.Equal(uint32(42), i32) } -func (s *BinarySuite) TestReadUint16(c *C) { +func (s *BinarySuite) TestReadUint16() { buf := bytes.NewBuffer(nil) err := binary.Write(buf, binary.BigEndian, uint16(42)) - c.Assert(err, IsNil) + s.NoError(err) i32, err := ReadUint16(buf) - c.Assert(err, IsNil) - c.Assert(i32, Equals, uint16(42)) + s.NoError(err) + s.Equal(uint16(42), i32) } -func (s *BinarySuite) TestReadHash(c *C) { +func (s *BinarySuite) TestReadHash() { expected := plumbing.NewHash("43aec75c611f22c73b27ece2841e6ccca592f285") buf := bytes.NewBuffer(nil) err := binary.Write(buf, binary.BigEndian, expected) - c.Assert(err, IsNil) + s.NoError(err) hash, err := ReadHash(buf) - c.Assert(err, IsNil) - c.Assert(hash.String(), Equals, expected.String()) + s.NoError(err) + s.Equal(expected.String(), hash.String()) } -func (s *BinarySuite) TestIsBinary(c *C) { +func (s *BinarySuite) TestIsBinary() { buf := bytes.NewBuffer(nil) buf.Write(bytes.Repeat([]byte{'A'}, sniffLen)) buf.Write([]byte{0}) ok, err := IsBinary(buf) - c.Assert(err, IsNil) - c.Assert(ok, Equals, false) + s.NoError(err) + s.False(ok) buf.Reset() buf.Write(bytes.Repeat([]byte{'A'}, sniffLen-1)) buf.Write([]byte{0}) ok, err = IsBinary(buf) - c.Assert(err, IsNil) - c.Assert(ok, Equals, true) + s.NoError(err) + s.True(ok) buf.Reset() buf.Write(bytes.Repeat([]byte{'A'}, 10)) ok, err = IsBinary(buf) - c.Assert(err, IsNil) - c.Assert(ok, Equals, false) + s.NoError(err) + s.False(ok) } diff --git a/utils/binary/write_test.go b/utils/binary/write_test.go index 1380280c0..79f5984cf 100644 --- a/utils/binary/write_test.go +++ b/utils/binary/write_test.go @@ -3,57 +3,55 @@ package binary import ( "bytes" "encoding/binary" - - . "gopkg.in/check.v1" ) -func (s *BinarySuite) TestWrite(c *C) { +func (s *BinarySuite) TestWrite() { expected := bytes.NewBuffer(nil) err := binary.Write(expected, binary.BigEndian, int64(42)) - c.Assert(err, IsNil) + s.NoError(err) err = binary.Write(expected, binary.BigEndian, int32(42)) - c.Assert(err, IsNil) + s.NoError(err) buf := bytes.NewBuffer(nil) err = Write(buf, int64(42), int32(42)) - c.Assert(err, IsNil) - c.Assert(buf, DeepEquals, expected) + s.NoError(err) + s.Equal(expected, buf) } -func (s *BinarySuite) TestWriteUint32(c *C) { +func (s *BinarySuite) TestWriteUint32() { expected := bytes.NewBuffer(nil) err := binary.Write(expected, binary.BigEndian, int32(42)) - c.Assert(err, IsNil) + s.NoError(err) buf := bytes.NewBuffer(nil) err = WriteUint32(buf, 42) - c.Assert(err, IsNil) - c.Assert(buf, DeepEquals, expected) + s.NoError(err) + s.Equal(expected, buf) } -func (s *BinarySuite) TestWriteUint16(c *C) { +func (s *BinarySuite) TestWriteUint16() { expected := bytes.NewBuffer(nil) err := binary.Write(expected, binary.BigEndian, int16(42)) - c.Assert(err, IsNil) + s.NoError(err) buf := bytes.NewBuffer(nil) err = WriteUint16(buf, 42) - c.Assert(err, IsNil) - c.Assert(buf, DeepEquals, expected) + s.NoError(err) + s.Equal(expected, buf) } -func (s *BinarySuite) TestWriteVariableWidthInt(c *C) { +func (s *BinarySuite) TestWriteVariableWidthInt() { buf := bytes.NewBuffer(nil) err := WriteVariableWidthInt(buf, 366) - c.Assert(err, IsNil) - c.Assert(buf.Bytes(), DeepEquals, []byte{129, 110}) + s.NoError(err) + s.Equal([]byte{129, 110}, buf.Bytes()) } -func (s *BinarySuite) TestWriteVariableWidthIntShort(c *C) { +func (s *BinarySuite) TestWriteVariableWidthIntShort() { buf := bytes.NewBuffer(nil) err := WriteVariableWidthInt(buf, 19) - c.Assert(err, IsNil) - c.Assert(buf.Bytes(), DeepEquals, []byte{19}) + s.NoError(err) + s.Equal([]byte{19}, buf.Bytes()) } diff --git a/utils/diff/diff_ext_test.go b/utils/diff/diff_ext_test.go index 2eea2753a..1d51bfb73 100644 --- a/utils/diff/diff_ext_test.go +++ b/utils/diff/diff_ext_test.go @@ -1,19 +1,22 @@ package diff_test import ( + "fmt" "testing" - "github.com/go-git/go-git/v5/utils/diff" + "github.com/jesseduffield/go-git/v5/utils/diff" + "github.com/stretchr/testify/suite" "github.com/sergi/go-diff/diffmatchpatch" - . "gopkg.in/check.v1" ) -func Test(t *testing.T) { TestingT(t) } - -type suiteCommon struct{} +type suiteCommon struct { + suite.Suite +} -var _ = Suite(&suiteCommon{}) +func TestSuiteCommon(t *testing.T) { + suite.Run(t, new(suiteCommon)) +} var diffTests = [...]struct { src string // the src string to diff @@ -40,13 +43,13 @@ var diffTests = [...]struct { {"a\nbbbbb\n\tccc\ndd\n\tfffffffff\n", "bbbbb\n\tccc\n\tDD\n\tffff\n"}, } -func (s *suiteCommon) TestAll(c *C) { +func (s *suiteCommon) TestAll() { for i, t := range diffTests { diffs := diff.Do(t.src, t.dst) src := diff.Src(diffs) dst := diff.Dst(diffs) - c.Assert(src, Equals, t.src, Commentf("subtest %d, src=%q, dst=%q, bad calculated src", i, t.src, t.dst)) - c.Assert(dst, Equals, t.dst, Commentf("subtest %d, src=%q, dst=%q, bad calculated dst", i, t.src, t.dst)) + s.Equal(t.src, src, fmt.Sprintf("subtest %d, src=%q, dst=%q, bad calculated src", i, t.src, t.dst)) + s.Equal(t.dst, dst, fmt.Sprintf("subtest %d, src=%q, dst=%q, bad calculated dst", i, t.src, t.dst)) } } @@ -132,9 +135,9 @@ var doTests = [...]struct { }, } -func (s *suiteCommon) TestDo(c *C) { +func (s *suiteCommon) TestDo() { for i, t := range doTests { diffs := diff.Do(t.src, t.dst) - c.Assert(diffs, DeepEquals, t.exp, Commentf("subtest %d", i)) + s.Equal(t.exp, diffs, fmt.Sprintf("subtest %d", i)) } } diff --git a/utils/ioutil/common.go b/utils/ioutil/common.go index 235af717b..1fb0786f1 100644 --- a/utils/ioutil/common.go +++ b/utils/ioutil/common.go @@ -6,24 +6,26 @@ import ( "context" "errors" "io" - - ctxio "github.com/jbenet/go-context/io" ) -type readPeeker interface { - io.Reader +// Peeker is an interface for types that can peek at the next bytes. +type Peeker interface { Peek(int) ([]byte, error) } -var ( - ErrEmptyReader = errors.New("reader is empty") -) +// ReadPeeker is an interface that groups the basic Read and Peek methods. +type ReadPeeker interface { + io.Reader + Peeker +} + +var ErrEmptyReader = errors.New("reader is empty") // NonEmptyReader takes a reader and returns it if it is not empty, or // `ErrEmptyReader` if it is empty. If there is an error when reading the first // byte of the given reader, it will be propagated. func NonEmptyReader(r io.Reader) (io.Reader, error) { - pr, ok := r.(readPeeker) + pr, ok := r.(ReadPeeker) if !ok { pr = bufio.NewReader(r) } @@ -83,6 +85,9 @@ type writeCloser struct { } func (r *writeCloser) Close() error { + if r.closer == nil { + return nil + } return r.closer.Close() } @@ -131,29 +136,15 @@ func CheckClose(c io.Closer, err *error) { } } -// NewContextWriter wraps a writer to make it respect given Context. -// If there is a blocking write, the returned Writer will return whenever the -// context is cancelled (the return values are n=0 and err=ctx.Err()). -func NewContextWriter(ctx context.Context, w io.Writer) io.Writer { - return ctxio.NewWriter(ctx, w) -} - -// NewContextReader wraps a reader to make it respect given Context. -// If there is a blocking read, the returned Reader will return whenever the -// context is cancelled (the return values are n=0 and err=ctx.Err()). -func NewContextReader(ctx context.Context, r io.Reader) io.Reader { - return ctxio.NewReader(ctx, r) -} - // NewContextWriteCloser as NewContextWriter but with io.Closer interface. func NewContextWriteCloser(ctx context.Context, w io.WriteCloser) io.WriteCloser { - ctxw := ctxio.NewWriter(ctx, w) + ctxw := NewContextWriter(ctx, w) return NewWriteCloser(ctxw, w) } // NewContextReadCloser as NewContextReader but with io.Closer interface. func NewContextReadCloser(ctx context.Context, r io.ReadCloser) io.ReadCloser { - ctxr := ctxio.NewReader(ctx, r) + ctxr := NewContextReader(ctx, r) return NewReadCloser(ctxr, r) } @@ -208,3 +199,13 @@ func (r *writerOnError) Write(p []byte) (n int, err error) { return } + +// CloserFunc implements the io.Closer interface with a function. +type CloserFunc func() error + +var _ io.Closer = CloserFunc(nil) + +// Close calls the function. +func (f CloserFunc) Close() error { + return f() +} diff --git a/utils/ioutil/common_test.go b/utils/ioutil/common_test.go index e3c9d69fa..c7a35b66c 100644 --- a/utils/ioutil/common_test.go +++ b/utils/ioutil/common_test.go @@ -7,14 +7,16 @@ import ( "strings" "testing" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } - -type CommonSuite struct{} +type CommonSuite struct { + suite.Suite +} -var _ = Suite(&CommonSuite{}) +func TestCommonSuite(t *testing.T) { + suite.Run(t, new(CommonSuite)) +} type closer struct { called int @@ -25,38 +27,38 @@ func (c *closer) Close() error { return nil } -func (s *CommonSuite) TestNonEmptyReader_Empty(c *C) { +func (s *CommonSuite) TestNonEmptyReader_Empty() { var buf bytes.Buffer r, err := NonEmptyReader(&buf) - c.Assert(err, Equals, ErrEmptyReader) - c.Assert(r, IsNil) + s.ErrorIs(err, ErrEmptyReader) + s.Nil(r) } -func (s *CommonSuite) TestNonEmptyReader_NonEmpty(c *C) { +func (s *CommonSuite) TestNonEmptyReader_NonEmpty() { buf := bytes.NewBuffer([]byte("1")) r, err := NonEmptyReader(buf) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) read, err := io.ReadAll(r) - c.Assert(err, IsNil) - c.Assert(string(read), Equals, "1") + s.NoError(err) + s.Equal("1", string(read)) } -func (s *CommonSuite) TestNewReadCloser(c *C) { +func (s *CommonSuite) TestNewReadCloser() { buf := bytes.NewBuffer([]byte("1")) closer := &closer{} r := NewReadCloser(buf, closer) read, err := io.ReadAll(r) - c.Assert(err, IsNil) - c.Assert(string(read), Equals, "1") + s.NoError(err) + s.Equal("1", string(read)) - c.Assert(r.Close(), IsNil) - c.Assert(closer.called, Equals, 1) + s.NoError(r.Close()) + s.Equal(1, closer.called) } -func (s *CommonSuite) TestNewContextReader(c *C) { +func (s *CommonSuite) TestNewContextReader() { buf := bytes.NewBuffer([]byte("12")) ctx, close := context.WithCancel(context.Background()) @@ -64,16 +66,16 @@ func (s *CommonSuite) TestNewContextReader(c *C) { b := make([]byte, 1) n, err := r.Read(b) - c.Assert(n, Equals, 1) - c.Assert(err, IsNil) + s.Equal(1, n) + s.NoError(err) close() n, err = r.Read(b) - c.Assert(n, Equals, 0) - c.Assert(err, NotNil) + s.Equal(0, n) + s.NotNil(err) } -func (s *CommonSuite) TestNewContextReadCloser(c *C) { +func (s *CommonSuite) TestNewContextReadCloser() { buf := NewReadCloser(bytes.NewBuffer([]byte("12")), &closer{}) ctx, close := context.WithCancel(context.Background()) @@ -81,52 +83,52 @@ func (s *CommonSuite) TestNewContextReadCloser(c *C) { b := make([]byte, 1) n, err := r.Read(b) - c.Assert(n, Equals, 1) - c.Assert(err, IsNil) + s.Equal(1, n) + s.NoError(err) close() n, err = r.Read(b) - c.Assert(n, Equals, 0) - c.Assert(err, NotNil) + s.Equal(0, n) + s.NotNil(err) - c.Assert(r.Close(), IsNil) + s.NoError(r.Close()) } -func (s *CommonSuite) TestNewContextWriter(c *C) { +func (s *CommonSuite) TestNewContextWriter() { buf := bytes.NewBuffer(nil) ctx, close := context.WithCancel(context.Background()) r := NewContextWriter(ctx, buf) n, err := r.Write([]byte("1")) - c.Assert(n, Equals, 1) - c.Assert(err, IsNil) + s.Equal(1, n) + s.NoError(err) close() n, err = r.Write([]byte("1")) - c.Assert(n, Equals, 0) - c.Assert(err, NotNil) + s.Equal(0, n) + s.NotNil(err) } -func (s *CommonSuite) TestNewContextWriteCloser(c *C) { +func (s *CommonSuite) TestNewContextWriteCloser() { buf := NewWriteCloser(bytes.NewBuffer(nil), &closer{}) ctx, close := context.WithCancel(context.Background()) w := NewContextWriteCloser(ctx, buf) n, err := w.Write([]byte("1")) - c.Assert(n, Equals, 1) - c.Assert(err, IsNil) + s.Equal(1, n) + s.NoError(err) close() n, err = w.Write([]byte("1")) - c.Assert(n, Equals, 0) - c.Assert(err, NotNil) + s.Equal(0, n) + s.NotNil(err) - c.Assert(w.Close(), IsNil) + s.NoError(w.Close()) } -func (s *CommonSuite) TestNewWriteCloserOnError(c *C) { +func (s *CommonSuite) TestNewWriteCloserOnError() { buf := NewWriteCloser(bytes.NewBuffer(nil), &closer{}) ctx, close := context.WithCancel(context.Background()) @@ -139,10 +141,10 @@ func (s *CommonSuite) TestNewWriteCloserOnError(c *C) { close() w.Write(nil) - c.Assert(called, NotNil) + s.NotNil(called) } -func (s *CommonSuite) TestNewReadCloserOnError(c *C) { +func (s *CommonSuite) TestNewReadCloserOnError() { buf := NewReadCloser(bytes.NewBuffer(nil), &closer{}) ctx, close := context.WithCancel(context.Background()) @@ -154,7 +156,7 @@ func (s *CommonSuite) TestNewReadCloserOnError(c *C) { close() w.Read(nil) - c.Assert(called, NotNil) + s.NotNil(called) } func ExampleCheckClose() { // CheckClose is commonly used with named return values diff --git a/utils/ioutil/context.go b/utils/ioutil/context.go new file mode 100644 index 000000000..ae11e4519 --- /dev/null +++ b/utils/ioutil/context.go @@ -0,0 +1,117 @@ +package ioutil + +import ( + "context" + "io" + "slices" +) + +type ioret struct { + err error + n int +} + +type Writer interface { + io.Writer +} + +type ctxWriter struct { + w io.Writer + ctx context.Context +} + +// NewContextWriter wraps a writer to make it respect the given Context. +// If there is a blocking write, the returned Writer will return +// whenever the context is cancelled (the return values are n=0 +// and err=ctx.Err().) +// +// Note that this wrapper DOES NOT ACTUALLY cancel the underlying +// write, as there is no way to do that with the standard Go io +// interface. So the read and write _will_ happen or hang. Use +// this sparingly, make sure to cancel the read or write as necessary +// (e.g. closing a connection whose context is up, etc.) +// +// Furthermore, in order to protect your memory from being read +// _after_ you've cancelled the context, this io.Writer will +// first make a **copy** of the buffer. +func NewContextWriter(ctx context.Context, w io.Writer) *ctxWriter { + if ctx == nil { + ctx = context.Background() + } + return &ctxWriter{ctx: ctx, w: w} +} + +func (w *ctxWriter) Write(buf []byte) (int, error) { + buf2 := slices.Clone(buf) + + c := make(chan ioret, 1) + + go func() { + n, err := w.w.Write(buf2) + c <- ioret{err, n} + close(c) + }() + + select { + case r := <-c: + return r.n, r.err + case <-w.ctx.Done(): + return 0, w.ctx.Err() + } +} + +type Reader interface { + io.Reader +} + +type ctxReader struct { + r io.Reader + ctx context.Context + closer io.Closer +} + +// NewContextReader wraps a reader to make it respect given Context. +// If there is a blocking read, the returned Reader will return +// whenever the context is cancelled (the return values are n=0 +// and err=ctx.Err().) +// +// Note well: this wrapper DOES NOT ACTUALLY cancel the underlying +// write-- there is no way to do that with the standard go io +// interface. So the read and write _will_ happen or hang. So, use +// this sparingly, make sure to cancel the read or write as necesary +// (e.g. closing a connection whose context is up, etc.) +// +// Furthermore, in order to protect your memory from being read +// _before_ you've cancelled the context, this io.Reader will +// allocate a buffer of the same size, and **copy** into the client's +// if the read succeeds in time. +func NewContextReader(ctx context.Context, r io.Reader) *ctxReader { + return &ctxReader{ctx: ctx, r: r} +} + +func (r *ctxReader) Read(buf []byte) (int, error) { + buf2 := make([]byte, len(buf)) + + c := make(chan ioret, 1) + + go func() { + n, err := r.r.Read(buf2) + c <- ioret{err, n} + close(c) + }() + + select { + case ret := <-c: + copy(buf, buf2) + return ret.n, ret.err + case <-r.ctx.Done(): + if r.closer != nil { + r.closer.Close() + } + return 0, r.ctx.Err() + } +} + +func NewContextReaderWithCloser(ctx context.Context, r io.Reader, closer io.Closer) *ctxReader { + return &ctxReader{ctx: ctx, r: r, closer: closer} +} diff --git a/utils/ioutil/context_test.go b/utils/ioutil/context_test.go new file mode 100644 index 000000000..6eb23d205 --- /dev/null +++ b/utils/ioutil/context_test.go @@ -0,0 +1,273 @@ +package ioutil + +import ( + "bytes" + "io" + "testing" + "time" + + context "golang.org/x/net/context" +) + +func TestReader(t *testing.T) { + buf := []byte("abcdef") + buf2 := make([]byte, 3) + r := NewContextReader(context.Background(), bytes.NewReader(buf)) + + // read first half + n, err := r.Read(buf2) + if n != 3 { + t.Error("n should be 3") + } + if err != nil { + t.Error("should have no error") + } + if string(buf2) != string(buf[:3]) { + t.Error("incorrect contents") + } + + // read second half + n, err = r.Read(buf2) + if n != 3 { + t.Error("n should be 3") + } + if err != nil { + t.Error("should have no error") + } + if string(buf2) != string(buf[3:6]) { + t.Error("incorrect contents") + } + + // read more. + n, err = r.Read(buf2) + if n != 0 { + t.Error("n should be 0", n) + } + if err != io.EOF { + t.Error("should be EOF", err) + } +} + +func TestWriter(t *testing.T) { + var buf bytes.Buffer + w := NewContextWriter(context.Background(), &buf) + + // write three + n, err := w.Write([]byte("abc")) + if n != 3 { + t.Error("n should be 3") + } + if err != nil { + t.Error("should have no error") + } + if string(buf.Bytes()) != string("abc") { + t.Error("incorrect contents") + } + + // write three more + n, err = w.Write([]byte("def")) + if n != 3 { + t.Error("n should be 3") + } + if err != nil { + t.Error("should have no error") + } + if string(buf.Bytes()) != string("abcdef") { + t.Error("incorrect contents") + } +} + +func TestReaderCancel(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + piper, pipew := io.Pipe() + r := NewContextReader(ctx, piper) + + buf := make([]byte, 10) + done := make(chan ioret) + + go func() { + n, err := r.Read(buf) + done <- ioret{err, n} + }() + + pipew.Write([]byte("abcdefghij")) + + select { + case ret := <-done: + if ret.n != 10 { + t.Error("ret.n should be 10", ret.n) + } + if ret.err != nil { + t.Error("ret.err should be nil", ret.err) + } + if string(buf) != "abcdefghij" { + t.Error("read contents differ") + } + case <-time.After(20 * time.Millisecond): + t.Fatal("failed to read") + } + + go func() { + n, err := r.Read(buf) + done <- ioret{err, n} + }() + + cancel() + + select { + case ret := <-done: + if ret.n != 0 { + t.Error("ret.n should be 0", ret.n) + } + if ret.err == nil { + t.Error("ret.err should be ctx error", ret.err) + } + case <-time.After(20 * time.Millisecond): + t.Fatal("failed to stop reading after cancel") + } +} + +func TestWriterCancel(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + piper, pipew := io.Pipe() + w := NewContextWriter(ctx, pipew) + + buf := make([]byte, 10) + done := make(chan ioret) + + go func() { + n, err := w.Write([]byte("abcdefghij")) + done <- ioret{err, n} + }() + + piper.Read(buf) + + select { + case ret := <-done: + if ret.n != 10 { + t.Error("ret.n should be 10", ret.n) + } + if ret.err != nil { + t.Error("ret.err should be nil", ret.err) + } + if string(buf) != "abcdefghij" { + t.Error("write contents differ") + } + case <-time.After(20 * time.Millisecond): + t.Fatal("failed to write") + } + + go func() { + n, err := w.Write([]byte("abcdefghij")) + done <- ioret{err, n} + }() + + cancel() + + select { + case ret := <-done: + if ret.n != 0 { + t.Error("ret.n should be 0", ret.n) + } + if ret.err == nil { + t.Error("ret.err should be ctx error", ret.err) + } + case <-time.After(20 * time.Millisecond): + t.Fatal("failed to stop writing after cancel") + } +} + +func TestReadPostCancel(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + piper, pipew := io.Pipe() + r := NewContextReader(ctx, piper) + + buf := make([]byte, 10) + done := make(chan ioret) + + go func() { + n, err := r.Read(buf) + done <- ioret{err, n} + }() + + cancel() + + select { + case ret := <-done: + if ret.n != 0 { + t.Error("ret.n should be 0", ret.n) + } + if ret.err == nil { + t.Error("ret.err should be ctx error", ret.err) + } + case <-time.After(20 * time.Millisecond): + t.Fatal("failed to stop reading after cancel") + } + + pipew.Write([]byte("abcdefghij")) + + if !bytes.Equal(buf, make([]byte, len(buf))) { + t.Fatal("buffer should have not been written to") + } +} + +func TestWritePostCancel(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + piper, pipew := io.Pipe() + w := NewContextWriter(ctx, pipew) + + buf := []byte("abcdefghij") + buf2 := make([]byte, 10) + done := make(chan ioret) + + go func() { + n, err := w.Write(buf) + done <- ioret{err, n} + }() + + piper.Read(buf2) + + select { + case ret := <-done: + if ret.n != 10 { + t.Error("ret.n should be 10", ret.n) + } + if ret.err != nil { + t.Error("ret.err should be nil", ret.err) + } + if string(buf2) != "abcdefghij" { + t.Error("write contents differ") + } + case <-time.After(20 * time.Millisecond): + t.Fatal("failed to write") + } + + go func() { + n, err := w.Write(buf) + done <- ioret{err, n} + }() + + cancel() + + select { + case ret := <-done: + if ret.n != 0 { + t.Error("ret.n should be 0", ret.n) + } + if ret.err == nil { + t.Error("ret.err should be ctx error", ret.err) + } + case <-time.After(20 * time.Millisecond): + t.Fatal("failed to stop writing after cancel") + } + + copy(buf, []byte("aaaaaaaaaa")) + + piper.Read(buf2) + + if string(buf2) == "aaaaaaaaaa" { + t.Error("buffer was read from after ctx cancel") + } else if string(buf2) != "abcdefghij" { + t.Error("write contents differ from expected") + } +} diff --git a/utils/merkletrie/change.go b/utils/merkletrie/change.go index 450feb4ba..f408261fc 100644 --- a/utils/merkletrie/change.go +++ b/utils/merkletrie/change.go @@ -5,7 +5,7 @@ import ( "fmt" "io" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" ) var ( diff --git a/utils/merkletrie/change_test.go b/utils/merkletrie/change_test.go index cd28bfe52..0eeffd398 100644 --- a/utils/merkletrie/change_test.go +++ b/utils/merkletrie/change_test.go @@ -1,87 +1,92 @@ package merkletrie_test import ( - "github.com/go-git/go-git/v5/utils/merkletrie" - "github.com/go-git/go-git/v5/utils/merkletrie/internal/fsnoder" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" + "testing" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/utils/merkletrie" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/internal/fsnoder" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" + "github.com/stretchr/testify/suite" ) -type ChangeSuite struct{} +type ChangeSuite struct { + suite.Suite +} -var _ = Suite(&ChangeSuite{}) +func TestChangeSuite(t *testing.T) { + suite.Run(t, new(ChangeSuite)) +} -func (s *ChangeSuite) TestActionString(c *C) { +func (s *ChangeSuite) TestActionString() { action := merkletrie.Insert - c.Assert(action.String(), Equals, "Insert") + s.Equal("Insert", action.String()) action = merkletrie.Delete - c.Assert(action.String(), Equals, "Delete") + s.Equal("Delete", action.String()) action = merkletrie.Modify - c.Assert(action.String(), Equals, "Modify") + s.Equal("Modify", action.String()) } -func (s *ChangeSuite) TestUnsupportedAction(c *C) { +func (s *ChangeSuite) TestUnsupportedAction() { a := merkletrie.Action(42) - c.Assert(a.String, PanicMatches, "unsupported action.*") + s.Panics(func() { _ = a.String() }) } -func (s ChangeSuite) TestEmptyChanges(c *C) { +func (s *ChangeSuite) TestEmptyChanges() { ret := merkletrie.NewChanges() p := noder.Path{} err := ret.AddRecursiveInsert(p) - c.Assert(err, Equals, merkletrie.ErrEmptyFileName) + s.ErrorIs(err, merkletrie.ErrEmptyFileName) err = ret.AddRecursiveDelete(p) - c.Assert(err, Equals, merkletrie.ErrEmptyFileName) + s.ErrorIs(err, merkletrie.ErrEmptyFileName) } -func (s ChangeSuite) TestNewInsert(c *C) { +func (s *ChangeSuite) TestNewInsert() { tree, err := fsnoder.New("(a(b(z<>)))") - c.Assert(err, IsNil) - path := find(c, tree, "z") + s.NoError(err) + path := find(s.T(), tree, "z") change := merkletrie.NewInsert(path) - c.Assert(change.String(), Equals, "") + s.Equal("", change.String()) shortPath := noder.Path([]noder.Noder{path.Last()}) change = merkletrie.NewInsert(shortPath) - c.Assert(change.String(), Equals, "") + s.Equal("", change.String()) } -func (s ChangeSuite) TestNewDelete(c *C) { +func (s *ChangeSuite) TestNewDelete() { tree, err := fsnoder.New("(a(b(z<>)))") - c.Assert(err, IsNil) - path := find(c, tree, "z") + s.NoError(err) + path := find(s.T(), tree, "z") change := merkletrie.NewDelete(path) - c.Assert(change.String(), Equals, "") + s.Equal("", change.String()) shortPath := noder.Path([]noder.Noder{path.Last()}) change = merkletrie.NewDelete(shortPath) - c.Assert(change.String(), Equals, "") + s.Equal("", change.String()) } -func (s ChangeSuite) TestNewModify(c *C) { +func (s *ChangeSuite) TestNewModify() { tree1, err := fsnoder.New("(a(b(z<>)))") - c.Assert(err, IsNil) - path1 := find(c, tree1, "z") + s.NoError(err) + path1 := find(s.T(), tree1, "z") tree2, err := fsnoder.New("(a(b(z<1>)))") - c.Assert(err, IsNil) - path2 := find(c, tree2, "z") + s.NoError(err) + path2 := find(s.T(), tree2, "z") change := merkletrie.NewModify(path1, path2) - c.Assert(change.String(), Equals, "") + s.Equal("", change.String()) shortPath1 := noder.Path([]noder.Noder{path1.Last()}) shortPath2 := noder.Path([]noder.Noder{path2.Last()}) change = merkletrie.NewModify(shortPath1, shortPath2) - c.Assert(change.String(), Equals, "") + s.Equal("", change.String()) } -func (s ChangeSuite) TestMalformedChange(c *C) { +func (s *ChangeSuite) TestMalformedChange() { change := merkletrie.Change{} - c.Assert(change.String, PanicMatches, "malformed change.*") + s.PanicsWithError("malformed change: nil from and to", func() { _ = change.String() }) } diff --git a/utils/merkletrie/difftree.go b/utils/merkletrie/difftree.go index 8090942dd..bd5805e4a 100644 --- a/utils/merkletrie/difftree.go +++ b/utils/merkletrie/difftree.go @@ -11,7 +11,7 @@ package merkletrie // corresponding changes and move the iterators further over both // trees. // -// The table bellow show all the possible comparison results, along +// The table below shows all the possible comparison results, along // with what changes should we produce and how to advance the // iterators. // @@ -252,7 +252,7 @@ import ( "errors" "fmt" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" ) var ( diff --git a/utils/merkletrie/difftree_test.go b/utils/merkletrie/difftree_test.go index c3937bfa0..b6a581039 100644 --- a/utils/merkletrie/difftree_test.go +++ b/utils/merkletrie/difftree_test.go @@ -4,23 +4,23 @@ import ( "bytes" ctx "context" "fmt" - "reflect" "sort" "strings" "testing" "unicode" - "github.com/go-git/go-git/v5/utils/merkletrie" - "github.com/go-git/go-git/v5/utils/merkletrie/internal/fsnoder" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/utils/merkletrie" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/internal/fsnoder" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } - -type DiffTreeSuite struct{} +type DiffTreeSuite struct { + suite.Suite +} -var _ = Suite(&DiffTreeSuite{}) +func TestDiffTreeSuite(t *testing.T) { + suite.Run(t, new(DiffTreeSuite)) +} type diffTreeTest struct { from string @@ -28,79 +28,83 @@ type diffTreeTest struct { expected string } -func (t diffTreeTest) innerRun(c *C, context string, reverse bool) { - comment := Commentf("\n%s", context) +func (t diffTreeTest) innerRun(s *DiffTreeSuite, context string, reverse bool) { + comment := fmt.Sprintf("\n%s", context) if reverse { - comment = Commentf("%s [REVERSED]", comment.CheckCommentString()) + comment = fmt.Sprintf("%s [REVERSED]", comment) } a, err := fsnoder.New(t.from) - c.Assert(err, IsNil, comment) - comment = Commentf("%s\n\t from = %s", comment.CheckCommentString(), a) + s.NoError(err, comment) + comment = fmt.Sprintf("%s\n\t from = %s", comment, a) b, err := fsnoder.New(t.to) - c.Assert(err, IsNil, comment) - comment = Commentf("%s\n\t to = %s", comment.CheckCommentString(), b) + s.NoError(err, comment) + comment = fmt.Sprintf("%s\n\t to = %s", comment, b) expected, err := newChangesFromString(t.expected) - c.Assert(err, IsNil, comment) + s.NoError(err, comment) if reverse { a, b = b, a expected = expected.reverse() } - comment = Commentf("%s\n\texpected = %s", comment.CheckCommentString(), expected) + comment = fmt.Sprintf("%s\n\texpected = %s", comment, expected) results, err := merkletrie.DiffTree(a, b, fsnoder.HashEqual) - c.Assert(err, IsNil, comment) + s.NoError(err, comment) obtained, err := newChanges(results) - c.Assert(err, IsNil, comment) + s.NoError(err, comment) - comment = Commentf("%s\n\tobtained = %s", comment.CheckCommentString(), obtained) + comment = fmt.Sprintf("%s\n\tobtained = %s", comment, obtained) - c.Assert(obtained, changesEquals, expected, comment) + sort.Sort(obtained) + sort.Sort(expected) + s.Equal(expected, obtained, comment) } -func (t diffTreeTest) innerRunCtx(c *C, context string, reverse bool) { - comment := Commentf("\n%s", context) +func (t diffTreeTest) innerRunCtx(s *DiffTreeSuite, context string, reverse bool) { + comment := fmt.Sprintf("\n%s", context) if reverse { - comment = Commentf("%s [REVERSED]", comment.CheckCommentString()) + comment = fmt.Sprintf("%s [REVERSED]", comment) } a, err := fsnoder.New(t.from) - c.Assert(err, IsNil, comment) - comment = Commentf("%s\n\t from = %s", comment.CheckCommentString(), a) + s.NoError(err, comment) + comment = fmt.Sprintf("%s\n\t from = %s", comment, a) b, err := fsnoder.New(t.to) - c.Assert(err, IsNil, comment) - comment = Commentf("%s\n\t to = %s", comment.CheckCommentString(), b) + s.NoError(err, comment) + comment = fmt.Sprintf("%s\n\t to = %s", comment, b) expected, err := newChangesFromString(t.expected) - c.Assert(err, IsNil, comment) + s.NoError(err, comment) if reverse { a, b = b, a expected = expected.reverse() } - comment = Commentf("%s\n\texpected = %s", comment.CheckCommentString(), expected) + comment = fmt.Sprintf("%s\n\texpected = %s", comment, expected) results, err := merkletrie.DiffTreeContext(ctx.Background(), a, b, fsnoder.HashEqual) - c.Assert(err, IsNil, comment) + s.NoError(err, comment) obtained, err := newChanges(results) - c.Assert(err, IsNil, comment) + s.NoError(err, comment) - comment = Commentf("%s\n\tobtained = %s", comment.CheckCommentString(), obtained) + comment = fmt.Sprintf("%s\n\tobtained = %s", comment, obtained) - c.Assert(obtained, changesEquals, expected, comment) + sort.Sort(obtained) + sort.Sort(expected) + s.Equal(expected, obtained, comment) } -func (t diffTreeTest) run(c *C, context string) { - t.innerRun(c, context, false) - t.innerRun(c, context, true) - t.innerRunCtx(c, context, false) - t.innerRunCtx(c, context, true) +func (t diffTreeTest) run(s *DiffTreeSuite, context string) { + t.innerRun(s, context, false) + t.innerRun(s, context, true) + t.innerRunCtx(s, context, false) + t.innerRunCtx(s, context, true) } type change struct { @@ -229,12 +233,6 @@ func (cc changes) Len() int { return len(cc) } func (cc changes) Swap(i, j int) { cc[i], cc[j] = cc[j], cc[i] } func (cc changes) Less(i, j int) bool { return strings.Compare(cc[i].String(), cc[j].String()) < 0 } -func (cc changes) equals(other changes) bool { - sort.Sort(cc) - sort.Sort(other) - return reflect.DeepEqual(cc, other) -} - func (cc changes) String() string { var buf bytes.Buffer fmt.Fprintf(&buf, "len(%d) [", len(cc)) @@ -256,35 +254,14 @@ func (cc changes) reverse() changes { return ret } -type changesEqualsChecker struct { - *CheckerInfo -} - -var changesEquals Checker = &changesEqualsChecker{ - &CheckerInfo{Name: "changesEquals", Params: []string{"obtained", "expected"}}, -} - -func (checker *changesEqualsChecker) Check(params []interface{}, names []string) (result bool, error string) { - a, ok := params[0].(changes) - if !ok { - return false, "first parameter must be a changes" - } - b, ok := params[1].(changes) - if !ok { - return false, "second parameter must be a changes" - } - - return a.equals(b), "" -} - -func do(c *C, list []diffTreeTest) { +func do(s *DiffTreeSuite, list []diffTreeTest) { for i, t := range list { - t.run(c, fmt.Sprintf("test #%d:", i)) + t.run(s, fmt.Sprintf("test #%d:", i)) } } -func (s *DiffTreeSuite) TestEmptyVsEmpty(c *C) { - do(c, []diffTreeTest{ +func (s *DiffTreeSuite) TestEmptyVsEmpty() { + do(s, []diffTreeTest{ {"()", "()", ""}, {"A()", "A()", ""}, {"A()", "()", ""}, @@ -292,8 +269,8 @@ func (s *DiffTreeSuite) TestEmptyVsEmpty(c *C) { }) } -func (s *DiffTreeSuite) TestBasicCases(c *C) { - do(c, []diffTreeTest{ +func (s *DiffTreeSuite) TestBasicCases() { + do(s, []diffTreeTest{ {"()", "()", ""}, {"()", "(a<>)", "+a"}, {"()", "(a<1>)", "+a"}, @@ -344,8 +321,8 @@ func (s *DiffTreeSuite) TestBasicCases(c *C) { }) } -func (s *DiffTreeSuite) TestHorizontals(c *C) { - do(c, []diffTreeTest{ +func (s *DiffTreeSuite) TestHorizontals() { + do(s, []diffTreeTest{ {"()", "(a<> b<>)", "+a +b"}, {"()", "(a<> b<1>)", "+a +b"}, {"()", "(a<> b())", "+a"}, @@ -361,8 +338,8 @@ func (s *DiffTreeSuite) TestHorizontals(c *C) { }) } -func (s *DiffTreeSuite) TestVerticals(c *C) { - do(c, []diffTreeTest{ +func (s *DiffTreeSuite) TestVerticals() { + do(s, []diffTreeTest{ {"()", "(z<>)", "+z"}, {"()", "(a(z<>))", "+a/z"}, {"()", "(a(b(z<>)))", "+a/b/z"}, @@ -372,8 +349,8 @@ func (s *DiffTreeSuite) TestVerticals(c *C) { }) } -func (s *DiffTreeSuite) TestSingleInserts(c *C) { - do(c, []diffTreeTest{ +func (s *DiffTreeSuite) TestSingleInserts() { + do(s, []diffTreeTest{ {"()", "(z<>)", "+z"}, {"(a())", "(a(z<>))", "+a/z"}, {"(a())", "(a(b(z<>)))", "+a/b/z"}, @@ -386,27 +363,29 @@ func (s *DiffTreeSuite) TestSingleInserts(c *C) { }) } -func (s *DiffTreeSuite) TestDebug(c *C) { - do(c, []diffTreeTest{ +func (s *DiffTreeSuite) TestDebug() { + do(s, []diffTreeTest{ {"(a(b<>) f<>)", "(a(b<> z<>) f<>)", "+a/z"}, }) } -// root -// / | \ -// / | ---- -// f d h -------- -// /\ / \ | -// e a j b/ g -// | / \ | -// l n k icm -// | -// o -// | -// p/ -func (s *DiffTreeSuite) TestCrazy(c *C) { +// root +// / | \ +// / | ---- +// f d h -------- +// /\ / \ | +// +// e a j b/ g +// | / \ | +// l n k icm +// +// | +// o +// | +// p/ +func (s *DiffTreeSuite) TestCrazy() { crazy := "(f(e(l<1>) a(n(o(p())) k<1>)) d<1> h(j(i<1> c<2> m<>) b() g<>))" - do(c, []diffTreeTest{ + do(s, []diffTreeTest{ { crazy, "()", @@ -447,8 +426,8 @@ func (s *DiffTreeSuite) TestCrazy(c *C) { }) } -func (s *DiffTreeSuite) TestSameNames(c *C) { - do(c, []diffTreeTest{ +func (s *DiffTreeSuite) TestSameNames() { + do(s, []diffTreeTest{ { "(a(a(a<>)))", "(a(a(a<1>)))", @@ -465,8 +444,8 @@ func (s *DiffTreeSuite) TestSameNames(c *C) { }) } -func (s *DiffTreeSuite) TestIssue275(c *C) { - do(c, []diffTreeTest{ +func (s *DiffTreeSuite) TestIssue275() { + do(s, []diffTreeTest{ { "(a(b(c.go<1>) b.go<2>))", "(a(b(c.go<1> d.go<3>) b.go<2>))", @@ -475,11 +454,11 @@ func (s *DiffTreeSuite) TestIssue275(c *C) { }) } -func (s *DiffTreeSuite) TestIssue1057(c *C) { +func (s *DiffTreeSuite) TestIssue1057() { p1 := "TestAppWithUnicodéPath" p2 := "TestAppWithUnicodéPath" - c.Assert(p1 == p2, Equals, false) - do(c, []diffTreeTest{ + s.False(p1 == p2) + do(s, []diffTreeTest{ { fmt.Sprintf("(%s(x.go<1>))", p1), fmt.Sprintf("(%s(x.go<1>) %s(x.go<1>))", p1, p2), @@ -487,7 +466,7 @@ func (s *DiffTreeSuite) TestIssue1057(c *C) { }, }) // swap p1 with p2 - do(c, []diffTreeTest{ + do(s, []diffTreeTest{ { fmt.Sprintf("(%s(x.go<1>))", p2), fmt.Sprintf("(%s(x.go<1>) %s(x.go<1>))", p1, p2), @@ -496,26 +475,26 @@ func (s *DiffTreeSuite) TestIssue1057(c *C) { }) } -func (s *DiffTreeSuite) TestCancel(c *C) { +func (s *DiffTreeSuite) TestCancel() { t := diffTreeTest{"()", "(a<> b<1> c() d<> e<2> f())", "+a +b +d +e"} - comment := Commentf("\n%s", "test cancel:") + comment := fmt.Sprintf("\n%s", "test cancel:") a, err := fsnoder.New(t.from) - c.Assert(err, IsNil, comment) - comment = Commentf("%s\n\t from = %s", comment.CheckCommentString(), a) + s.NoError(err, comment) + comment = fmt.Sprintf("%s\n\t from = %s", comment, a) b, err := fsnoder.New(t.to) - c.Assert(err, IsNil, comment) - comment = Commentf("%s\n\t to = %s", comment.CheckCommentString(), b) + s.NoError(err, comment) + comment = fmt.Sprintf("%s\n\t to = %s", comment, b) expected, err := newChangesFromString(t.expected) - c.Assert(err, IsNil, comment) + s.NoError(err, comment) - comment = Commentf("%s\n\texpected = %s", comment.CheckCommentString(), expected) + comment = fmt.Sprintf("%s\n\texpected = %s", comment, expected) context, cancel := ctx.WithCancel(ctx.Background()) cancel() results, err := merkletrie.DiffTreeContext(context, a, b, fsnoder.HashEqual) - c.Assert(results, IsNil, comment) - c.Assert(err, ErrorMatches, "operation canceled") + s.Nil(results, comment) + s.ErrorContains(err, "operation canceled") } diff --git a/utils/merkletrie/doubleiter.go b/utils/merkletrie/doubleiter.go index 4a4341b38..2a6e6843d 100644 --- a/utils/merkletrie/doubleiter.go +++ b/utils/merkletrie/doubleiter.go @@ -4,7 +4,7 @@ import ( "fmt" "io" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" ) // A doubleIter is a convenience type to keep track of the current diff --git a/utils/merkletrie/filesystem/node.go b/utils/merkletrie/filesystem/node.go index 33800627d..a96f1e8f2 100644 --- a/utils/merkletrie/filesystem/node.go +++ b/utils/merkletrie/filesystem/node.go @@ -5,9 +5,9 @@ import ( "os" "path" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/filemode" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" "github.com/go-git/go-billy/v5" ) diff --git a/utils/merkletrie/filesystem/node_test.go b/utils/merkletrie/filesystem/node_test.go index b76abc412..ff92dde02 100644 --- a/utils/merkletrie/filesystem/node_test.go +++ b/utils/merkletrie/filesystem/node_test.go @@ -10,23 +10,25 @@ import ( "runtime" "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/utils/merkletrie" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/utils/merkletrie" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" + "github.com/stretchr/testify/suite" "github.com/go-git/go-billy/v5" "github.com/go-git/go-billy/v5/memfs" "github.com/go-git/go-billy/v5/osfs" - . "gopkg.in/check.v1" ) -func Test(t *testing.T) { TestingT(t) } - -type NoderSuite struct{} +type NoderSuite struct { + suite.Suite +} -var _ = Suite(&NoderSuite{}) +func TestNoderSuite(t *testing.T) { + suite.Run(t, new(NoderSuite)) +} -func (s *NoderSuite) TestDiff(c *C) { +func (s *NoderSuite) TestDiff() { fsA := memfs.New() WriteFile(fsA, "foo", []byte("foo"), 0644) WriteFile(fsA, "qux/bar", []byte("foo"), 0644) @@ -45,11 +47,11 @@ func (s *NoderSuite) TestDiff(c *C) { IsEquals, ) - c.Assert(err, IsNil) - c.Assert(ch, HasLen, 0) + s.NoError(err) + s.Len(ch, 0) } -func (s *NoderSuite) TestDiffChangeLink(c *C) { +func (s *NoderSuite) TestDiffChangeLink() { fsA := memfs.New() fsA.Symlink("qux", "foo") @@ -62,11 +64,11 @@ func (s *NoderSuite) TestDiffChangeLink(c *C) { IsEquals, ) - c.Assert(err, IsNil) - c.Assert(ch, HasLen, 1) + s.NoError(err) + s.Len(ch, 1) } -func (s *NoderSuite) TestDiffChangeContent(c *C) { +func (s *NoderSuite) TestDiffChangeContent() { fsA := memfs.New() WriteFile(fsA, "foo", []byte("foo"), 0644) WriteFile(fsA, "qux/bar", []byte("foo"), 0644) @@ -83,11 +85,11 @@ func (s *NoderSuite) TestDiffChangeContent(c *C) { IsEquals, ) - c.Assert(err, IsNil) - c.Assert(ch, HasLen, 1) + s.NoError(err) + s.Len(ch, 1) } -func (s *NoderSuite) TestDiffSymlinkDirOnA(c *C) { +func (s *NoderSuite) TestDiffSymlinkDirOnA() { fsA := memfs.New() WriteFile(fsA, "qux/qux", []byte("foo"), 0644) @@ -101,11 +103,11 @@ func (s *NoderSuite) TestDiffSymlinkDirOnA(c *C) { IsEquals, ) - c.Assert(err, IsNil) - c.Assert(ch, HasLen, 1) + s.NoError(err) + s.Len(ch, 1) } -func (s *NoderSuite) TestDiffSymlinkDirOnB(c *C) { +func (s *NoderSuite) TestDiffSymlinkDirOnB() { fsA := memfs.New() fsA.Symlink("qux", "foo") WriteFile(fsA, "qux/qux", []byte("foo"), 0644) @@ -119,11 +121,11 @@ func (s *NoderSuite) TestDiffSymlinkDirOnB(c *C) { IsEquals, ) - c.Assert(err, IsNil) - c.Assert(ch, HasLen, 1) + s.NoError(err) + s.Len(ch, 1) } -func (s *NoderSuite) TestDiffChangeMissing(c *C) { +func (s *NoderSuite) TestDiffChangeMissing() { fsA := memfs.New() WriteFile(fsA, "foo", []byte("foo"), 0644) @@ -136,11 +138,11 @@ func (s *NoderSuite) TestDiffChangeMissing(c *C) { IsEquals, ) - c.Assert(err, IsNil) - c.Assert(ch, HasLen, 2) + s.NoError(err) + s.Len(ch, 2) } -func (s *NoderSuite) TestDiffChangeMode(c *C) { +func (s *NoderSuite) TestDiffChangeMode() { fsA := memfs.New() WriteFile(fsA, "foo", []byte("foo"), 0644) @@ -153,11 +155,11 @@ func (s *NoderSuite) TestDiffChangeMode(c *C) { IsEquals, ) - c.Assert(err, IsNil) - c.Assert(ch, HasLen, 1) + s.NoError(err) + s.Len(ch, 1) } -func (s *NoderSuite) TestDiffChangeModeNotRelevant(c *C) { +func (s *NoderSuite) TestDiffChangeModeNotRelevant() { fsA := memfs.New() WriteFile(fsA, "foo", []byte("foo"), 0644) @@ -170,11 +172,11 @@ func (s *NoderSuite) TestDiffChangeModeNotRelevant(c *C) { IsEquals, ) - c.Assert(err, IsNil) - c.Assert(ch, HasLen, 0) + s.NoError(err) + s.Len(ch, 0) } -func (s *NoderSuite) TestDiffDirectory(c *C) { +func (s *NoderSuite) TestDiffDirectory() { dir := path.Join("qux", "bar") fsA := memfs.New() fsA.MkdirAll(dir, 0644) @@ -192,25 +194,24 @@ func (s *NoderSuite) TestDiffDirectory(c *C) { IsEquals, ) - c.Assert(err, IsNil) - c.Assert(ch, HasLen, 1) + s.NoError(err) + s.Len(ch, 1) a, err := ch[0].Action() - c.Assert(err, IsNil) - c.Assert(a, Equals, merkletrie.Modify) + s.NoError(err) + s.Equal(merkletrie.Modify, a) } -func (s *NoderSuite) TestSocket(c *C) { +func (s *NoderSuite) TestSocket() { if runtime.GOOS == "windows" { - c.Skip("socket files do not exist on windows") + s.T().Skip("socket files do not exist on windows") } td, err := os.MkdirTemp("", "socket-test") - defer os.RemoveAll(td) - c.Assert(err, IsNil) + s.NoError(err) sock, err := net.ListenUnix("unix", &net.UnixAddr{Name: fmt.Sprintf("%s/socket", td), Net: "unix"}) - c.Assert(err, IsNil) + s.NoError(err) defer sock.Close() fsA := osfs.New(td) @@ -218,8 +219,8 @@ func (s *NoderSuite) TestSocket(c *C) { noder := NewRootNode(fsA, nil) childs, err := noder.Children() - c.Assert(err, IsNil) - c.Assert(childs, HasLen, 1) + s.NoError(err) + s.Len(childs, 1) } func WriteFile(fs billy.Filesystem, filename string, data []byte, perm os.FileMode) error { diff --git a/utils/merkletrie/index/node.go b/utils/merkletrie/index/node.go index c1809f7ec..59cd17f84 100644 --- a/utils/merkletrie/index/node.go +++ b/utils/merkletrie/index/node.go @@ -4,8 +4,8 @@ import ( "path" "strings" - "github.com/go-git/go-git/v5/plumbing/format/index" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" + "github.com/jesseduffield/go-git/v5/plumbing/format/index" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" ) // The node represents a index.Entry or a directory inferred from the path diff --git a/utils/merkletrie/index/node_test.go b/utils/merkletrie/index/node_test.go index cc5600dcb..8a1f79ffc 100644 --- a/utils/merkletrie/index/node_test.go +++ b/utils/merkletrie/index/node_test.go @@ -5,21 +5,22 @@ import ( "path/filepath" "testing" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/index" - "github.com/go-git/go-git/v5/utils/merkletrie" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/format/index" + "github.com/jesseduffield/go-git/v5/utils/merkletrie" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } - -type NoderSuite struct{} +type NoderSuite struct { + suite.Suite +} -var _ = Suite(&NoderSuite{}) +func TestNoderSuite(t *testing.T) { + suite.Run(t, new(NoderSuite)) +} -func (s *NoderSuite) TestDiff(c *C) { +func (s *NoderSuite) TestDiff() { indexA := &index.Index{ Entries: []*index.Entry{ {Name: "foo", Hash: plumbing.NewHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d")}, @@ -39,11 +40,11 @@ func (s *NoderSuite) TestDiff(c *C) { } ch, err := merkletrie.DiffTree(NewRootNode(indexA), NewRootNode(indexB), isEquals) - c.Assert(err, IsNil) - c.Assert(ch, HasLen, 0) + s.NoError(err) + s.Len(ch, 0) } -func (s *NoderSuite) TestDiffChange(c *C) { +func (s *NoderSuite) TestDiffChange() { indexA := &index.Index{ Entries: []*index.Entry{{ Name: filepath.Join("bar", "baz", "bar"), @@ -59,11 +60,11 @@ func (s *NoderSuite) TestDiffChange(c *C) { } ch, err := merkletrie.DiffTree(NewRootNode(indexA), NewRootNode(indexB), isEquals) - c.Assert(err, IsNil) - c.Assert(ch, HasLen, 2) + s.NoError(err) + s.Len(ch, 2) } -func (s *NoderSuite) TestDiffDir(c *C) { +func (s *NoderSuite) TestDiffDir() { indexA := &index.Index{ Entries: []*index.Entry{{ Name: "foo", @@ -79,11 +80,11 @@ func (s *NoderSuite) TestDiffDir(c *C) { } ch, err := merkletrie.DiffTree(NewRootNode(indexA), NewRootNode(indexB), isEquals) - c.Assert(err, IsNil) - c.Assert(ch, HasLen, 2) + s.NoError(err) + s.Len(ch, 2) } -func (s *NoderSuite) TestDiffSameRoot(c *C) { +func (s *NoderSuite) TestDiffSameRoot() { indexA := &index.Index{ Entries: []*index.Entry{ {Name: "foo.go", Hash: plumbing.NewHash("aab686eafeb1f44702738c8b0f24f2567c36da6d")}, @@ -99,8 +100,8 @@ func (s *NoderSuite) TestDiffSameRoot(c *C) { } ch, err := merkletrie.DiffTree(NewRootNode(indexA), NewRootNode(indexB), isEquals) - c.Assert(err, IsNil) - c.Assert(ch, HasLen, 1) + s.NoError(err) + s.Len(ch, 1) } var empty = make([]byte, 24) diff --git a/utils/merkletrie/internal/frame/frame.go b/utils/merkletrie/internal/frame/frame.go index 131878a1c..b24f97a55 100644 --- a/utils/merkletrie/internal/frame/frame.go +++ b/utils/merkletrie/internal/frame/frame.go @@ -6,7 +6,7 @@ import ( "sort" "strings" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" ) // A Frame is a collection of siblings in a trie, sorted alphabetically diff --git a/utils/merkletrie/internal/frame/frame_test.go b/utils/merkletrie/internal/frame/frame_test.go index 0544c8b02..9a22ad465 100644 --- a/utils/merkletrie/internal/frame/frame_test.go +++ b/utils/merkletrie/internal/frame/frame_test.go @@ -4,85 +4,86 @@ import ( "fmt" "testing" - "github.com/go-git/go-git/v5/utils/merkletrie/internal/fsnoder" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/internal/fsnoder" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } - -type FrameSuite struct{} +type FrameSuite struct { + suite.Suite +} -var _ = Suite(&FrameSuite{}) +func TestFrameSuite(t *testing.T) { + suite.Run(t, new(FrameSuite)) +} -func (s *FrameSuite) TestNewFrameFromEmptyDir(c *C) { +func (s *FrameSuite) TestNewFrameFromEmptyDir() { A, err := fsnoder.New("A()") - c.Assert(err, IsNil) + s.NoError(err) frame, err := New(A) - c.Assert(err, IsNil) + s.NoError(err) expectedString := `[]` - c.Assert(frame.String(), Equals, expectedString) + s.Equal(expectedString, frame.String()) first, ok := frame.First() - c.Assert(first, IsNil) - c.Assert(ok, Equals, false) + s.Nil(first) + s.False(ok) first, ok = frame.First() - c.Assert(first, IsNil) - c.Assert(ok, Equals, false) + s.Nil(first) + s.False(ok) l := frame.Len() - c.Assert(l, Equals, 0) + s.Equal(0, l) } -func (s *FrameSuite) TestNewFrameFromNonEmpty(c *C) { +func (s *FrameSuite) TestNewFrameFromNonEmpty() { // _______A/________ // | / \ | // x y B/ C/ // | // z root, err := fsnoder.New("A(x<> y<> B() C(z<>))") - c.Assert(err, IsNil) + s.NoError(err) frame, err := New(root) - c.Assert(err, IsNil) + s.NoError(err) expectedString := `["B", "C", "x", "y"]` - c.Assert(frame.String(), Equals, expectedString) + s.Equal(expectedString, frame.String()) l := frame.Len() - c.Assert(l, Equals, 4) + s.Equal(4, l) - checkFirstAndDrop(c, frame, "B", true) + checkFirstAndDrop(s, frame, "B", true) l = frame.Len() - c.Assert(l, Equals, 3) + s.Equal(3, l) - checkFirstAndDrop(c, frame, "C", true) + checkFirstAndDrop(s, frame, "C", true) l = frame.Len() - c.Assert(l, Equals, 2) + s.Equal(2, l) - checkFirstAndDrop(c, frame, "x", true) + checkFirstAndDrop(s, frame, "x", true) l = frame.Len() - c.Assert(l, Equals, 1) + s.Equal(1, l) - checkFirstAndDrop(c, frame, "y", true) + checkFirstAndDrop(s, frame, "y", true) l = frame.Len() - c.Assert(l, Equals, 0) + s.Equal(0, l) - checkFirstAndDrop(c, frame, "", false) + checkFirstAndDrop(s, frame, "", false) l = frame.Len() - c.Assert(l, Equals, 0) + s.Equal(0, l) - checkFirstAndDrop(c, frame, "", false) + checkFirstAndDrop(s, frame, "", false) } -func checkFirstAndDrop(c *C, f *Frame, expectedNodeName string, expectedOK bool) { +func checkFirstAndDrop(s *FrameSuite, f *Frame, expectedNodeName string, expectedOK bool) { first, ok := f.First() - c.Assert(ok, Equals, expectedOK) + s.Equal(expectedOK, ok) if expectedOK { - c.Assert(first.Name(), Equals, expectedNodeName) + s.Equal(expectedNodeName, first.Name()) } f.Drop() @@ -95,7 +96,7 @@ func (e *errorNoder) Children() ([]noder.Noder, error) { return nil, fmt.Errorf("mock error") } -func (s *FrameSuite) TestNewFrameErrors(c *C) { +func (s *FrameSuite) TestNewFrameErrors() { _, err := New(&errorNoder{}) - c.Assert(err, ErrorMatches, "mock error") + s.ErrorContains(err, "mock error") } diff --git a/utils/merkletrie/internal/fsnoder/dir.go b/utils/merkletrie/internal/fsnoder/dir.go index 3a4c2424e..87269633e 100644 --- a/utils/merkletrie/internal/fsnoder/dir.go +++ b/utils/merkletrie/internal/fsnoder/dir.go @@ -7,7 +7,7 @@ import ( "sort" "strings" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" ) // Dir values implement directory-like noders. diff --git a/utils/merkletrie/internal/fsnoder/dir_test.go b/utils/merkletrie/internal/fsnoder/dir_test.go index 1a6ea03ca..6cf7dbba4 100644 --- a/utils/merkletrie/internal/fsnoder/dir_test.go +++ b/utils/merkletrie/internal/fsnoder/dir_test.go @@ -1,243 +1,215 @@ package fsnoder import ( - "reflect" "sort" + "testing" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" ) -type DirSuite struct{} +type DirSuite struct { + suite.Suite +} -var _ = Suite(&DirSuite{}) +func TestDirSuite(t *testing.T) { + suite.Run(t, new(DirSuite)) +} -func (s *DirSuite) TestIsDir(c *C) { +func (s *DirSuite) TestIsDir() { noName, err := newDir("", nil) - c.Assert(err, IsNil) - c.Assert(noName.IsDir(), Equals, true) + s.NoError(err) + s.True(noName.IsDir()) empty, err := newDir("empty", nil) - c.Assert(err, IsNil) - c.Assert(empty.IsDir(), Equals, true) + s.NoError(err) + s.True(empty.IsDir()) root, err := newDir("foo", []noder.Noder{empty}) - c.Assert(err, IsNil) - c.Assert(root.IsDir(), Equals, true) + s.NoError(err) + s.True(root.IsDir()) } -func assertChildren(c *C, n noder.Noder, expected []noder.Noder) { +func assertChildren(t *testing.T, n noder.Noder, expected []noder.Noder) { numChildren, err := n.NumChildren() - c.Assert(err, IsNil) - c.Assert(numChildren, Equals, len(expected)) + assert.NoError(t, err) + assert.Len(t, expected, numChildren) children, err := n.Children() - c.Assert(err, IsNil) - c.Assert(children, sortedSliceEquals, expected) -} - -type sortedSliceEqualsChecker struct { - *CheckerInfo + assert.NoError(t, err) + sort.Sort(byName(children)) + sort.Sort(byName(expected)) + assert.Equal(t, expected, children) } -var sortedSliceEquals Checker = &sortedSliceEqualsChecker{ - &CheckerInfo{ - Name: "sortedSliceEquals", - Params: []string{"obtained", "expected"}, - }, -} - -func (checker *sortedSliceEqualsChecker) Check( - params []interface{}, names []string) (result bool, error string) { - a, ok := params[0].([]noder.Noder) - if !ok { - return false, "first parameter must be a []noder.Noder" - } - b, ok := params[1].([]noder.Noder) - if !ok { - return false, "second parameter must be a []noder.Noder" - } - sort.Sort(byName(a)) - sort.Sort(byName(b)) - - return reflect.DeepEqual(a, b), "" -} - -func (s *DirSuite) TestNewDirectoryNoNameAndEmpty(c *C) { +func (s *DirSuite) TestNewDirectoryNoNameAndEmpty() { root, err := newDir("", nil) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(root.Hash(), DeepEquals, - []byte{0xca, 0x40, 0xf8, 0x67, 0x57, 0x8c, 0x32, 0x1c}) - c.Assert(root.Name(), Equals, "") - assertChildren(c, root, noder.NoChildren) - c.Assert(root.String(), Equals, "()") + s.Equal([]byte{0xca, 0x40, 0xf8, 0x67, 0x57, 0x8c, 0x32, 0x1c}, root.Hash()) + s.Equal("", root.Name()) + assertChildren(s.T(), root, noder.NoChildren) + s.Equal("()", root.String()) } -func (s *DirSuite) TestNewDirectoryEmpty(c *C) { +func (s *DirSuite) TestNewDirectoryEmpty() { root, err := newDir("root", nil) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(root.Hash(), DeepEquals, - []byte{0xca, 0x40, 0xf8, 0x67, 0x57, 0x8c, 0x32, 0x1c}) - c.Assert(root.Name(), Equals, "root") - assertChildren(c, root, noder.NoChildren) - c.Assert(root.String(), Equals, "root()") + s.Equal([]byte{0xca, 0x40, 0xf8, 0x67, 0x57, 0x8c, 0x32, 0x1c}, root.Hash()) + s.Equal("root", root.Name()) + assertChildren(s.T(), root, noder.NoChildren) + s.Equal("root()", root.String()) } -func (s *DirSuite) TestEmptyDirsHaveSameHash(c *C) { +func (s *DirSuite) TestEmptyDirsHaveSameHash() { d1, err := newDir("foo", nil) - c.Assert(err, IsNil) + s.NoError(err) d2, err := newDir("bar", nil) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(d1.Hash(), DeepEquals, d2.Hash()) + s.Equal(d2.Hash(), d1.Hash()) } -func (s *DirSuite) TestNewDirWithEmptyDir(c *C) { +func (s *DirSuite) TestNewDirWithEmptyDir() { empty, err := newDir("empty", nil) - c.Assert(err, IsNil) + s.NoError(err) root, err := newDir("", []noder.Noder{empty}) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(root.Hash(), DeepEquals, - []byte{0x39, 0x25, 0xa8, 0x99, 0x16, 0x47, 0x6a, 0x75}) - c.Assert(root.Name(), Equals, "") - assertChildren(c, root, []noder.Noder{empty}) - c.Assert(root.String(), Equals, "(empty())") + s.Equal([]byte{0x39, 0x25, 0xa8, 0x99, 0x16, 0x47, 0x6a, 0x75}, root.Hash()) + s.Equal("", root.Name()) + assertChildren(s.T(), root, []noder.Noder{empty}) + s.Equal("(empty())", root.String()) } -func (s *DirSuite) TestNewDirWithOneEmptyFile(c *C) { +func (s *DirSuite) TestNewDirWithOneEmptyFile() { empty, err := newFile("name", "") - c.Assert(err, IsNil) + s.NoError(err) root, err := newDir("", []noder.Noder{empty}) - c.Assert(err, IsNil) - c.Assert(root.Hash(), DeepEquals, - []byte{0xd, 0x4e, 0x23, 0x1d, 0xf5, 0x2e, 0xfa, 0xc2}) - c.Assert(root.Name(), Equals, "") - assertChildren(c, root, []noder.Noder{empty}) - c.Assert(root.String(), Equals, "(name<>)") + s.NoError(err) + s.Equal([]byte{0xd, 0x4e, 0x23, 0x1d, 0xf5, 0x2e, 0xfa, 0xc2}, root.Hash()) + s.Equal("", root.Name()) + assertChildren(s.T(), root, []noder.Noder{empty}) + s.Equal("(name<>)", root.String()) } -func (s *DirSuite) TestNewDirWithOneFile(c *C) { +func (s *DirSuite) TestNewDirWithOneFile() { a, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) root, err := newDir("", []noder.Noder{a}) - c.Assert(err, IsNil) - c.Assert(root.Hash(), DeepEquals, - []byte{0x96, 0xab, 0x29, 0x54, 0x2, 0x9e, 0x89, 0x28}) - c.Assert(root.Name(), Equals, "") - assertChildren(c, root, []noder.Noder{a}) - c.Assert(root.String(), Equals, "(a<1>)") + s.NoError(err) + s.Equal([]byte{0x96, 0xab, 0x29, 0x54, 0x2, 0x9e, 0x89, 0x28}, root.Hash()) + s.Equal("", root.Name()) + assertChildren(s.T(), root, []noder.Noder{a}) + s.Equal("(a<1>)", root.String()) } -func (s *DirSuite) TestDirsWithSameFileHaveSameHash(c *C) { +func (s *DirSuite) TestDirsWithSameFileHaveSameHash() { f1, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) r1, err := newDir("", []noder.Noder{f1}) - c.Assert(err, IsNil) + s.NoError(err) f2, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) r2, err := newDir("", []noder.Noder{f2}) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(r1.Hash(), DeepEquals, r2.Hash()) + s.Equal(r2.Hash(), r1.Hash()) } -func (s *DirSuite) TestDirsWithDifferentFileContentHaveDifferentHash(c *C) { +func (s *DirSuite) TestDirsWithDifferentFileContentHaveDifferentHash() { f1, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) r1, err := newDir("", []noder.Noder{f1}) - c.Assert(err, IsNil) + s.NoError(err) f2, err := newFile("a", "2") - c.Assert(err, IsNil) + s.NoError(err) r2, err := newDir("", []noder.Noder{f2}) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(r1.Hash(), Not(DeepEquals), r2.Hash()) + s.NotEqual(r2.Hash(), r1.Hash()) } -func (s *DirSuite) TestDirsWithDifferentFileNameHaveDifferentHash(c *C) { +func (s *DirSuite) TestDirsWithDifferentFileNameHaveDifferentHash() { f1, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) r1, err := newDir("", []noder.Noder{f1}) - c.Assert(err, IsNil) + s.NoError(err) f2, err := newFile("b", "1") - c.Assert(err, IsNil) + s.NoError(err) r2, err := newDir("", []noder.Noder{f2}) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(r1.Hash(), Not(DeepEquals), r2.Hash()) + s.NotEqual(r2.Hash(), r1.Hash()) } -func (s *DirSuite) TestDirsWithDifferentFileHaveDifferentHash(c *C) { +func (s *DirSuite) TestDirsWithDifferentFileHaveDifferentHash() { f1, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) r1, err := newDir("", []noder.Noder{f1}) - c.Assert(err, IsNil) + s.NoError(err) f2, err := newFile("b", "2") - c.Assert(err, IsNil) + s.NoError(err) r2, err := newDir("", []noder.Noder{f2}) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(r1.Hash(), Not(DeepEquals), r2.Hash()) + s.NotEqual(r2.Hash(), r1.Hash()) } -func (s *DirSuite) TestDirWithEmptyDirHasDifferentHashThanEmptyDir(c *C) { +func (s *DirSuite) TestDirWithEmptyDirHasDifferentHashThanEmptyDir() { f, err := newFile("a", "") - c.Assert(err, IsNil) + s.NoError(err) r1, err := newDir("", []noder.Noder{f}) - c.Assert(err, IsNil) + s.NoError(err) d, err := newDir("a", nil) - c.Assert(err, IsNil) + s.NoError(err) r2, err := newDir("", []noder.Noder{d}) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(r1.Hash(), Not(DeepEquals), r2.Hash()) + s.NotEqual(r2.Hash(), r1.Hash()) } -func (s *DirSuite) TestNewDirWithTwoFilesSameContent(c *C) { +func (s *DirSuite) TestNewDirWithTwoFilesSameContent() { a1, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) b1, err := newFile("b", "1") - c.Assert(err, IsNil) + s.NoError(err) root, err := newDir("", []noder.Noder{a1, b1}) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(root.Hash(), DeepEquals, - []byte{0xc7, 0xc4, 0xbf, 0x70, 0x33, 0xb9, 0x57, 0xdb}) - c.Assert(root.Name(), Equals, "") - assertChildren(c, root, []noder.Noder{b1, a1}) - c.Assert(root.String(), Equals, "(a<1> b<1>)") + s.Equal([]byte{0xc7, 0xc4, 0xbf, 0x70, 0x33, 0xb9, 0x57, 0xdb}, root.Hash()) + s.Equal("", root.Name()) + assertChildren(s.T(), root, []noder.Noder{b1, a1}) + s.Equal("(a<1> b<1>)", root.String()) } -func (s *DirSuite) TestNewDirWithTwoFilesDifferentContent(c *C) { +func (s *DirSuite) TestNewDirWithTwoFilesDifferentContent() { a1, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) b2, err := newFile("b", "2") - c.Assert(err, IsNil) + s.NoError(err) root, err := newDir("", []noder.Noder{a1, b2}) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(root.Hash(), DeepEquals, - []byte{0x94, 0x8a, 0x9d, 0x8f, 0x6d, 0x98, 0x34, 0x55}) - c.Assert(root.Name(), Equals, "") - assertChildren(c, root, []noder.Noder{b2, a1}) + s.Equal([]byte{0x94, 0x8a, 0x9d, 0x8f, 0x6d, 0x98, 0x34, 0x55}, root.Hash()) + s.Equal("", root.Name()) + assertChildren(s.T(), root, []noder.Noder{b2, a1}) } -func (s *DirSuite) TestCrazy(c *C) { +func (s *DirSuite) TestCrazy() { // "" // | // ------------------------- @@ -250,115 +222,113 @@ func (s *DirSuite) TestCrazy(c *C) { // | | // a1 e1 e1, err := newFile("e", "1") - c.Assert(err, IsNil) + s.NoError(err) E, err := newDir("e", []noder.Noder{e1}) - c.Assert(err, IsNil) + s.NoError(err) E, err = newDir("e", []noder.Noder{E}) - c.Assert(err, IsNil) + s.NoError(err) E, err = newDir("e", []noder.Noder{E}) - c.Assert(err, IsNil) + s.NoError(err) A, err := newDir("a", nil) - c.Assert(err, IsNil) + s.NoError(err) B, err := newDir("b", nil) - c.Assert(err, IsNil) + s.NoError(err) a1, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) X, err := newDir("x", []noder.Noder{a1}) - c.Assert(err, IsNil) + s.NoError(err) c1, err := newFile("c", "1") - c.Assert(err, IsNil) + s.NoError(err) B, err = newDir("b", []noder.Noder{c1, B, X, A}) - c.Assert(err, IsNil) + s.NoError(err) a1, err = newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) c1, err = newFile("c", "1") - c.Assert(err, IsNil) + s.NoError(err) d2, err := newFile("d", "2") - c.Assert(err, IsNil) + s.NoError(err) root, err := newDir("", []noder.Noder{a1, d2, E, B, c1}) - c.Assert(err, IsNil) - - c.Assert(root.Hash(), DeepEquals, - []byte{0xc3, 0x72, 0x9d, 0xf1, 0xcc, 0xec, 0x6d, 0xbb}) - c.Assert(root.Name(), Equals, "") - assertChildren(c, root, []noder.Noder{E, c1, B, a1, d2}) - c.Assert(root.String(), Equals, - "(a<1> b(a() b() c<1> x(a<1>)) c<1> d<2> e(e(e(e<1>))))") + s.NoError(err) + + s.Equal([]byte{0xc3, 0x72, 0x9d, 0xf1, 0xcc, 0xec, 0x6d, 0xbb}, root.Hash()) + s.Equal("", root.Name()) + assertChildren(s.T(), root, []noder.Noder{E, c1, B, a1, d2}) + s.Equal("(a<1> b(a() b() c<1> x(a<1>)) c<1> d<2> e(e(e(e<1>))))", root.String()) } -func (s *DirSuite) TestDirCannotHaveDirWithNoName(c *C) { +func (s *DirSuite) TestDirCannotHaveDirWithNoName() { noName, err := newDir("", nil) - c.Assert(err, IsNil) + s.NoError(err) _, err = newDir("", []noder.Noder{noName}) - c.Assert(err, Not(IsNil)) + s.Error(err) } -func (s *DirSuite) TestDirCannotHaveDuplicatedFiles(c *C) { +func (s *DirSuite) TestDirCannotHaveDuplicatedFiles() { f1, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) f2, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) _, err = newDir("", []noder.Noder{f1, f2}) - c.Assert(err, Not(IsNil)) + s.Error(err) } -func (s *DirSuite) TestDirCannotHaveDuplicatedFileNames(c *C) { +func (s *DirSuite) TestDirCannotHaveDuplicatedFileNames() { a1, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) a2, err := newFile("a", "2") - c.Assert(err, IsNil) + s.NoError(err) _, err = newDir("", []noder.Noder{a1, a2}) - c.Assert(err, Not(IsNil)) + s.Error(err) } -func (s *DirSuite) TestDirCannotHaveDuplicatedDirNames(c *C) { +func (s *DirSuite) TestDirCannotHaveDuplicatedDirNames() { d1, err := newDir("a", nil) - c.Assert(err, IsNil) + s.NoError(err) d2, err := newDir("a", nil) - c.Assert(err, IsNil) + s.NoError(err) _, err = newDir("", []noder.Noder{d1, d2}) - c.Assert(err, Not(IsNil)) + s.Error(err) } -func (s *DirSuite) TestDirCannotHaveDirAndFileWithSameName(c *C) { +func (s *DirSuite) TestDirCannotHaveDirAndFileWithSameName() { f, err := newFile("a", "") - c.Assert(err, IsNil) + s.NoError(err) d, err := newDir("a", nil) - c.Assert(err, IsNil) + s.NoError(err) _, err = newDir("", []noder.Noder{f, d}) - c.Assert(err, Not(IsNil)) + s.Error(err) } -func (s *DirSuite) TestUnsortedString(c *C) { +func (s *DirSuite) TestUnsortedString() { b, err := newDir("b", nil) - c.Assert(err, IsNil) + s.NoError(err) z, err := newDir("z", nil) - c.Assert(err, IsNil) + s.NoError(err) a1, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) c2, err := newFile("c", "2") - c.Assert(err, IsNil) + s.NoError(err) d3, err := newFile("d", "3") - c.Assert(err, IsNil) + s.NoError(err) d, err := newDir("d", []noder.Noder{c2, z, d3, a1, b}) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(d.String(), Equals, "d(a<1> b() c<2> d<3> z())") + s.Equal("d(a<1> b() c<2> d<3> z())", d.String()) } diff --git a/utils/merkletrie/internal/fsnoder/file.go b/utils/merkletrie/internal/fsnoder/file.go index 453efee04..29eb1b9e4 100644 --- a/utils/merkletrie/internal/fsnoder/file.go +++ b/utils/merkletrie/internal/fsnoder/file.go @@ -5,7 +5,7 @@ import ( "fmt" "hash/fnv" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" ) // file values represent file-like noders in a merkle trie. diff --git a/utils/merkletrie/internal/fsnoder/file_test.go b/utils/merkletrie/internal/fsnoder/file_test.go index b949b53dd..c970998d8 100644 --- a/utils/merkletrie/internal/fsnoder/file_test.go +++ b/utils/merkletrie/internal/fsnoder/file_test.go @@ -3,65 +3,66 @@ package fsnoder import ( "testing" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } - -type FileSuite struct{} +type FileSuite struct { + suite.Suite +} -var _ = Suite(&FileSuite{}) +func TestFileSuite(t *testing.T) { + suite.Run(t, new(FileSuite)) +} var ( HashOfEmptyFile = []byte{0xcb, 0xf2, 0x9c, 0xe4, 0x84, 0x22, 0x23, 0x25} // fnv64 basis offset HashOfContents = []byte{0xee, 0x7e, 0xf3, 0xd0, 0xc2, 0xb5, 0xef, 0x83} // hash of "contents" ) -func (s *FileSuite) TestNewFileEmpty(c *C) { +func (s *FileSuite) TestNewFileEmpty() { f, err := newFile("name", "") - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(f.Hash(), DeepEquals, HashOfEmptyFile) - c.Assert(f.Name(), Equals, "name") - c.Assert(f.IsDir(), Equals, false) - assertChildren(c, f, noder.NoChildren) - c.Assert(f.String(), Equals, "name<>") + s.Equal(HashOfEmptyFile, f.Hash()) + s.Equal("name", f.Name()) + s.False(f.IsDir()) + assertChildren(s.T(), f, noder.NoChildren) + s.Equal("name<>", f.String()) } -func (s *FileSuite) TestNewFileWithContents(c *C) { +func (s *FileSuite) TestNewFileWithContents() { f, err := newFile("name", "contents") - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(f.Hash(), DeepEquals, HashOfContents) - c.Assert(f.Name(), Equals, "name") - c.Assert(f.IsDir(), Equals, false) - assertChildren(c, f, noder.NoChildren) - c.Assert(f.String(), Equals, "name") + s.Equal(HashOfContents, f.Hash()) + s.Equal("name", f.Name()) + s.False(f.IsDir()) + assertChildren(s.T(), f, noder.NoChildren) + s.Equal("name", f.String()) } -func (s *FileSuite) TestNewfileErrorEmptyName(c *C) { +func (s *FileSuite) TestNewfileErrorEmptyName() { _, err := newFile("", "contents") - c.Assert(err, Not(IsNil)) + s.Error(err) } -func (s *FileSuite) TestDifferentContentsHaveDifferentHash(c *C) { +func (s *FileSuite) TestDifferentContentsHaveDifferentHash() { f1, err := newFile("name", "contents") - c.Assert(err, IsNil) + s.NoError(err) f2, err := newFile("name", "foo") - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(f1.Hash(), Not(DeepEquals), f2.Hash()) + s.NotEqual(f2.Hash(), f1.Hash()) } -func (s *FileSuite) TestSameContentsHaveSameHash(c *C) { +func (s *FileSuite) TestSameContentsHaveSameHash() { f1, err := newFile("name1", "contents") - c.Assert(err, IsNil) + s.NoError(err) f2, err := newFile("name2", "contents") - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(f1.Hash(), DeepEquals, f2.Hash()) + s.Equal(f2.Hash(), f1.Hash()) } diff --git a/utils/merkletrie/internal/fsnoder/new.go b/utils/merkletrie/internal/fsnoder/new.go index b5389c7e7..2d604a053 100644 --- a/utils/merkletrie/internal/fsnoder/new.go +++ b/utils/merkletrie/internal/fsnoder/new.go @@ -5,7 +5,7 @@ import ( "fmt" "io" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" ) // New function creates a full merkle trie from the string description of diff --git a/utils/merkletrie/internal/fsnoder/new_test.go b/utils/merkletrie/internal/fsnoder/new_test.go index ad069c7fc..8ba7b0554 100644 --- a/utils/merkletrie/internal/fsnoder/new_test.go +++ b/utils/merkletrie/internal/fsnoder/new_test.go @@ -1,288 +1,294 @@ package fsnoder import ( - "github.com/go-git/go-git/v5/utils/merkletrie/noder" + "fmt" + "testing" - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" + "github.com/stretchr/testify/suite" ) -type FSNoderSuite struct{} +type FSNoderSuite struct { + suite.Suite +} -var _ = Suite(&FSNoderSuite{}) +func TestFSNoderSuite(t *testing.T) { + suite.Run(t, new(FSNoderSuite)) +} -func check(c *C, input string, expected *dir) { +func check(s *FSNoderSuite, input string, expected *dir) { obtained, err := New(input) - c.Assert(err, IsNil, Commentf("input = %s", input)) + s.NoError(err, fmt.Sprintf("input = %s", input)) - comment := Commentf("\n input = %s\n"+ + comment := fmt.Sprintf("\n input = %s\n"+ "expected = %s\nobtained = %s", input, expected, obtained) - c.Assert(obtained.Hash(), DeepEquals, expected.Hash(), comment) + s.Equal(expected.Hash(), obtained.Hash(), comment) } -func (s *FSNoderSuite) TestNoDataFails(c *C) { +func (s *FSNoderSuite) TestNoDataFails() { _, err := New("") - c.Assert(err, Not(IsNil)) + s.Error(err) _, err = New(" ") // SPC + TAB - c.Assert(err, Not(IsNil)) + s.Error(err) } -func (s *FSNoderSuite) TestUnnamedRootFailsIfNotRoot(c *C) { +func (s *FSNoderSuite) TestUnnamedRootFailsIfNotRoot() { _, err := decodeDir([]byte("()"), false) - c.Assert(err, Not(IsNil)) + s.Error(err) } -func (s *FSNoderSuite) TestUnnamedInnerFails(c *C) { +func (s *FSNoderSuite) TestUnnamedInnerFails() { _, err := New("(())") - c.Assert(err, Not(IsNil)) + s.Error(err) _, err = New("((a<>))") - c.Assert(err, Not(IsNil)) + s.Error(err) } -func (s *FSNoderSuite) TestMalformedFile(c *C) { +func (s *FSNoderSuite) TestMalformedFile() { _, err := New("(4<>)") - c.Assert(err, Not(IsNil)) + s.Error(err) _, err = New("(4<1>)") - c.Assert(err, Not(IsNil)) + s.Error(err) _, err = New("(4?1>)") - c.Assert(err, Not(IsNil)) + s.Error(err) _, err = New("(4)") - c.Assert(err, Not(IsNil)) + s.Error(err) _, err = New("(4")) - c.Assert(err, Not(IsNil)) + s.Error(err) _, err = decodeFile([]byte("a")) - c.Assert(err, Not(IsNil)) + s.Error(err) _, err = decodeFile([]byte("a<1?")) - c.Assert(err, Not(IsNil)) + s.Error(err) _, err = decodeFile([]byte("a?>")) - c.Assert(err, Not(IsNil)) + s.Error(err) _, err = decodeFile([]byte("1<>")) - c.Assert(err, Not(IsNil)) + s.Error(err) _, err = decodeFile([]byte("a") - c.Assert(err, Not(IsNil)) + s.Error(err) _, err = New("a<>") - c.Assert(err, Not(IsNil)) + s.Error(err) } -func (s *FSNoderSuite) TestUnnamedEmptyRoot(c *C) { +func (s *FSNoderSuite) TestUnnamedEmptyRoot() { input := "()" expected, err := newDir("", nil) - c.Assert(err, IsNil) + s.NoError(err) - check(c, input, expected) + check(s, input, expected) } -func (s *FSNoderSuite) TestNamedEmptyRoot(c *C) { +func (s *FSNoderSuite) TestNamedEmptyRoot() { input := "a()" expected, err := newDir("a", nil) - c.Assert(err, IsNil) + s.NoError(err) - check(c, input, expected) + check(s, input, expected) } -func (s *FSNoderSuite) TestEmptyFile(c *C) { +func (s *FSNoderSuite) TestEmptyFile() { input := "(a<>)" a1, err := newFile("a", "") - c.Assert(err, IsNil) + s.NoError(err) expected, err := newDir("", []noder.Noder{a1}) - c.Assert(err, IsNil) + s.NoError(err) - check(c, input, expected) + check(s, input, expected) } -func (s *FSNoderSuite) TestNonEmptyFile(c *C) { +func (s *FSNoderSuite) TestNonEmptyFile() { input := "(a<1>)" a1, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) expected, err := newDir("", []noder.Noder{a1}) - c.Assert(err, IsNil) + s.NoError(err) - check(c, input, expected) + check(s, input, expected) } -func (s *FSNoderSuite) TestTwoFilesSameContents(c *C) { +func (s *FSNoderSuite) TestTwoFilesSameContents() { input := "(b<1> a<1>)" a1, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) b1, err := newFile("b", "1") - c.Assert(err, IsNil) + s.NoError(err) expected, err := newDir("", []noder.Noder{a1, b1}) - c.Assert(err, IsNil) + s.NoError(err) - check(c, input, expected) + check(s, input, expected) } -func (s *FSNoderSuite) TestTwoFilesDifferentContents(c *C) { +func (s *FSNoderSuite) TestTwoFilesDifferentContents() { input := "(b<2> a<1>)" a1, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) b2, err := newFile("b", "2") - c.Assert(err, IsNil) + s.NoError(err) expected, err := newDir("", []noder.Noder{a1, b2}) - c.Assert(err, IsNil) + s.NoError(err) - check(c, input, expected) + check(s, input, expected) } -func (s *FSNoderSuite) TestManyFiles(c *C) { +func (s *FSNoderSuite) TestManyFiles() { input := "(e<1> b<2> a<1> c<1> d<3> f<4>)" a1, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) b2, err := newFile("b", "2") - c.Assert(err, IsNil) + s.NoError(err) c1, err := newFile("c", "1") - c.Assert(err, IsNil) + s.NoError(err) d3, err := newFile("d", "3") - c.Assert(err, IsNil) + s.NoError(err) e1, err := newFile("e", "1") - c.Assert(err, IsNil) + s.NoError(err) f4, err := newFile("f", "4") - c.Assert(err, IsNil) + s.NoError(err) expected, err := newDir("", []noder.Noder{e1, b2, a1, c1, d3, f4}) - c.Assert(err, IsNil) + s.NoError(err) - check(c, input, expected) + check(s, input, expected) } -func (s *FSNoderSuite) TestEmptyDir(c *C) { +func (s *FSNoderSuite) TestEmptyDir() { input := "(A())" A, err := newDir("A", nil) - c.Assert(err, IsNil) + s.NoError(err) expected, err := newDir("", []noder.Noder{A}) - c.Assert(err, IsNil) + s.NoError(err) - check(c, input, expected) + check(s, input, expected) } -func (s *FSNoderSuite) TestDirWithEmptyFile(c *C) { +func (s *FSNoderSuite) TestDirWithEmptyFile() { input := "(A(a<>))" a, err := newFile("a", "") - c.Assert(err, IsNil) + s.NoError(err) A, err := newDir("A", []noder.Noder{a}) - c.Assert(err, IsNil) + s.NoError(err) expected, err := newDir("", []noder.Noder{A}) - c.Assert(err, IsNil) + s.NoError(err) - check(c, input, expected) + check(s, input, expected) } -func (s *FSNoderSuite) TestDirWithEmptyFileSameName(c *C) { +func (s *FSNoderSuite) TestDirWithEmptyFileSameName() { input := "(A(A<>))" f, err := newFile("A", "") - c.Assert(err, IsNil) + s.NoError(err) A, err := newDir("A", []noder.Noder{f}) - c.Assert(err, IsNil) + s.NoError(err) expected, err := newDir("", []noder.Noder{A}) - c.Assert(err, IsNil) + s.NoError(err) - check(c, input, expected) + check(s, input, expected) } -func (s *FSNoderSuite) TestDirWithFileLongContents(c *C) { +func (s *FSNoderSuite) TestDirWithFileLongContents() { input := "(A(a<12>))" a1, err := newFile("a", "12") - c.Assert(err, IsNil) + s.NoError(err) A, err := newDir("A", []noder.Noder{a1}) - c.Assert(err, IsNil) + s.NoError(err) expected, err := newDir("", []noder.Noder{A}) - c.Assert(err, IsNil) + s.NoError(err) - check(c, input, expected) + check(s, input, expected) } -func (s *FSNoderSuite) TestDirWithFileLongName(c *C) { +func (s *FSNoderSuite) TestDirWithFileLongName() { input := "(A(abc<12>))" a1, err := newFile("abc", "12") - c.Assert(err, IsNil) + s.NoError(err) A, err := newDir("A", []noder.Noder{a1}) - c.Assert(err, IsNil) + s.NoError(err) expected, err := newDir("", []noder.Noder{A}) - c.Assert(err, IsNil) + s.NoError(err) - check(c, input, expected) + check(s, input, expected) } -func (s *FSNoderSuite) TestDirWithFile(c *C) { +func (s *FSNoderSuite) TestDirWithFile() { input := "(A(a<1>))" a1, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) A, err := newDir("A", []noder.Noder{a1}) - c.Assert(err, IsNil) + s.NoError(err) expected, err := newDir("", []noder.Noder{A}) - c.Assert(err, IsNil) + s.NoError(err) - check(c, input, expected) + check(s, input, expected) } -func (s *FSNoderSuite) TestDirWithEmptyDirSameName(c *C) { +func (s *FSNoderSuite) TestDirWithEmptyDirSameName() { input := "(A(A()))" A2, err := newDir("A", nil) - c.Assert(err, IsNil) + s.NoError(err) A1, err := newDir("A", []noder.Noder{A2}) - c.Assert(err, IsNil) + s.NoError(err) expected, err := newDir("", []noder.Noder{A1}) - c.Assert(err, IsNil) + s.NoError(err) - check(c, input, expected) + check(s, input, expected) } -func (s *FSNoderSuite) TestDirWithEmptyDir(c *C) { +func (s *FSNoderSuite) TestDirWithEmptyDir() { input := "(A(B()))" B, err := newDir("B", nil) - c.Assert(err, IsNil) + s.NoError(err) A, err := newDir("A", []noder.Noder{B}) - c.Assert(err, IsNil) + s.NoError(err) expected, err := newDir("", []noder.Noder{A}) - c.Assert(err, IsNil) + s.NoError(err) - check(c, input, expected) + check(s, input, expected) } -func (s *FSNoderSuite) TestDirWithTwoFiles(c *C) { +func (s *FSNoderSuite) TestDirWithTwoFiles() { input := "(A(a<1> b<2>))" a1, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) b2, err := newFile("b", "2") - c.Assert(err, IsNil) + s.NoError(err) A, err := newDir("A", []noder.Noder{b2, a1}) - c.Assert(err, IsNil) + s.NoError(err) expected, err := newDir("", []noder.Noder{A}) - c.Assert(err, IsNil) + s.NoError(err) - check(c, input, expected) + check(s, input, expected) } -func (s *FSNoderSuite) TestCrazy(c *C) { +func (s *FSNoderSuite) TestCrazy() { // "" // | // ------------------------- @@ -297,58 +303,58 @@ func (s *FSNoderSuite) TestCrazy(c *C) { input := "(d<2> b(c<1> b() a() x(a<1>)) a<1> c<1> e(e(e(e<1>))))" e1, err := newFile("e", "1") - c.Assert(err, IsNil) + s.NoError(err) E, err := newDir("e", []noder.Noder{e1}) - c.Assert(err, IsNil) + s.NoError(err) E, err = newDir("e", []noder.Noder{E}) - c.Assert(err, IsNil) + s.NoError(err) E, err = newDir("e", []noder.Noder{E}) - c.Assert(err, IsNil) + s.NoError(err) A, err := newDir("a", nil) - c.Assert(err, IsNil) + s.NoError(err) B, err := newDir("b", nil) - c.Assert(err, IsNil) + s.NoError(err) a1, err := newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) X, err := newDir("x", []noder.Noder{a1}) - c.Assert(err, IsNil) + s.NoError(err) c1, err := newFile("c", "1") - c.Assert(err, IsNil) + s.NoError(err) B, err = newDir("b", []noder.Noder{c1, B, X, A}) - c.Assert(err, IsNil) + s.NoError(err) a1, err = newFile("a", "1") - c.Assert(err, IsNil) + s.NoError(err) c1, err = newFile("c", "1") - c.Assert(err, IsNil) + s.NoError(err) d2, err := newFile("d", "2") - c.Assert(err, IsNil) + s.NoError(err) expected, err := newDir("", []noder.Noder{a1, d2, E, B, c1}) - c.Assert(err, IsNil) + s.NoError(err) - check(c, input, expected) + check(s, input, expected) } -func (s *FSNoderSuite) TestHashEqual(c *C) { +func (s *FSNoderSuite) TestHashEqual() { input1 := "(A(a<1> b<2>))" input2 := "(A(a<1> b<2>))" input3 := "(A(a<> b<2>))" t1, err := New(input1) - c.Assert(err, IsNil) + s.NoError(err) t2, err := New(input2) - c.Assert(err, IsNil) + s.NoError(err) t3, err := New(input3) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(HashEqual(t1, t2), Equals, true) - c.Assert(HashEqual(t2, t1), Equals, true) + s.True(HashEqual(t1, t2)) + s.True(HashEqual(t2, t1)) - c.Assert(HashEqual(t2, t3), Equals, false) - c.Assert(HashEqual(t3, t2), Equals, false) + s.False(HashEqual(t2, t3)) + s.False(HashEqual(t3, t2)) - c.Assert(HashEqual(t3, t1), Equals, false) - c.Assert(HashEqual(t1, t3), Equals, false) + s.False(HashEqual(t3, t1)) + s.False(HashEqual(t1, t3)) } diff --git a/utils/merkletrie/iter.go b/utils/merkletrie/iter.go index d75afec46..d8a4fbf39 100644 --- a/utils/merkletrie/iter.go +++ b/utils/merkletrie/iter.go @@ -4,8 +4,8 @@ import ( "fmt" "io" - "github.com/go-git/go-git/v5/utils/merkletrie/internal/frame" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/internal/frame" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" ) // Iter is an iterator for merkletries (only the trie part of the diff --git a/utils/merkletrie/iter_test.go b/utils/merkletrie/iter_test.go index ad6639ba5..8ac59350b 100644 --- a/utils/merkletrie/iter_test.go +++ b/utils/merkletrie/iter_test.go @@ -4,17 +4,22 @@ import ( "fmt" "io" "strings" + "testing" - "github.com/go-git/go-git/v5/utils/merkletrie" - "github.com/go-git/go-git/v5/utils/merkletrie/internal/fsnoder" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" - - . "gopkg.in/check.v1" + "github.com/jesseduffield/go-git/v5/utils/merkletrie" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/internal/fsnoder" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" ) -type IterSuite struct{} +type IterSuite struct { + suite.Suite +} -var _ = Suite(&IterSuite{}) +func TestIterSuite(t *testing.T) { + suite.Run(t, new(IterSuite)) +} // A test is a list of operations we want to perform on an iterator and // their expected results. @@ -30,10 +35,10 @@ var _ = Suite(&IterSuite{}) // // For instance: // -// t := test{ -// operations: "ns", -// expected: "a a/b" -// } +// t := test{ +// operations: "ns", +// expected: "a a/b" +// } // // means: // @@ -50,7 +55,7 @@ type test struct { // Runs a test on the provided iterator, checking that the names of the // returned values are correct. If not, the treeDescription value is // printed along with information about mismatch. -func (t test) run(c *C, iter *merkletrie.Iter, +func (t test) run(s *IterSuite, iter *merkletrie.Iter, treeDescription string, testNumber int) { expectedChunks := strings.Split(t.expected, " ") @@ -59,38 +64,38 @@ func (t test) run(c *C, iter *merkletrie.Iter, } if len(t.operations) < len(expectedChunks) { - c.Fatalf("malformed test %d: not enough operations", testNumber) + s.T().Logf("malformed test %d: not enough operations", testNumber) return } var obtained noder.Path var err error for i, b := range t.operations { - comment := Commentf("\ntree: %q\ntest #%d (%q)\noperation #%d (%q)", + comment := fmt.Sprintf("\ntree: %q\ntest #%d (%q)\noperation #%d (%q)", treeDescription, testNumber, t.operations, i, t.operations[i]) switch t.operations[i] { case 'n': obtained, err = iter.Next() if err != io.EOF { - c.Assert(err, IsNil) + s.NoError(err) } case 's': obtained, err = iter.Step() if err != io.EOF { - c.Assert(err, IsNil) + s.NoError(err) } default: - c.Fatalf("unknown operation at test %d, operation %d (%c)\n", + s.T().Errorf("unknown operation at test %d, operation %d (%c)\n", testNumber, i, b) } if i >= len(expectedChunks) { - c.Assert(err, Equals, io.EOF, comment) + s.Equal(io.EOF, err, comment) continue } - c.Assert(err, IsNil, comment) - c.Assert(obtained.String(), Equals, expectedChunks[i], comment) + s.NoError(err, comment) + s.Equal(expectedChunks[i], obtained.String(), comment) } } @@ -99,21 +104,21 @@ func (t test) run(c *C, iter *merkletrie.Iter, // // Example: // -// . -// | -// --------- -// | | | -// a b c -// | -// z +// . +// | +// --------- +// | | | +// a b c +// | +// z // -// var foo testCollection = { -// tree: "(a<> b(z<>) c<>)" -// tests: []test{ -// {operations: "nns", expected: "a b b/z"}, -// {operations: "nnn", expected: "a b c"}, -// }, -// } +// var foo testCollection = { +// tree: "(a<> b(z<>) c<>)" +// tests: []test{ +// {operations: "nns", expected: "a b b/z"}, +// {operations: "nnn", expected: "a b c"}, +// }, +// } // // A new iterator will be build for each test. type testsCollection struct { @@ -122,18 +127,18 @@ type testsCollection struct { } // Executes all the tests in a testsCollection. -func (tc testsCollection) run(c *C) { +func (tc testsCollection) run(s *IterSuite) { root, err := fsnoder.New(tc.tree) - c.Assert(err, IsNil) + s.NoError(err) for i, t := range tc.tests { iter, err := merkletrie.NewIter(root) - c.Assert(err, IsNil) - t.run(c, iter, root.String(), i) + s.NoError(err) + t.run(s, iter, root.String(), i) } } -func (s *IterSuite) TestEmptyNamedDir(c *C) { +func (s *IterSuite) TestEmptyNamedDir() { tc := testsCollection{ tree: "A()", tests: []test{ @@ -149,10 +154,10 @@ func (s *IterSuite) TestEmptyNamedDir(c *C) { {operations: "sssnnsnssn", expected: ""}, }, } - tc.run(c) + tc.run(s) } -func (s *IterSuite) TestEmptyUnnamedDir(c *C) { +func (s *IterSuite) TestEmptyUnnamedDir() { tc := testsCollection{ tree: "()", tests: []test{ @@ -168,10 +173,10 @@ func (s *IterSuite) TestEmptyUnnamedDir(c *C) { {operations: "sssnnsnssn", expected: ""}, }, } - tc.run(c) + tc.run(s) } -func (s *IterSuite) TestOneFile(c *C) { +func (s *IterSuite) TestOneFile() { tc := testsCollection{ tree: "(a<>)", tests: []test{ @@ -187,13 +192,15 @@ func (s *IterSuite) TestOneFile(c *C) { {operations: "sssnnsnssn", expected: "a"}, }, } - tc.run(c) + tc.run(s) } -// root -// / \ -// a b -func (s *IterSuite) TestTwoFiles(c *C) { +// root +// +// / \ +// +// a b +func (s *IterSuite) TestTwoFiles() { tc := testsCollection{ tree: "(a<> b<>)", tests: []test{ @@ -207,15 +214,16 @@ func (s *IterSuite) TestTwoFiles(c *C) { {operations: "sss", expected: "a b"}, }, } - tc.run(c) + tc.run(s) } -// root -// | -// a -// | -// b -func (s *IterSuite) TestDirWithFile(c *C) { +// root +// +// | +// a +// | +// b +func (s *IterSuite) TestDirWithFile() { tc := testsCollection{ tree: "(a(b<>))", tests: []test{ @@ -229,13 +237,15 @@ func (s *IterSuite) TestDirWithFile(c *C) { {operations: "sss", expected: "a a/b"}, }, } - tc.run(c) + tc.run(s) } -// root -// /|\ -// c a b -func (s *IterSuite) TestThreeSiblings(c *C) { +// root +// +// /|\ +// +// c a b +func (s *IterSuite) TestThreeSiblings() { tc := testsCollection{ tree: "(c<> a<> b<>)", tests: []test{ @@ -257,17 +267,18 @@ func (s *IterSuite) TestThreeSiblings(c *C) { {operations: "ssss", expected: "a b c"}, }, } - tc.run(c) + tc.run(s) } -// root -// | -// b -// | -// c -// | -// a -func (s *IterSuite) TestThreeVertical(c *C) { +// root +// +// | +// b +// | +// c +// | +// a +func (s *IterSuite) TestThreeVertical() { tc := testsCollection{ tree: "(b(c(a())))", tests: []test{ @@ -289,15 +300,17 @@ func (s *IterSuite) TestThreeVertical(c *C) { {operations: "ssss", expected: "b b/c b/c/a"}, }, } - tc.run(c) + tc.run(s) } -// root -// / \ -// c a -// | -// b -func (s *IterSuite) TestThreeMix1(c *C) { +// root +// +// / \ +// +// c a +// | +// b +func (s *IterSuite) TestThreeMix1() { tc := testsCollection{ tree: "(c(b<>) a<>)", tests: []test{ @@ -319,15 +332,18 @@ func (s *IterSuite) TestThreeMix1(c *C) { {operations: "ssss", expected: "a c c/b"}, }, } - tc.run(c) + tc.run(s) } -// root -// / \ -// b a -// | -// c -func (s *IterSuite) TestThreeMix2(c *C) { +// root +// +// / \ +// +// b a +// +// | +// c +func (s *IterSuite) TestThreeMix2() { tc := testsCollection{ tree: "(b() a(c<>))", tests: []test{ @@ -349,22 +365,24 @@ func (s *IterSuite) TestThreeMix2(c *C) { {operations: "ssss", expected: "a a/c b"}, }, } - tc.run(c) + tc.run(s) } -// root -// / | \ -// / | ---- -// f d h -------- -// /\ / \ | -// e a j b/ g -// | / \ | -// l n k icm -// | -// o -// | -// p/ -func (s *IterSuite) TestCrazy(c *C) { +// root +// / | \ +// / | ---- +// f d h -------- +// /\ / \ | +// +// e a j b/ g +// | / \ | +// l n k icm +// +// | +// o +// | +// p/ +func (s *IterSuite) TestCrazy() { tc := testsCollection{ tree: "(f(e(l<>) a(n(o(p())) k<>)) d<> h(j(i<> c<> m<>) b() g<>))", tests: []test{ @@ -383,55 +401,57 @@ func (s *IterSuite) TestCrazy(c *C) { {operations: "nssnn", expected: "d f f/a f/e h"}, }, } - tc.run(c) + tc.run(s) } -// . -// | -// a -// | -// b -// / \ -// z h -// / \ -// d e -// | -// f -func (s *IterSuite) TestNewIterFromPath(c *C) { +// . +// | +// a +// | +// b +// / \ +// z h +// / \ +// +// d e +// +// | +// f +func (s *IterSuite) TestNewIterFromPath() { tree, err := fsnoder.New("(a(b(z(d<> e(f<>)) h<>)))") - c.Assert(err, IsNil) + s.NoError(err) - z := find(c, tree, "z") + z := find(s.T(), tree, "z") iter, err := merkletrie.NewIterFromPath(z) - c.Assert(err, IsNil) + s.NoError(err) n, err := iter.Next() - c.Assert(err, IsNil) - c.Assert(n.String(), Equals, "a/b/z/d") + s.NoError(err) + s.Equal("a/b/z/d", n.String()) n, err = iter.Next() - c.Assert(err, IsNil) - c.Assert(n.String(), Equals, "a/b/z/e") + s.NoError(err) + s.Equal("a/b/z/e", n.String()) n, err = iter.Step() - c.Assert(err, IsNil) - c.Assert(n.String(), Equals, "a/b/z/e/f") + s.NoError(err) + s.Equal("a/b/z/e/f", n.String()) _, err = iter.Step() - c.Assert(err, Equals, io.EOF) + s.ErrorIs(err, io.EOF) } -func find(c *C, tree noder.Noder, name string) noder.Path { +func find(t *testing.T, tree noder.Noder, name string) noder.Path { iter, err := merkletrie.NewIter(tree) - c.Assert(err, IsNil) + assert.NoError(t, err) for { current, err := iter.Step() if err != io.EOF { - c.Assert(err, IsNil) + assert.NoError(t, err) } else { - c.Fatalf("node %s not found in tree %s", name, tree) + t.Fatalf("node %s not found in tree %s", name, tree) } if current.Name() == name { @@ -446,14 +466,14 @@ func (e *errorNoder) Children() ([]noder.Noder, error) { return nil, fmt.Errorf("mock error") } -func (s *IterSuite) TestNewIterNil(c *C) { +func (s *IterSuite) TestNewIterNil() { i, err := merkletrie.NewIter(nil) - c.Assert(err, IsNil) + s.NoError(err) _, err = i.Next() - c.Assert(err, Equals, io.EOF) + s.ErrorIs(err, io.EOF) } -func (s *IterSuite) TestNewIterFailsOnChildrenErrors(c *C) { +func (s *IterSuite) TestNewIterFailsOnChildrenErrors() { _, err := merkletrie.NewIter(&errorNoder{}) - c.Assert(err, ErrorMatches, "mock error") + s.ErrorContains(err, "mock error") } diff --git a/utils/merkletrie/noder/noder_test.go b/utils/merkletrie/noder/noder_test.go index c1af99843..d48405dd9 100644 --- a/utils/merkletrie/noder/noder_test.go +++ b/utils/merkletrie/noder/noder_test.go @@ -3,14 +3,16 @@ package noder import ( "testing" - . "gopkg.in/check.v1" + "github.com/stretchr/testify/suite" ) -func Test(t *testing.T) { TestingT(t) } - -type NoderSuite struct{} +type NoderSuite struct { + suite.Suite +} -var _ = Suite(&NoderSuite{}) +func TestNoderSuite(t *testing.T) { + suite.Run(t, new(NoderSuite)) +} type noderMock struct { name string @@ -30,12 +32,13 @@ func (n noderMock) Skip() bool { return false } // Returns a sequence with the noders 3, 2, and 1 from the // following diagram: // -// 3 -// | -// 2 -// | -// 1 -// / \ +// 3 +// | +// 2 +// | +// 1 +// / \ +// // c1 c2 // // This is also the path of "1". @@ -63,25 +66,25 @@ func pathFixture() Path { return Path(nodersFixture()) } -func (s *NoderSuite) TestString(c *C) { - c.Assert(pathFixture().String(), Equals, "3/2/1") +func (s *NoderSuite) TestString() { + s.Equal("3/2/1", pathFixture().String()) } -func (s *NoderSuite) TestLast(c *C) { - c.Assert(pathFixture().Last().Name(), Equals, "1") +func (s *NoderSuite) TestLast() { + s.Equal("1", pathFixture().Last().Name()) } -func (s *NoderSuite) TestPathImplementsNoder(c *C) { +func (s *NoderSuite) TestPathImplementsNoder() { p := pathFixture() - c.Assert(p.Name(), Equals, "1") - c.Assert(p.Hash(), DeepEquals, []byte{0x00, 0x01, 0x02}) - c.Assert(p.IsDir(), Equals, true) + s.Equal("1", p.Name()) + s.Equal([]byte{0x00, 0x01, 0x02}, p.Hash()) + s.True(p.IsDir()) children, err := p.Children() - c.Assert(err, IsNil) - c.Assert(children, DeepEquals, childrenFixture()) + s.NoError(err) + s.Equal(childrenFixture(), children) numChildren, err := p.NumChildren() - c.Assert(err, IsNil) - c.Assert(numChildren, Equals, 2) + s.NoError(err) + s.Equal(2, numChildren) } diff --git a/utils/merkletrie/noder/path_test.go b/utils/merkletrie/noder/path_test.go index f65b1d503..8c9e72d2c 100644 --- a/utils/merkletrie/noder/path_test.go +++ b/utils/merkletrie/noder/path_test.go @@ -1,34 +1,40 @@ package noder import ( + "testing" + + "github.com/stretchr/testify/suite" "golang.org/x/text/unicode/norm" - . "gopkg.in/check.v1" ) -type PathSuite struct{} +type PathSuite struct { + suite.Suite +} -var _ = Suite(&PathSuite{}) +func TestPathSuite(t *testing.T) { + suite.Run(t, new(PathSuite)) +} -func (s *PathSuite) TestShortFile(c *C) { +func (s *PathSuite) TestShortFile() { f := &noderMock{ name: "1", isDir: false, } p := Path([]Noder{f}) - c.Assert(p.String(), Equals, "1") + s.Equal("1", p.String()) } -func (s *PathSuite) TestShortDir(c *C) { +func (s *PathSuite) TestShortDir() { d := &noderMock{ name: "1", isDir: true, children: NoChildren, } p := Path([]Noder{d}) - c.Assert(p.String(), Equals, "1") + s.Equal("1", p.String()) } -func (s *PathSuite) TestLongFile(c *C) { +func (s *PathSuite) TestLongFile() { n3 := &noderMock{ name: "3", isDir: false, @@ -44,10 +50,10 @@ func (s *PathSuite) TestLongFile(c *C) { children: []Noder{n2}, } p := Path([]Noder{n1, n2, n3}) - c.Assert(p.String(), Equals, "1/2/3") + s.Equal("1/2/3", p.String()) } -func (s *PathSuite) TestLongDir(c *C) { +func (s *PathSuite) TestLongDir() { n3 := &noderMock{ name: "3", isDir: true, @@ -64,27 +70,27 @@ func (s *PathSuite) TestLongDir(c *C) { children: []Noder{n2}, } p := Path([]Noder{n1, n2, n3}) - c.Assert(p.String(), Equals, "1/2/3") + s.Equal("1/2/3", p.String()) } -func (s *PathSuite) TestCompareDepth1(c *C) { +func (s *PathSuite) TestCompareDepth1() { p1 := Path([]Noder{&noderMock{name: "a"}}) p2 := Path([]Noder{&noderMock{name: "b"}}) - c.Assert(p1.Compare(p2), Equals, -1) - c.Assert(p2.Compare(p1), Equals, 1) + s.Equal(-1, p1.Compare(p2)) + s.Equal(1, p2.Compare(p1)) p1 = Path([]Noder{&noderMock{name: "a"}}) p2 = Path([]Noder{&noderMock{name: "a"}}) - c.Assert(p1.Compare(p2), Equals, 0) - c.Assert(p2.Compare(p1), Equals, 0) + s.Equal(0, p1.Compare(p2)) + s.Equal(0, p2.Compare(p1)) p1 = Path([]Noder{&noderMock{name: "a.go"}}) p2 = Path([]Noder{&noderMock{name: "a"}}) - c.Assert(p1.Compare(p2), Equals, 1) - c.Assert(p2.Compare(p1), Equals, -1) + s.Equal(1, p1.Compare(p2)) + s.Equal(-1, p2.Compare(p1)) } -func (s *PathSuite) TestCompareDepth2(c *C) { +func (s *PathSuite) TestCompareDepth2() { p1 := Path([]Noder{ &noderMock{name: "a"}, &noderMock{name: "b"}, @@ -93,8 +99,8 @@ func (s *PathSuite) TestCompareDepth2(c *C) { &noderMock{name: "b"}, &noderMock{name: "a"}, }) - c.Assert(p1.Compare(p2), Equals, -1) - c.Assert(p2.Compare(p1), Equals, 1) + s.Equal(-1, p1.Compare(p2)) + s.Equal(1, p2.Compare(p1)) p1 = Path([]Noder{ &noderMock{name: "a"}, @@ -104,8 +110,8 @@ func (s *PathSuite) TestCompareDepth2(c *C) { &noderMock{name: "a"}, &noderMock{name: "b"}, }) - c.Assert(p1.Compare(p2), Equals, 0) - c.Assert(p2.Compare(p1), Equals, 0) + s.Equal(0, p1.Compare(p2)) + s.Equal(0, p2.Compare(p1)) p1 = Path([]Noder{ &noderMock{name: "a"}, @@ -115,51 +121,51 @@ func (s *PathSuite) TestCompareDepth2(c *C) { &noderMock{name: "a"}, &noderMock{name: "a"}, }) - c.Assert(p1.Compare(p2), Equals, 1) - c.Assert(p2.Compare(p1), Equals, -1) + s.Equal(1, p1.Compare(p2)) + s.Equal(-1, p2.Compare(p1)) } -func (s *PathSuite) TestCompareMixedDepths(c *C) { +func (s *PathSuite) TestCompareMixedDepths() { p1 := Path([]Noder{ &noderMock{name: "a"}, &noderMock{name: "b"}, }) p2 := Path([]Noder{&noderMock{name: "b"}}) - c.Assert(p1.Compare(p2), Equals, -1) - c.Assert(p2.Compare(p1), Equals, 1) + s.Equal(-1, p1.Compare(p2)) + s.Equal(1, p2.Compare(p1)) p1 = Path([]Noder{ &noderMock{name: "b"}, &noderMock{name: "b"}, }) p2 = Path([]Noder{&noderMock{name: "b"}}) - c.Assert(p1.Compare(p2), Equals, 1) - c.Assert(p2.Compare(p1), Equals, -1) + s.Equal(1, p1.Compare(p2)) + s.Equal(-1, p2.Compare(p1)) p1 = Path([]Noder{&noderMock{name: "a.go"}}) p2 = Path([]Noder{ &noderMock{name: "a"}, &noderMock{name: "a.go"}, }) - c.Assert(p1.Compare(p2), Equals, 1) - c.Assert(p2.Compare(p1), Equals, -1) + s.Equal(1, p1.Compare(p2)) + s.Equal(-1, p2.Compare(p1)) p1 = Path([]Noder{&noderMock{name: "b.go"}}) p2 = Path([]Noder{ &noderMock{name: "a"}, &noderMock{name: "a.go"}, }) - c.Assert(p1.Compare(p2), Equals, 1) - c.Assert(p2.Compare(p1), Equals, -1) + s.Equal(1, p1.Compare(p2)) + s.Equal(-1, p2.Compare(p1)) } -func (s *PathSuite) TestCompareNormalization(c *C) { +func (s *PathSuite) TestCompareNormalization() { p1 := Path([]Noder{&noderMock{name: norm.NFKC.String("페")}}) p2 := Path([]Noder{&noderMock{name: norm.NFKD.String("페")}}) - c.Assert(p1.Compare(p2), Equals, 1) - c.Assert(p2.Compare(p1), Equals, -1) + s.Equal(1, p1.Compare(p2)) + s.Equal(-1, p2.Compare(p1)) p1 = Path([]Noder{&noderMock{name: "TestAppWithUnicodéPath"}}) p2 = Path([]Noder{&noderMock{name: "TestAppWithUnicodéPath"}}) - c.Assert(p1.Compare(p2), Equals, -1) - c.Assert(p2.Compare(p1), Equals, 1) + s.Equal(-1, p1.Compare(p2)) + s.Equal(1, p2.Compare(p1)) } diff --git a/utils/sync/bufio.go b/utils/sync/bufio.go index 5009ea804..42f60f7ea 100644 --- a/utils/sync/bufio.go +++ b/utils/sync/bufio.go @@ -13,7 +13,7 @@ var bufioReader = sync.Pool{ } // GetBufioReader returns a *bufio.Reader that is managed by a sync.Pool. -// Returns a bufio.Reader that is resetted with reader and ready for use. +// Returns a bufio.Reader that is reset with reader and ready for use. // // After use, the *bufio.Reader should be put back into the sync.Pool // by calling PutBufioReader. diff --git a/utils/sync/bytes.go b/utils/sync/bytes.go index dd06fc0bc..c67b97837 100644 --- a/utils/sync/bytes.go +++ b/utils/sync/bytes.go @@ -35,7 +35,7 @@ func PutByteSlice(buf *[]byte) { } // GetBytesBuffer returns a *bytes.Buffer that is managed by a sync.Pool. -// Returns a buffer that is resetted and ready for use. +// Returns a buffer that is reset and ready for use. // // After use, the *bytes.Buffer should be put back into the sync.Pool // by calling PutBytesBuffer. diff --git a/utils/sync/zlib.go b/utils/sync/zlib.go index c61388595..28e1b8a57 100644 --- a/utils/sync/zlib.go +++ b/utils/sync/zlib.go @@ -11,10 +11,7 @@ var ( zlibInitBytes = []byte{0x78, 0x9c, 0x01, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01} zlibReader = sync.Pool{ New: func() interface{} { - r, _ := zlib.NewReader(bytes.NewReader(zlibInitBytes)) - return ZLibReader{ - Reader: r.(zlibReadCloser), - } + return NewZlibReader(nil) }, } zlibWriter = sync.Pool{ @@ -29,13 +26,29 @@ type zlibReadCloser interface { zlib.Resetter } +func NewZlibReader(dict *[]byte) ZLibReader { + r, _ := zlib.NewReader(bytes.NewReader(zlibInitBytes)) + return ZLibReader{ + Reader: r.(zlibReadCloser), + dict: dict, + } +} + type ZLibReader struct { dict *[]byte Reader zlibReadCloser } +func (z ZLibReader) Reset(r io.Reader) error { + var dict []byte + if z.dict != nil { + dict = *z.dict + } + return z.Reader.Reset(r, dict) +} + // GetZlibReader returns a ZLibReader that is managed by a sync.Pool. -// Returns a ZLibReader that is resetted using a dictionary that is +// Returns a ZLibReader that is reset using a dictionary that is // also managed by a sync.Pool. // // After use, the ZLibReader should be put back into the sync.Pool @@ -58,7 +71,7 @@ func PutZlibReader(z ZLibReader) { } // GetZlibWriter returns a *zlib.Writer that is managed by a sync.Pool. -// Returns a writer that is resetted with w and ready for use. +// Returns a writer that is reset with w and ready for use. // // After use, the *zlib.Writer should be put back into the sync.Pool // by calling PutZlibWriter. diff --git a/utils/trace/trace.go b/utils/trace/trace.go index 3e15c5b9f..201af0e4e 100644 --- a/utils/trace/trace.go +++ b/utils/trace/trace.go @@ -4,15 +4,35 @@ import ( "fmt" "log" "os" + "strings" "sync/atomic" ) +func init() { + var target Target + for k, v := range envToTarget { + if strings.EqualFold(os.Getenv(k), "true") { + target |= v + } + } + SetTarget(target) +} + var ( // logger is the logger to use for tracing. logger = newLogger() // current is the targets that are enabled for tracing. current atomic.Int32 + + // envToTarget maps what environment variables can be used + // to enable specific trace targets. + envToTarget = map[string]Target{ + "GIT_TRACE": General, + "GIT_TRACE_PACKET": Packet, + "GIT_TRACE_SSH": SSH, + "GIT_TRACE_PERFORMANCE": Performance, + } ) func newLogger() *log.Logger { @@ -28,6 +48,13 @@ const ( // Packet traces git packets. Packet + + // SSH traces SSH handshake operations. This does not have + // a direct translation to an upstream trace option. + SSH + + // Performance traces performance of go-git components. + Performance ) // SetTarget sets the tracing targets. @@ -42,14 +69,19 @@ func SetLogger(l *log.Logger) { // Print prints the given message only if the target is enabled. func (t Target) Print(args ...interface{}) { - if int32(t)¤t.Load() != 0 { + if t.Enabled() { logger.Output(2, fmt.Sprint(args...)) // nolint: errcheck } } // Printf prints the given message only if the target is enabled. func (t Target) Printf(format string, args ...interface{}) { - if int32(t)¤t.Load() != 0 { + if t.Enabled() { logger.Output(2, fmt.Sprintf(format, args...)) // nolint: errcheck } } + +// Enabled returns true if the target is enabled. +func (t Target) Enabled() bool { + return int32(t)¤t.Load() != 0 +} diff --git a/worktree.go b/worktree.go index ab11d42db..6ad3396cf 100644 --- a/worktree.go +++ b/worktree.go @@ -9,27 +9,30 @@ import ( "path/filepath" "runtime" "strings" + "time" "github.com/go-git/go-billy/v5" "github.com/go-git/go-billy/v5/util" - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/filemode" - "github.com/go-git/go-git/v5/plumbing/format/gitignore" - "github.com/go-git/go-git/v5/plumbing/format/index" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/utils/ioutil" - "github.com/go-git/go-git/v5/utils/merkletrie" - "github.com/go-git/go-git/v5/utils/sync" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/plumbing/format/gitignore" + "github.com/jesseduffield/go-git/v5/plumbing/format/index" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/utils/merkletrie" + "github.com/jesseduffield/go-git/v5/utils/sync" + "github.com/jesseduffield/go-git/v5/utils/trace" ) var ( - ErrWorktreeNotClean = errors.New("worktree is not clean") - ErrSubmoduleNotFound = errors.New("submodule not found") - ErrUnstagedChanges = errors.New("worktree contains unstaged changes") - ErrGitModulesSymlink = errors.New(gitmodulesFile + " is a symlink") - ErrNonFastForwardUpdate = errors.New("non-fast-forward update") + ErrWorktreeNotClean = errors.New("worktree is not clean") + ErrSubmoduleNotFound = errors.New("submodule not found") + ErrUnstagedChanges = errors.New("worktree contains unstaged changes") + ErrGitModulesSymlink = errors.New(gitmodulesFile + " is a symlink") + ErrNonFastForwardUpdate = errors.New("non-fast-forward update") + ErrRestoreWorktreeOnlyNotSupported = errors.New("worktree only is not supported") ) // Worktree represents a git worktree. @@ -139,7 +142,7 @@ func (w *Worktree) PullContext(ctx context.Context, o *PullOptions) error { } if o.RecurseSubmodules != NoRecurseSubmodules { - return w.updateSubmodules(&SubmoduleUpdateOptions{ + return w.updateSubmodules(ctx, &SubmoduleUpdateOptions{ RecurseSubmodules: o.RecurseSubmodules, Auth: o.Auth, }) @@ -148,13 +151,13 @@ func (w *Worktree) PullContext(ctx context.Context, o *PullOptions) error { return nil } -func (w *Worktree) updateSubmodules(o *SubmoduleUpdateOptions) error { +func (w *Worktree) updateSubmodules(ctx context.Context, o *SubmoduleUpdateOptions) error { s, err := w.Submodules() if err != nil { return err } o.Init = true - return s.Update(o) + return s.UpdateContext(ctx, o) } // Checkout switch branches or restore working tree files. @@ -307,13 +310,13 @@ func (w *Worktree) ResetSparsely(opts *ResetOptions, dirs []string) error { } if opts.Mode == MixedReset || opts.Mode == MergeReset || opts.Mode == HardReset { - if err := w.resetIndex(t, dirs); err != nil { + if err := w.resetIndex(t, dirs, opts.Files); err != nil { return err } } if opts.Mode == MergeReset || opts.Mode == HardReset { - if err := w.resetWorktree(t); err != nil { + if err := w.resetWorktree(t, opts.Files); err != nil { return err } } @@ -321,20 +324,57 @@ func (w *Worktree) ResetSparsely(opts *ResetOptions, dirs []string) error { return nil } +// Restore restores specified files in the working tree or stage with contents from +// a restore source. If a path is tracked but does not exist in the restore, +// source, it will be removed to match the source. +// +// If Staged and Worktree are true, then the restore source will be the index. +// If only Staged is true, then the restore source will be HEAD. +// If only Worktree is true or neither Staged nor Worktree are true, will +// result in ErrRestoreWorktreeOnlyNotSupported because restoring the working +// tree while leaving the stage untouched is not currently supported. +// +// Restore with no files specified will return ErrNoRestorePaths. +func (w *Worktree) Restore(o *RestoreOptions) error { + if err := o.Validate(); err != nil { + return err + } + + if o.Staged { + opts := &ResetOptions{ + Files: o.Files, + } + + if o.Worktree { + // If we are doing both Worktree and Staging then it is a hard reset + opts.Mode = HardReset + } else { + // If we are doing just staging then it is a mixed reset + opts.Mode = MixedReset + } + + return w.Reset(opts) + } + + return ErrRestoreWorktreeOnlyNotSupported +} + // Reset the worktree to a specified state. func (w *Worktree) Reset(opts *ResetOptions) error { + start := time.Now() + defer func() { + trace.Performance.Printf("performance: %.9f s: reset_worktree", time.Since(start).Seconds()) + }() + return w.ResetSparsely(opts, nil) } -func (w *Worktree) resetIndex(t *object.Tree, dirs []string) error { +func (w *Worktree) resetIndex(t *object.Tree, dirs []string, files []string) error { idx, err := w.r.Storer.Index() - if len(dirs) > 0 { - idx.SkipUnless(dirs) - } - if err != nil { return err } + b := newIndexBuilder(idx) changes, err := w.diffTreeWithStaging(t, true) @@ -362,6 +402,13 @@ func (w *Worktree) resetIndex(t *object.Tree, dirs []string) error { name = ch.From.String() } + if len(files) > 0 { + contains := inFiles(files, name) + if !contains { + continue + } + } + b.Remove(name) if e == nil { continue @@ -376,10 +423,26 @@ func (w *Worktree) resetIndex(t *object.Tree, dirs []string) error { } b.Write(idx) + + if len(dirs) > 0 { + idx.SkipUnless(dirs) + } + return w.r.Storer.SetIndex(idx) } -func (w *Worktree) resetWorktree(t *object.Tree) error { +func inFiles(files []string, v string) bool { + v = filepath.Clean(v) + for _, s := range files { + if filepath.Clean(s) == v { + return true + } + } + + return false +} + +func (w *Worktree) resetWorktree(t *object.Tree, files []string) error { changes, err := w.diffStagingWithWorktree(true, false) if err != nil { return err @@ -395,6 +458,25 @@ func (w *Worktree) resetWorktree(t *object.Tree) error { if err := w.validChange(ch); err != nil { return err } + + if len(files) > 0 { + file := "" + if ch.From != nil { + file = ch.From.String() + } else if ch.To != nil { + file = ch.To.String() + } + + if file == "" { + continue + } + + contains := inFiles(files, file) + if !contains { + continue + } + } + if err := w.checkoutChange(ch, t, b); err != nil { return err } @@ -1058,7 +1140,7 @@ func rmFileAndDirsIfEmpty(fs billy.Filesystem, name string) error { dir := filepath.Dir(name) for { removed, err := removeDirIfEmpty(fs, dir) - if err != nil { + if err != nil && !os.IsNotExist(err) { return err } diff --git a/worktree_bsd.go b/worktree_bsd.go index d4682eb83..562007874 100644 --- a/worktree_bsd.go +++ b/worktree_bsd.go @@ -6,7 +6,7 @@ import ( "syscall" "time" - "github.com/go-git/go-git/v5/plumbing/format/index" + "github.com/jesseduffield/go-git/v5/plumbing/format/index" ) func init() { diff --git a/worktree_commit.go b/worktree_commit.go index 2faf6f00e..b9621204d 100644 --- a/worktree_commit.go +++ b/worktree_commit.go @@ -5,14 +5,15 @@ import ( "errors" "io" "path" + "regexp" "sort" "strings" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/filemode" - "github.com/go-git/go-git/v5/plumbing/format/index" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/storage" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/plumbing/format/index" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/storage" "github.com/ProtonMail/go-crypto/openpgp" "github.com/ProtonMail/go-crypto/openpgp/packet" @@ -23,6 +24,10 @@ var ( // ErrEmptyCommit occurs when a commit is attempted using a clean // working tree, with no changes to be committed. ErrEmptyCommit = errors.New("cannot create empty commit: clean working tree") + + // characters to be removed from user name and/or email before using them to build a commit object + // See https://git-scm.com/docs/git-commit#_commit_information + invalidCharactersRe = regexp.MustCompile(`[<>\n]`) ) // Commit stores the current contents of the index in a new commit along with @@ -48,10 +53,7 @@ func (w *Worktree) Commit(msg string, opts *CommitOptions) (plumbing.Hash, error return plumbing.ZeroHash, err } - opts.Parents = nil - if len(headCommit.ParentHashes) != 0 { - opts.Parents = []plumbing.Hash{headCommit.ParentHashes[0]} - } + opts.Parents = headCommit.ParentHashes } idx, err := w.r.Storer.Index() @@ -137,8 +139,8 @@ func (w *Worktree) updateHEAD(commit plumbing.Hash) error { func (w *Worktree) buildCommitObject(msg string, opts *CommitOptions, tree plumbing.Hash) (plumbing.Hash, error) { commit := &object.Commit{ - Author: *opts.Author, - Committer: *opts.Committer, + Author: w.sanitize(*opts.Author), + Committer: w.sanitize(*opts.Committer), Message: msg, TreeHash: tree, ParentHashes: opts.Parents, @@ -164,6 +166,14 @@ func (w *Worktree) buildCommitObject(msg string, opts *CommitOptions, tree plumb return w.r.Storer.SetEncodedObject(obj) } +func (w *Worktree) sanitize(signature object.Signature) object.Signature { + return object.Signature{ + Name: invalidCharactersRe.ReplaceAllString(signature.Name, ""), + Email: invalidCharactersRe.ReplaceAllString(signature.Email, ""), + When: signature.When, + } +} + type gpgSigner struct { key *openpgp.Entity cfg *packet.Config diff --git a/worktree_commit_test.go b/worktree_commit_test.go index e028facd7..36aca0683 100644 --- a/worktree_commit_test.go +++ b/worktree_commit_test.go @@ -2,144 +2,148 @@ package git import ( "bytes" + "fmt" "log" "os" "os/exec" "path/filepath" "runtime" "strings" + "testing" "time" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/storage/filesystem" - "github.com/go-git/go-git/v5/storage/memory" + fixtures "github.com/go-git/go-git-fixtures/v4" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/plumbing/storer" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/storage/memory" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/ProtonMail/go-crypto/openpgp" "github.com/ProtonMail/go-crypto/openpgp/armor" "github.com/ProtonMail/go-crypto/openpgp/errors" "github.com/go-git/go-billy/v5/memfs" "github.com/go-git/go-billy/v5/util" - . "gopkg.in/check.v1" ) -func (s *WorktreeSuite) TestCommitEmptyOptions(c *C) { +func (s *WorktreeSuite) TestCommitEmptyOptions() { fs := memfs.New() r, err := Init(memory.NewStorage(), fs) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) util.WriteFile(fs, "foo", []byte("foo"), 0644) _, err = w.Add("foo") - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Commit("foo", &CommitOptions{}) - c.Assert(err, IsNil) - c.Assert(hash.IsZero(), Equals, false) + s.NoError(err) + s.False(hash.IsZero()) commit, err := r.CommitObject(hash) - c.Assert(err, IsNil) - c.Assert(commit.Author.Name, Not(Equals), "") + s.NoError(err) + s.NotEqual("", commit.Author.Name) } -func (s *WorktreeSuite) TestCommitInitial(c *C) { +func (s *WorktreeSuite) TestCommitInitial() { expected := plumbing.NewHash("98c4ac7c29c913f7461eae06e024dc18e80d23a4") fs := memfs.New() storage := memory.NewStorage() r, err := Init(storage, fs) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) util.WriteFile(fs, "foo", []byte("foo"), 0644) _, err = w.Add("foo") - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Commit("foo\n", &CommitOptions{Author: defaultSignature()}) - c.Assert(hash, Equals, expected) - c.Assert(err, IsNil) + s.Equal(expected, hash) + s.NoError(err) - assertStorageStatus(c, r, 1, 1, 1, expected) + assertStorageStatus(s, r, 1, 1, 1, expected) } -func (s *WorktreeSuite) TestNothingToCommit(c *C) { +func (s *WorktreeSuite) TestNothingToCommit() { expected := plumbing.NewHash("838ea833ce893e8555907e5ef224aa076f5e274a") r, err := Init(memory.NewStorage(), memfs.New()) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Commit("failed empty commit\n", &CommitOptions{Author: defaultSignature()}) - c.Assert(hash, Equals, plumbing.ZeroHash) - c.Assert(err, Equals, ErrEmptyCommit) + s.Equal(plumbing.ZeroHash, hash) + s.ErrorIs(err, ErrEmptyCommit) hash, err = w.Commit("enable empty commits\n", &CommitOptions{Author: defaultSignature(), AllowEmptyCommits: true}) - c.Assert(hash, Equals, expected) - c.Assert(err, IsNil) + s.Equal(expected, hash) + s.NoError(err) } -func (s *WorktreeSuite) TestNothingToCommitNonEmptyRepo(c *C) { +func (s *WorktreeSuite) TestNothingToCommitNonEmptyRepo() { fs := memfs.New() r, err := Init(memory.NewStorage(), fs) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) err = util.WriteFile(fs, "foo", []byte("foo"), 0644) - c.Assert(err, IsNil) + s.NoError(err) w.Add("foo") _, err = w.Commit("previous commit\n", &CommitOptions{Author: defaultSignature()}) - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Commit("failed empty commit\n", &CommitOptions{Author: defaultSignature()}) - c.Assert(hash, Equals, plumbing.ZeroHash) - c.Assert(err, Equals, ErrEmptyCommit) + s.Equal(plumbing.ZeroHash, hash) + s.ErrorIs(err, ErrEmptyCommit) _, err = w.Commit("enable empty commits\n", &CommitOptions{Author: defaultSignature(), AllowEmptyCommits: true}) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *WorktreeSuite) TestRemoveAndCommitToMakeEmptyRepo(c *C) { +func (s *WorktreeSuite) TestRemoveAndCommitToMakeEmptyRepo() { fs := memfs.New() r, err := Init(memory.NewStorage(), fs) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) err = util.WriteFile(fs, "foo", []byte("foo"), 0644) - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Add("foo") - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Commit("Add in Repo\n", &CommitOptions{Author: defaultSignature()}) - c.Assert(err, IsNil) + s.NoError(err) err = fs.Remove("foo") - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Add("foo") - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Commit("Remove foo\n", &CommitOptions{Author: defaultSignature()}) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *WorktreeSuite) TestCommitParent(c *C) { +func (s *WorktreeSuite) TestCommitParent() { expected := plumbing.NewHash("ef3ca05477530b37f48564be33ddd48063fc7a22") fs := memfs.New() @@ -149,22 +153,22 @@ func (s *WorktreeSuite) TestCommitParent(c *C) { } err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) err = util.WriteFile(fs, "foo", []byte("foo"), 0644) - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Add("foo") - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Commit("foo\n", &CommitOptions{Author: defaultSignature()}) - c.Assert(hash, Equals, expected) - c.Assert(err, IsNil) + s.Equal(expected, hash) + s.NoError(err) - assertStorageStatus(c, s.Repository, 13, 11, 10, expected) + assertStorageStatus(s, s.Repository, 13, 11, 10, expected) } -func (s *WorktreeSuite) TestCommitAmendWithoutChanges(c *C) { +func (s *WorktreeSuite) TestCommitAmendWithoutChanges() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -172,34 +176,34 @@ func (s *WorktreeSuite) TestCommitAmendWithoutChanges(c *C) { } err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) err = util.WriteFile(fs, "foo", []byte("foo"), 0644) - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Add("foo") - c.Assert(err, IsNil) + s.NoError(err) prevHash, err := w.Commit("foo\n", &CommitOptions{Author: defaultSignature()}) - c.Assert(err, IsNil) + s.NoError(err) amendedHash, err := w.Commit("foo\n", &CommitOptions{Author: defaultSignature(), Amend: true}) - c.Assert(err, IsNil) + s.NoError(err) headRef, err := w.r.Head() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(amendedHash, Equals, headRef.Hash()) - c.Assert(amendedHash, Equals, prevHash) + s.Equal(headRef.Hash(), amendedHash) + s.Equal(prevHash, amendedHash) commit, err := w.r.CommitObject(headRef.Hash()) - c.Assert(err, IsNil) - c.Assert(commit.Message, Equals, "foo\n") + s.NoError(err) + s.Equal("foo\n", commit.Message) - assertStorageStatus(c, s.Repository, 13, 11, 10, amendedHash) + assertStorageStatus(s, s.Repository, 13, 11, 10, amendedHash) } -func (s *WorktreeSuite) TestCommitAmendWithChanges(c *C) { +func (s *WorktreeSuite) TestCommitAmendWithChanges() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -207,50 +211,50 @@ func (s *WorktreeSuite) TestCommitAmendWithChanges(c *C) { } err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) util.WriteFile(fs, "foo", []byte("foo"), 0644) _, err = w.Add("foo") - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Commit("foo\n", &CommitOptions{Author: defaultSignature()}) - c.Assert(err, IsNil) + s.NoError(err) util.WriteFile(fs, "bar", []byte("bar"), 0644) _, err = w.Add("bar") - c.Assert(err, IsNil) + s.NoError(err) amendedHash, err := w.Commit("bar\n", &CommitOptions{Amend: true}) - c.Assert(err, IsNil) + s.NoError(err) headRef, err := w.r.Head() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(amendedHash, Equals, headRef.Hash()) + s.Equal(headRef.Hash(), amendedHash) commit, err := w.r.CommitObject(headRef.Hash()) - c.Assert(err, IsNil) - c.Assert(commit.Message, Equals, "bar\n") - c.Assert(commit.NumParents(), Equals, 1) + s.NoError(err) + s.Equal("bar\n", commit.Message) + s.Equal(1, commit.NumParents()) stats, err := commit.Stats() - c.Assert(err, IsNil) - c.Assert(stats, HasLen, 2) - c.Assert(stats[0], Equals, object.FileStat{ + s.NoError(err) + s.Len(stats, 2) + s.Equal(object.FileStat{ Name: "bar", Addition: 1, - }) - c.Assert(stats[1], Equals, object.FileStat{ + }, stats[0]) + s.Equal(object.FileStat{ Name: "foo", Addition: 1, - }) + }, stats[1]) - assertStorageStatus(c, s.Repository, 14, 12, 11, amendedHash) + assertStorageStatus(s, s.Repository, 14, 12, 11, amendedHash) } -func (s *WorktreeSuite) TestCommitAmendNothingToCommit(c *C) { +func (s *WorktreeSuite) TestCommitAmendNothingToCommit() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -258,37 +262,84 @@ func (s *WorktreeSuite) TestCommitAmendNothingToCommit(c *C) { } err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) err = util.WriteFile(fs, "foo", []byte("foo"), 0644) - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Add("foo") - c.Assert(err, IsNil) + s.NoError(err) prevHash, err := w.Commit("foo\n", &CommitOptions{Author: defaultSignature()}) - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Commit("bar\n", &CommitOptions{Author: defaultSignature(), AllowEmptyCommits: true}) - c.Assert(err, IsNil) + s.NoError(err) amendedHash, err := w.Commit("foo\n", &CommitOptions{Author: defaultSignature(), Amend: true}) - c.Log(prevHash, amendedHash) - c.Assert(err, Equals, ErrEmptyCommit) - c.Assert(amendedHash, Equals, plumbing.ZeroHash) + s.T().Log(prevHash, amendedHash) + s.ErrorIs(err, ErrEmptyCommit) + s.Equal(plumbing.ZeroHash, amendedHash) +} + +func TestCount(t *testing.T) { + f := fixtures.Basic().One() + r := NewRepositoryWithEmptyWorktree(f) + + iter, err := r.CommitObjects() + require.NoError(t, err) + + count := 0 + iter.ForEach(func(c *object.Commit) error { + count++ + return nil + }) + assert.Equal(t, 9, count, "commits mismatch") + + trees, err := r.TreeObjects() + require.NoError(t, err) + + count = 0 + trees.ForEach(func(c *object.Tree) error { + count++ + return nil + }) + assert.Equal(t, 12, count, "trees mismatch") + + blobs, err := r.BlobObjects() + require.NoError(t, err) + + count = 0 + blobs.ForEach(func(c *object.Blob) error { + count++ + return nil + }) + assert.Equal(t, 10, count, "blobs mismatch") + + objects, err := r.Objects() + require.NoError(t, err) + + count = 0 + objects.ForEach(func(c object.Object) error { + count++ + return nil + }) + assert.Equal(t, 31, count, "objects mismatch") } -func (s *WorktreeSuite) TestAddAndCommitWithSkipStatus(c *C) { +func TestAddAndCommitWithSkipStatus(t *testing.T) { expected := plumbing.NewHash("375a3808ffde7f129cdd3c8c252fd0fe37cfd13b") + f := fixtures.Basic().One() fs := memfs.New() + r := NewRepositoryWithEmptyWorktree(f) w := &Worktree{ - r: s.Repository, + r: r, Filesystem: fs, } err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + require.NoError(t, err) util.WriteFile(fs, "LICENSE", []byte("foo"), 0644) util.WriteFile(fs, "foo", []byte("foo"), 0644) @@ -297,19 +348,39 @@ func (s *WorktreeSuite) TestAddAndCommitWithSkipStatus(c *C) { Path: "foo", SkipStatus: true, }) - c.Assert(err, IsNil) + require.NoError(t, err) hash, err := w.Commit("commit foo only\n", &CommitOptions{ Author: defaultSignature(), }) - c.Assert(hash, Equals, expected) - c.Assert(err, IsNil) + assert.Equal(t, expected.String(), hash.String()) + require.NoError(t, err) - assertStorageStatus(c, s.Repository, 13, 11, 10, expected) + assertStorage(t, r, 13, 11, 10, expected) } -func (s *WorktreeSuite) TestAddAndCommitWithSkipStatusPathNotModified(c *C) { +func assertStorage( + t *testing.T, r *Repository, + treesCount, blobCount, commitCount int, head plumbing.Hash, +) { + trees, err := r.Storer.IterEncodedObjects(plumbing.TreeObject) + require.NoError(t, err) + blobs, err := r.Storer.IterEncodedObjects(plumbing.BlobObject) + require.NoError(t, err) + commits, err := r.Storer.IterEncodedObjects(plumbing.CommitObject) + require.NoError(t, err) + + assert.Equal(t, treesCount, lenIterEncodedObjects(trees), "trees count mismatch") + assert.Equal(t, blobCount, lenIterEncodedObjects(blobs), "blobs count mismatch") + assert.Equal(t, commitCount, lenIterEncodedObjects(commits), "commits count mismatch") + + ref, err := r.Head() + require.NoError(t, err) + assert.Equal(t, head.String(), ref.Hash().String()) +} + +func (s *WorktreeSuite) TestAddAndCommitWithSkipStatusPathNotModified() { expected := plumbing.NewHash("375a3808ffde7f129cdd3c8c252fd0fe37cfd13b") expected2 := plumbing.NewHash("8691273baf8f6ee2cccfc05e910552c04d02d472") @@ -320,82 +391,83 @@ func (s *WorktreeSuite) TestAddAndCommitWithSkipStatusPathNotModified(c *C) { } err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) util.WriteFile(fs, "foo", []byte("foo"), 0644) status, err := w.Status() - c.Assert(err, IsNil) + s.NoError(err) foo := status.File("foo") - c.Assert(foo.Staging, Equals, Untracked) - c.Assert(foo.Worktree, Equals, Untracked) + s.Equal(Untracked, foo.Staging) + s.Equal(Untracked, foo.Worktree) err = w.AddWithOptions(&AddOptions{ Path: "foo", SkipStatus: true, }) - c.Assert(err, IsNil) + s.NoError(err) status, err = w.Status() - c.Assert(err, IsNil) + s.NoError(err) foo = status.File("foo") - c.Assert(foo.Staging, Equals, Added) - c.Assert(foo.Worktree, Equals, Unmodified) + s.Equal(Added, foo.Staging) + s.Equal(Unmodified, foo.Worktree) - hash, err := w.Commit("commit foo only\n", &CommitOptions{All: true, + hash, err := w.Commit("commit foo only\n", &CommitOptions{ + All: true, Author: defaultSignature(), }) - c.Assert(hash, Equals, expected) - c.Assert(err, IsNil) + s.Equal(expected, hash) + s.NoError(err) commit1, err := w.r.CommitObject(hash) - c.Assert(err, IsNil) + s.NoError(err) status, err = w.Status() - c.Assert(err, IsNil) + s.NoError(err) foo = status.File("foo") - c.Assert(foo.Staging, Equals, Untracked) - c.Assert(foo.Worktree, Equals, Untracked) + s.Equal(Untracked, foo.Staging) + s.Equal(Untracked, foo.Worktree) - assertStorageStatus(c, s.Repository, 13, 11, 10, expected) + assertStorageStatus(s, s.Repository, 13, 11, 10, expected) err = w.AddWithOptions(&AddOptions{ Path: "foo", SkipStatus: true, }) - c.Assert(err, IsNil) + s.NoError(err) status, err = w.Status() - c.Assert(err, IsNil) + s.NoError(err) foo = status.File("foo") - c.Assert(foo.Staging, Equals, Untracked) - c.Assert(foo.Worktree, Equals, Untracked) + s.Equal(Untracked, foo.Staging) + s.Equal(Untracked, foo.Worktree) hash, err = w.Commit("commit with no changes\n", &CommitOptions{ Author: defaultSignature(), AllowEmptyCommits: true, }) - c.Assert(hash, Equals, expected2) - c.Assert(err, IsNil) + s.Equal(expected2, hash) + s.NoError(err) commit2, err := w.r.CommitObject(hash) - c.Assert(err, IsNil) + s.NoError(err) status, err = w.Status() - c.Assert(err, IsNil) + s.NoError(err) foo = status.File("foo") - c.Assert(foo.Staging, Equals, Untracked) - c.Assert(foo.Worktree, Equals, Untracked) + s.Equal(Untracked, foo.Staging) + s.Equal(Untracked, foo.Worktree) patch, err := commit2.Patch(commit1) - c.Assert(err, IsNil) + s.NoError(err) files := patch.FilePatches() - c.Assert(files, IsNil) + s.Nil(files) - assertStorageStatus(c, s.Repository, 13, 11, 11, expected2) + assertStorageStatus(s, s.Repository, 13, 11, 11, expected2) } -func (s *WorktreeSuite) TestCommitAll(c *C) { +func (s *WorktreeSuite) TestCommitAll() { expected := plumbing.NewHash("aede6f8c9c1c7ec9ca8d287c64b8ed151276fa28") fs := memfs.New() @@ -405,7 +477,7 @@ func (s *WorktreeSuite) TestCommitAll(c *C) { } err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) util.WriteFile(fs, "LICENSE", []byte("foo"), 0644) util.WriteFile(fs, "foo", []byte("foo"), 0644) @@ -415,13 +487,13 @@ func (s *WorktreeSuite) TestCommitAll(c *C) { Author: defaultSignature(), }) - c.Assert(hash, Equals, expected) - c.Assert(err, IsNil) + s.Equal(expected, hash) + s.NoError(err) - assertStorageStatus(c, s.Repository, 13, 11, 10, expected) + assertStorageStatus(s, s.Repository, 13, 11, 10, expected) } -func (s *WorktreeSuite) TestRemoveAndCommitAll(c *C) { +func (s *WorktreeSuite) TestRemoveAndCommitAll() { expected := plumbing.NewHash("907cd576c6ced2ecd3dab34a72bf9cf65944b9a9") fs := memfs.New() @@ -431,122 +503,121 @@ func (s *WorktreeSuite) TestRemoveAndCommitAll(c *C) { } err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) util.WriteFile(fs, "foo", []byte("foo"), 0644) _, err = w.Add("foo") - c.Assert(err, IsNil) + s.NoError(err) _, errFirst := w.Commit("Add in Repo\n", &CommitOptions{ Author: defaultSignature(), }) - c.Assert(errFirst, IsNil) + s.Nil(errFirst) errRemove := fs.Remove("foo") - c.Assert(errRemove, IsNil) + s.Nil(errRemove) hash, errSecond := w.Commit("Remove foo\n", &CommitOptions{ All: true, Author: defaultSignature(), }) - c.Assert(errSecond, IsNil) + s.Nil(errSecond) - c.Assert(hash, Equals, expected) - c.Assert(err, IsNil) + s.Equal(expected, hash) + s.NoError(err) - assertStorageStatus(c, s.Repository, 13, 11, 11, expected) + assertStorageStatus(s, s.Repository, 13, 11, 11, expected) } -func (s *WorktreeSuite) TestCommitSign(c *C) { +func (s *WorktreeSuite) TestCommitSign() { fs := memfs.New() storage := memory.NewStorage() r, err := Init(storage, fs) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) util.WriteFile(fs, "foo", []byte("foo"), 0644) _, err = w.Add("foo") - c.Assert(err, IsNil) + s.NoError(err) - key := commitSignKey(c, true) + key := commitSignKey(s.T(), true) hash, err := w.Commit("foo\n", &CommitOptions{Author: defaultSignature(), SignKey: key}) - c.Assert(err, IsNil) + s.NoError(err) // Verify the commit. pks := new(bytes.Buffer) pkw, err := armor.Encode(pks, openpgp.PublicKeyType, nil) - c.Assert(err, IsNil) + s.NoError(err) err = key.Serialize(pkw) - c.Assert(err, IsNil) + s.NoError(err) err = pkw.Close() - c.Assert(err, IsNil) + s.NoError(err) expectedCommit, err := r.CommitObject(hash) - c.Assert(err, IsNil) + s.NoError(err) actual, err := expectedCommit.Verify(pks.String()) - c.Assert(err, IsNil) - c.Assert(actual.PrimaryKey, DeepEquals, key.PrimaryKey) + s.NoError(err) + s.Equal(key.PrimaryKey, actual.PrimaryKey) } -func (s *WorktreeSuite) TestCommitSignBadKey(c *C) { +func (s *WorktreeSuite) TestCommitSignBadKey() { fs := memfs.New() storage := memory.NewStorage() r, err := Init(storage, fs) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) util.WriteFile(fs, "foo", []byte("foo"), 0644) _, err = w.Add("foo") - c.Assert(err, IsNil) + s.NoError(err) - key := commitSignKey(c, false) + key := commitSignKey(s.T(), false) _, err = w.Commit("foo\n", &CommitOptions{Author: defaultSignature(), SignKey: key}) - c.Assert(err, Equals, errors.InvalidArgumentError("signing key is encrypted")) + s.ErrorIs(err, errors.InvalidArgumentError("signing key is encrypted")) } -func (s *WorktreeSuite) TestCommitTreeSort(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *WorktreeSuite) TestCommitTreeSort() { + fs := s.TemporalFilesystem() st := filesystem.NewStorage(fs, cache.NewObjectLRUDefault()) _, err := Init(st, nil) - c.Assert(err, IsNil) + s.NoError(err) r, _ := Clone(memory.NewStorage(), memfs.New(), &CloneOptions{ URL: fs.Root(), }) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) mfs := w.Filesystem err = mfs.MkdirAll("delta", 0755) - c.Assert(err, IsNil) + s.NoError(err) for _, p := range []string{"delta_last", "Gamma", "delta/middle", "Beta", "delta-first", "alpha"} { util.WriteFile(mfs, p, []byte("foo"), 0644) _, err = w.Add(p) - c.Assert(err, IsNil) + s.NoError(err) } _, err = w.Commit("foo\n", &CommitOptions{ All: true, Author: defaultSignature(), }) - c.Assert(err, IsNil) + s.NoError(err) err = r.Push(&PushOptions{}) - c.Assert(err, IsNil) + s.NoError(err) cmd := exec.Command("git", "fsck") cmd.Dir = fs.Root() @@ -557,87 +628,123 @@ func (s *WorktreeSuite) TestCommitTreeSort(c *C) { err = cmd.Run() - c.Assert(err, IsNil, Commentf("%s", buf.Bytes())) + s.NoError(err, fmt.Sprintf("%s", buf.Bytes())) } // https://github.com/go-git/go-git/pull/224 -func (s *WorktreeSuite) TestJustStoreObjectsNotAlreadyStored(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *WorktreeSuite) TestJustStoreObjectsNotAlreadyStored() { + fs := s.TemporalFilesystem() fsDotgit, err := fs.Chroot(".git") // real fs to get modified timestamps - c.Assert(err, IsNil) + s.NoError(err) storage := filesystem.NewStorage(fsDotgit, cache.NewObjectLRUDefault()) r, err := Init(storage, fs) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) // Step 1: Write LICENSE util.WriteFile(fs, "LICENSE", []byte("license"), 0644) hLicense, err := w.Add("LICENSE") - c.Assert(err, IsNil) - c.Assert(hLicense, Equals, plumbing.NewHash("0484eba0d41636ba71fa612c78559cd6c3006cde")) + s.NoError(err) + s.Equal(plumbing.NewHash("0484eba0d41636ba71fa612c78559cd6c3006cde"), hLicense) hash, err := w.Commit("commit 1\n", &CommitOptions{ All: true, Author: defaultSignature(), }) - c.Assert(err, IsNil) - c.Assert(hash, Equals, plumbing.NewHash("7a7faee4630d2664a6869677cc8ab614f3fd4a18")) + s.NoError(err) + s.Equal(plumbing.NewHash("7a7faee4630d2664a6869677cc8ab614f3fd4a18"), hash) infoLicense, err := fsDotgit.Stat(filepath.Join("objects", "04", "84eba0d41636ba71fa612c78559cd6c3006cde")) - c.Assert(err, IsNil) // checking objects file exists + s.NoError(err) // checking objects file exists // Step 2: Write foo. time.Sleep(5 * time.Millisecond) // uncool, but we need to get different timestamps... util.WriteFile(fs, "foo", []byte("foo"), 0644) hFoo, err := w.Add("foo") - c.Assert(err, IsNil) - c.Assert(hFoo, Equals, plumbing.NewHash("19102815663d23f8b75a47e7a01965dcdc96468c")) + s.NoError(err) + s.Equal(plumbing.NewHash("19102815663d23f8b75a47e7a01965dcdc96468c"), hFoo) hash, err = w.Commit("commit 2\n", &CommitOptions{ All: true, Author: defaultSignature(), }) - c.Assert(err, IsNil) - c.Assert(hash, Equals, plumbing.NewHash("97c0c5177e6ac57d10e8ea0017f2d39b91e2b364")) + s.NoError(err) + s.Equal(plumbing.NewHash("97c0c5177e6ac57d10e8ea0017f2d39b91e2b364"), hash) // Step 3: Check // There is no need to overwrite the object of LICENSE, because its content // was not changed. Just a write on the object of foo is required. This behaviour // is fixed by #224 and tested by comparing the timestamps of the stored objects. infoFoo, err := fsDotgit.Stat(filepath.Join("objects", "19", "102815663d23f8b75a47e7a01965dcdc96468c")) - c.Assert(err, IsNil) // checking objects file exists - c.Assert(infoLicense.ModTime().Before(infoFoo.ModTime()), Equals, true) // object of foo has another/greaterThan timestamp than LICENSE + s.NoError(err) // checking objects file exists + s.True(infoLicense.ModTime().Before(infoFoo.ModTime())) // object of foo has another/greaterThan timestamp than LICENSE infoLicenseSecond, err := fsDotgit.Stat(filepath.Join("objects", "04", "84eba0d41636ba71fa612c78559cd6c3006cde")) - c.Assert(err, IsNil) + s.NoError(err) log.Printf("comparing mod time: %v == %v on %v (%v)", infoLicenseSecond.ModTime(), infoLicense.ModTime(), runtime.GOOS, runtime.GOARCH) - c.Assert(infoLicenseSecond.ModTime(), Equals, infoLicense.ModTime()) // object of LICENSE should have the same timestamp because no additional write operation was performed + s.Equal(infoLicense.ModTime(), infoLicenseSecond.ModTime()) // object of LICENSE should have the same timestamp because no additional write operation was performed +} + +func (s *WorktreeSuite) TestCommitInvalidCharactersInAuthorInfos() { + f := fixtures.Basic().One() + s.Repository = NewRepositoryWithEmptyWorktree(f) + + expected := plumbing.NewHash("e8eecef2524c3a37cf0f0996603162f81e0373f1") + + fs := memfs.New() + storage := memory.NewStorage() + + r, err := Init(storage, fs) + s.NoError(err) + + w, err := r.Worktree() + s.NoError(err) + + util.WriteFile(fs, "foo", []byte("foo"), 0644) + + _, err = w.Add("foo") + s.NoError(err) + + hash, err := w.Commit("foo\n", &CommitOptions{Author: invalidSignature()}) + s.Equal(expected, hash) + s.NoError(err) + + assertStorageStatus(s, r, 1, 1, 1, expected) + + // Check HEAD commit contains author informations with '<', '>' and '\n' stripped + lr, err := r.Log(&LogOptions{}) + s.NoError(err) + + commit, err := lr.Next() + s.NoError(err) + + s.Equal("foo bad", commit.Author.Name) + s.Equal("badfoo@foo.foo", commit.Author.Email) } func assertStorageStatus( - c *C, r *Repository, + s *WorktreeSuite, r *Repository, treesCount, blobCount, commitCount int, head plumbing.Hash, ) { trees, err := r.Storer.IterEncodedObjects(plumbing.TreeObject) - c.Assert(err, IsNil) + s.NoError(err) blobs, err := r.Storer.IterEncodedObjects(plumbing.BlobObject) - c.Assert(err, IsNil) + s.NoError(err) commits, err := r.Storer.IterEncodedObjects(plumbing.CommitObject) - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(lenIterEncodedObjects(trees), Equals, treesCount) - c.Assert(lenIterEncodedObjects(blobs), Equals, blobCount) - c.Assert(lenIterEncodedObjects(commits), Equals, commitCount) + s.Equal(treesCount, lenIterEncodedObjects(trees)) + s.Equal(blobCount, lenIterEncodedObjects(blobs)) + s.Equal(commitCount, lenIterEncodedObjects(commits)) ref, err := r.Head() - c.Assert(err, IsNil) - c.Assert(ref.Hash(), Equals, head) + s.NoError(err) + s.Equal(head, ref.Hash()) } func lenIterEncodedObjects(iter storer.EncodedObjectIter) int { @@ -659,20 +766,29 @@ func defaultSignature() *object.Signature { } } -func commitSignKey(c *C, decrypt bool) *openpgp.Entity { +func invalidSignature() *object.Signature { + when, _ := time.Parse(object.DateFormat, "Thu May 04 00:03:43 2017 +0200") + return &object.Signature{ + Name: "foo \n", + Email: "\nfoo@foo.foo", + When: when, + } +} + +func commitSignKey(t *testing.T, decrypt bool) *openpgp.Entity { s := strings.NewReader(armoredKeyRing) es, err := openpgp.ReadArmoredKeyRing(s) - c.Assert(err, IsNil) + assert.NoError(t, err) - c.Assert(es, HasLen, 1) - c.Assert(es[0].Identities, HasLen, 1) + assert.Len(t, es, 1) + assert.Len(t, es[0].Identities, 1) _, ok := es[0].Identities["foo bar "] - c.Assert(ok, Equals, true) + assert.True(t, ok) key := es[0] if decrypt { err = key.PrivateKey.Decrypt([]byte(keyPassphrase)) - c.Assert(err, IsNil) + assert.NoError(t, err) } return key diff --git a/worktree_js.go b/worktree_js.go index 7267d055e..7c4f6c325 100644 --- a/worktree_js.go +++ b/worktree_js.go @@ -6,7 +6,7 @@ import ( "syscall" "time" - "github.com/go-git/go-git/v5/plumbing/format/index" + "github.com/jesseduffield/go-git/v5/plumbing/format/index" ) func init() { diff --git a/worktree_linux.go b/worktree_linux.go index f6b85fe3d..ee090a7b2 100644 --- a/worktree_linux.go +++ b/worktree_linux.go @@ -7,7 +7,7 @@ import ( "syscall" "time" - "github.com/go-git/go-git/v5/plumbing/format/index" + "github.com/jesseduffield/go-git/v5/plumbing/format/index" ) func init() { diff --git a/worktree_plan9.go b/worktree_plan9.go index 8cedf71a3..7952a68e5 100644 --- a/worktree_plan9.go +++ b/worktree_plan9.go @@ -4,7 +4,7 @@ import ( "syscall" "time" - "github.com/go-git/go-git/v5/plumbing/format/index" + "github.com/jesseduffield/go-git/v5/plumbing/format/index" ) func init() { diff --git a/worktree_status.go b/worktree_status.go index 6e72db974..21c74c59e 100644 --- a/worktree_status.go +++ b/worktree_status.go @@ -10,16 +10,16 @@ import ( "strings" "github.com/go-git/go-billy/v5/util" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/filemode" - "github.com/go-git/go-git/v5/plumbing/format/gitignore" - "github.com/go-git/go-git/v5/plumbing/format/index" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/utils/ioutil" - "github.com/go-git/go-git/v5/utils/merkletrie" - "github.com/go-git/go-git/v5/utils/merkletrie/filesystem" - mindex "github.com/go-git/go-git/v5/utils/merkletrie/index" - "github.com/go-git/go-git/v5/utils/merkletrie/noder" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/plumbing/format/gitignore" + "github.com/jesseduffield/go-git/v5/plumbing/format/index" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/utils/ioutil" + "github.com/jesseduffield/go-git/v5/utils/merkletrie" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/filesystem" + mindex "github.com/jesseduffield/go-git/v5/utils/merkletrie/index" + "github.com/jesseduffield/go-git/v5/utils/merkletrie/noder" ) var ( @@ -370,6 +370,8 @@ func (w *Worktree) doAdd(path string, ignorePattern []gitignore.Pattern, skipSta } } + path = filepath.Clean(path) + if err != nil || !fi.IsDir() { added, h, err = w.doAddFile(idx, s, path, ignorePattern) } else { diff --git a/worktree_status_test.go b/worktree_status_test.go index 629ebd5bf..02ccc287e 100644 --- a/worktree_status_test.go +++ b/worktree_status_test.go @@ -7,8 +7,8 @@ import ( "testing" "github.com/go-git/go-billy/v5/osfs" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/storage/filesystem" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) diff --git a/worktree_test.go b/worktree_test.go index 636ccbe48..5ab931945 100644 --- a/worktree_test.go +++ b/worktree_test.go @@ -4,6 +4,7 @@ import ( "bytes" "context" "errors" + "fmt" "io" "os" "path/filepath" @@ -14,22 +15,23 @@ import ( "time" fixtures "github.com/go-git/go-git-fixtures/v4" - "github.com/go-git/go-git/v5/config" - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/filemode" - "github.com/go-git/go-git/v5/plumbing/format/gitignore" - "github.com/go-git/go-git/v5/plumbing/format/index" - "github.com/go-git/go-git/v5/plumbing/object" - "github.com/go-git/go-git/v5/storage/filesystem" - "github.com/go-git/go-git/v5/storage/memory" + "github.com/jesseduffield/go-git/v5/config" + "github.com/jesseduffield/go-git/v5/plumbing" + "github.com/jesseduffield/go-git/v5/plumbing/cache" + "github.com/jesseduffield/go-git/v5/plumbing/filemode" + "github.com/jesseduffield/go-git/v5/plumbing/format/gitignore" + "github.com/jesseduffield/go-git/v5/plumbing/format/index" + "github.com/jesseduffield/go-git/v5/plumbing/object" + "github.com/jesseduffield/go-git/v5/storage/filesystem" + "github.com/jesseduffield/go-git/v5/storage/memory" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" + "github.com/go-git/go-billy/v5" "github.com/go-git/go-billy/v5/memfs" "github.com/go-git/go-billy/v5/osfs" "github.com/go-git/go-billy/v5/util" "golang.org/x/text/unicode/norm" - . "gopkg.in/check.v1" ) func defaultTestCommitOptions() *CommitOptions { @@ -39,17 +41,20 @@ func defaultTestCommitOptions() *CommitOptions { } type WorktreeSuite struct { + suite.Suite BaseSuite } -var _ = Suite(&WorktreeSuite{}) +func TestWorktreeSuite(t *testing.T) { + suite.Run(t, new(WorktreeSuite)) +} -func (s *WorktreeSuite) SetUpTest(c *C) { +func (s *WorktreeSuite) SetupTest() { f := fixtures.Basic().One() - s.Repository = s.NewRepositoryWithEmptyWorktree(f) + s.Repository = NewRepositoryWithEmptyWorktree(f) } -func (s *WorktreeSuite) TestPullCheckout(c *C) { +func (s *WorktreeSuite) TestPullCheckout() { fs := memfs.New() r, _ := Init(memory.NewStorage(), fs) r.CreateRemote(&config.RemoteConfig{ @@ -58,94 +63,94 @@ func (s *WorktreeSuite) TestPullCheckout(c *C) { }) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) err = w.Pull(&PullOptions{}) - c.Assert(err, IsNil) + s.NoError(err) fi, err := fs.ReadDir("") - c.Assert(err, IsNil) - c.Assert(fi, HasLen, 8) + s.NoError(err) + s.Len(fi, 8) } -func (s *WorktreeSuite) TestPullFastForward(c *C) { - url, clean := s.TemporalDir() - defer clean() +func (s *WorktreeSuite) TestPullFastForward() { + url, err := os.MkdirTemp("", "") + s.NoError(err) path := fixtures.Basic().ByTag("worktree").One().Worktree().Root() server, err := PlainClone(url, false, &CloneOptions{ URL: path, }) - c.Assert(err, IsNil) + s.NoError(err) - dir, clean := s.TemporalDir() - defer clean() + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainClone(dir, false, &CloneOptions{ URL: url, }) - c.Assert(err, IsNil) + s.NoError(err) w, err := server.Worktree() - c.Assert(err, IsNil) - err = os.WriteFile(filepath.Join(url, "foo"), []byte("foo"), 0755) - c.Assert(err, IsNil) + s.NoError(err) + err = os.WriteFile(filepath.Join(url, "foo"), []byte("foo"), 0o755) + s.NoError(err) w.Add("foo") hash, err := w.Commit("foo", &CommitOptions{Author: defaultSignature()}) - c.Assert(err, IsNil) + s.NoError(err) w, err = r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) err = w.Pull(&PullOptions{}) - c.Assert(err, IsNil) + s.NoError(err) head, err := r.Head() - c.Assert(err, IsNil) - c.Assert(head.Hash(), Equals, hash) + s.NoError(err) + s.Equal(hash, head.Hash()) } -func (s *WorktreeSuite) TestPullNonFastForward(c *C) { - url, clean := s.TemporalDir() - defer clean() +func (s *WorktreeSuite) TestPullNonFastForward() { + url, err := os.MkdirTemp("", "") + s.NoError(err) path := fixtures.Basic().ByTag("worktree").One().Worktree().Root() server, err := PlainClone(url, false, &CloneOptions{ URL: path, }) - c.Assert(err, IsNil) + s.NoError(err) - dir, clean := s.TemporalDir() - defer clean() + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainClone(dir, false, &CloneOptions{ URL: url, }) - c.Assert(err, IsNil) + s.NoError(err) w, err := server.Worktree() - c.Assert(err, IsNil) - err = os.WriteFile(filepath.Join(url, "foo"), []byte("foo"), 0755) - c.Assert(err, IsNil) + s.NoError(err) + err = os.WriteFile(filepath.Join(url, "foo"), []byte("foo"), 0o755) + s.NoError(err) w.Add("foo") _, err = w.Commit("foo", &CommitOptions{Author: defaultSignature()}) - c.Assert(err, IsNil) + s.NoError(err) w, err = r.Worktree() - c.Assert(err, IsNil) - err = os.WriteFile(filepath.Join(dir, "bar"), []byte("bar"), 0755) - c.Assert(err, IsNil) + s.NoError(err) + err = os.WriteFile(filepath.Join(dir, "bar"), []byte("bar"), 0o755) + s.NoError(err) w.Add("bar") _, err = w.Commit("bar", &CommitOptions{Author: defaultSignature()}) - c.Assert(err, IsNil) + s.NoError(err) err = w.Pull(&PullOptions{}) - c.Assert(err, Equals, ErrNonFastForwardUpdate) + s.ErrorIs(err, ErrNonFastForwardUpdate) } -func (s *WorktreeSuite) TestPullUpdateReferencesIfNeeded(c *C) { +func (s *WorktreeSuite) TestPullUpdateReferencesIfNeeded() { r, _ := Init(memory.NewStorage(), memfs.New()) r.CreateRemote(&config.RemoteConfig{ Name: DefaultRemoteName, @@ -153,56 +158,56 @@ func (s *WorktreeSuite) TestPullUpdateReferencesIfNeeded(c *C) { }) err := r.Fetch(&FetchOptions{}) - c.Assert(err, IsNil) + s.NoError(err) _, err = r.Reference("refs/heads/master", false) - c.Assert(err, NotNil) + s.NotNil(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) err = w.Pull(&PullOptions{}) - c.Assert(err, IsNil) + s.NoError(err) head, err := r.Reference(plumbing.HEAD, true) - c.Assert(err, IsNil) - c.Assert(head.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") + s.NoError(err) + s.Equal("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", head.Hash().String()) branch, err := r.Reference("refs/heads/master", false) - c.Assert(err, IsNil) - c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") + s.NoError(err) + s.Equal("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", branch.Hash().String()) err = w.Pull(&PullOptions{}) - c.Assert(err, Equals, NoErrAlreadyUpToDate) + s.ErrorIs(err, NoErrAlreadyUpToDate) } -func (s *WorktreeSuite) TestPullInSingleBranch(c *C) { +func (s *WorktreeSuite) TestPullInSingleBranch() { r, _ := Init(memory.NewStorage(), memfs.New()) err := r.clone(context.Background(), &CloneOptions{ URL: s.GetBasicLocalRepositoryURL(), SingleBranch: true, }) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) err = w.Pull(&PullOptions{}) - c.Assert(err, Equals, NoErrAlreadyUpToDate) + s.ErrorIs(err, NoErrAlreadyUpToDate) branch, err := r.Reference("refs/heads/master", false) - c.Assert(err, IsNil) - c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") + s.NoError(err) + s.Equal("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", branch.Hash().String()) _, err = r.Reference("refs/remotes/foo/branch", false) - c.Assert(err, NotNil) + s.NotNil(err) storage := r.Storer.(*memory.Storage) - c.Assert(storage.Objects, HasLen, 28) + s.Len(storage.Objects, 28) } -func (s *WorktreeSuite) TestPullProgress(c *C) { +func (s *WorktreeSuite) TestPullProgress() { r, _ := Init(memory.NewStorage(), memfs.New()) r.CreateRemote(&config.RemoteConfig{ @@ -211,26 +216,26 @@ func (s *WorktreeSuite) TestPullProgress(c *C) { }) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) buf := bytes.NewBuffer(nil) err = w.Pull(&PullOptions{ Progress: buf, }) - c.Assert(err, IsNil) - c.Assert(buf.Len(), Not(Equals), 0) + s.NoError(err) + s.NotEqual(0, buf.Len()) } -func (s *WorktreeSuite) TestPullProgressWithRecursion(c *C) { +func (s *WorktreeSuite) TestPullProgressWithRecursion() { if testing.Short() { - c.Skip("skipping test in short mode.") + s.T().Skip("skipping test in short mode.") } path := fixtures.ByTag("submodule").One().Worktree().Root() - dir, clean := s.TemporalDir() - defer clean() + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, _ := PlainInit(dir, false) r.CreateRemote(&config.RemoteConfig{ @@ -239,55 +244,55 @@ func (s *WorktreeSuite) TestPullProgressWithRecursion(c *C) { }) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) err = w.Pull(&PullOptions{ RecurseSubmodules: DefaultSubmoduleRecursionDepth, }) - c.Assert(err, IsNil) + s.NoError(err) cfg, err := r.Config() - c.Assert(err, IsNil) - c.Assert(cfg.Submodules, HasLen, 2) + s.NoError(err) + s.Len(cfg.Submodules, 2) } -func (s *RepositorySuite) TestPullAdd(c *C) { +func (s *RepositorySuite) TestPullAdd() { path := fixtures.Basic().ByTag("worktree").One().Worktree().Root() r, err := Clone(memory.NewStorage(), memfs.New(), &CloneOptions{ URL: filepath.Join(path, ".git"), }) - c.Assert(err, IsNil) + s.NoError(err) storage := r.Storer.(*memory.Storage) - c.Assert(storage.Objects, HasLen, 28) + s.Len(storage.Objects, 28) branch, err := r.Reference("refs/heads/master", false) - c.Assert(err, IsNil) - c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") + s.NoError(err) + s.Equal("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", branch.Hash().String()) - ExecuteOnPath(c, path, + ExecuteOnPath(s.T(), path, "touch foo", "git add foo", "git commit --no-gpg-sign -m foo foo", ) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) err = w.Pull(&PullOptions{RemoteName: "origin"}) - c.Assert(err, IsNil) + s.NoError(err) // the commit command has introduced a new commit, tree and blob - c.Assert(storage.Objects, HasLen, 31) + s.Len(storage.Objects, 31) branch, err = r.Reference("refs/heads/master", false) - c.Assert(err, IsNil) - c.Assert(branch.Hash().String(), Not(Equals), "6ecf0ef2c2dffb796033e5a02219af86ec6584e5") + s.NoError(err) + s.NotEqual("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", branch.Hash().String()) } -func (s *WorktreeSuite) TestPullAlreadyUptodate(c *C) { +func (s *WorktreeSuite) TestPullAlreadyUptodate() { path := fixtures.Basic().ByTag("worktree").One().Worktree().Root() fs := memfs.New() @@ -295,71 +300,71 @@ func (s *WorktreeSuite) TestPullAlreadyUptodate(c *C) { URL: filepath.Join(path, ".git"), }) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) - err = util.WriteFile(fs, "bar", []byte("bar"), 0755) - c.Assert(err, IsNil) + s.NoError(err) + err = util.WriteFile(fs, "bar", []byte("bar"), 0o755) + s.NoError(err) w.Add("bar") _, err = w.Commit("bar", &CommitOptions{Author: defaultSignature()}) - c.Assert(err, IsNil) + s.NoError(err) err = w.Pull(&PullOptions{}) - c.Assert(err, Equals, NoErrAlreadyUpToDate) + s.ErrorIs(err, NoErrAlreadyUpToDate) } -func (s *WorktreeSuite) TestPullDepth(c *C) { +func (s *WorktreeSuite) TestPullDepth() { r, err := Clone(memory.NewStorage(), memfs.New(), &CloneOptions{ URL: fixtures.Basic().One().URL, Depth: 1, }) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) err = w.Pull(&PullOptions{}) - c.Assert(err, Equals, nil) + s.NoError(err) } -func (s *WorktreeSuite) TestPullAfterShallowClone(c *C) { - tempDir, clean := s.TemporalDir() - defer clean() +func (s *WorktreeSuite) TestPullAfterShallowClone() { + tempDir, err := os.MkdirTemp("", "") + s.NoError(err) remoteURL := filepath.Join(tempDir, "remote") repoDir := filepath.Join(tempDir, "repo") remote, err := PlainInit(remoteURL, false) - c.Assert(err, IsNil) - c.Assert(remote, NotNil) + s.NoError(err) + s.NotNil(remote) - _ = CommitNewFile(c, remote, "File1") - _ = CommitNewFile(c, remote, "File2") + _ = CommitNewFile(s.T(), remote, "File1") + _ = CommitNewFile(s.T(), remote, "File2") repo, err := PlainClone(repoDir, false, &CloneOptions{ URL: remoteURL, Depth: 1, - Tags: NoTags, + Tags: plumbing.NoTags, SingleBranch: true, ReferenceName: "master", }) - c.Assert(err, IsNil) + s.NoError(err) - _ = CommitNewFile(c, remote, "File3") - _ = CommitNewFile(c, remote, "File4") + _ = CommitNewFile(s.T(), remote, "File3") + _ = CommitNewFile(s.T(), remote, "File4") w, err := repo.Worktree() - c.Assert(err, IsNil) + s.NoError(err) err = w.Pull(&PullOptions{ RemoteName: DefaultRemoteName, SingleBranch: true, ReferenceName: plumbing.NewBranchReferenceName("master"), }) - c.Assert(err, IsNil) + s.NoError(err) } -func (s *WorktreeSuite) TestCheckout(c *C) { +func (s *WorktreeSuite) TestCheckout() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -369,46 +374,46 @@ func (s *WorktreeSuite) TestCheckout(c *C) { err := w.Checkout(&CheckoutOptions{ Force: true, }) - c.Assert(err, IsNil) + s.NoError(err) entries, err := fs.ReadDir("/") - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(entries, HasLen, 8) + s.Len(entries, 8) ch, err := fs.Open("CHANGELOG") - c.Assert(err, IsNil) + s.NoError(err) content, err := io.ReadAll(ch) - c.Assert(err, IsNil) - c.Assert(string(content), Equals, "Initial changelog\n") + s.NoError(err) + s.Equal("Initial changelog\n", string(content)) idx, err := s.Repository.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) + s.NoError(err) + s.Len(idx.Entries, 9) } -func (s *WorktreeSuite) TestCheckoutForce(c *C) { +func (s *WorktreeSuite) TestCheckoutForce() { w := &Worktree{ r: s.Repository, Filesystem: memfs.New(), } err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) w.Filesystem = memfs.New() err = w.Checkout(&CheckoutOptions{ Force: true, }) - c.Assert(err, IsNil) + s.NoError(err) entries, err := w.Filesystem.ReadDir("/") - c.Assert(err, IsNil) - c.Assert(entries, HasLen, 8) + s.NoError(err) + s.Len(entries, 8) } -func (s *WorktreeSuite) TestCheckoutKeep(c *C) { +func (s *WorktreeSuite) TestCheckoutKeep() { w := &Worktree{ r: s.Repository, Filesystem: memfs.New(), @@ -417,50 +422,50 @@ func (s *WorktreeSuite) TestCheckoutKeep(c *C) { err := w.Checkout(&CheckoutOptions{ Force: true, }) - c.Assert(err, IsNil) + s.NoError(err) // Create a new branch and create a new file. err = w.Checkout(&CheckoutOptions{ Branch: plumbing.NewBranchReferenceName("new-branch"), Create: true, }) - c.Assert(err, IsNil) + s.NoError(err) w.Filesystem = memfs.New() f, err := w.Filesystem.Create("new-file.txt") - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("DUMMY")) - c.Assert(err, IsNil) - c.Assert(f.Close(), IsNil) + s.NoError(err) + s.Nil(f.Close()) // Add the file to staging. _, err = w.Add("new-file.txt") - c.Assert(err, IsNil) + s.NoError(err) // Switch branch to master, and verify that the new file was kept in staging. err = w.Checkout(&CheckoutOptions{ Keep: true, }) - c.Assert(err, IsNil) + s.NoError(err) fi, err := w.Filesystem.Stat("new-file.txt") - c.Assert(err, IsNil) - c.Assert(fi.Size(), Equals, int64(5)) + s.NoError(err) + s.Equal(int64(5), fi.Size()) } -func (s *WorktreeSuite) TestCheckoutSymlink(c *C) { +func (s *WorktreeSuite) TestCheckoutSymlink() { if runtime.GOOS == "windows" { - c.Skip("git doesn't support symlinks by default in windows") + s.T().Skip("git doesn't support symlinks by default in windows") } - dir, clean := s.TemporalDir() - defer clean() + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainInit(dir, false) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) w.Filesystem.Symlink("not-exists", "bar") w.Add("bar") @@ -470,37 +475,38 @@ func (s *WorktreeSuite) TestCheckoutSymlink(c *C) { w.Filesystem = osfs.New(filepath.Join(dir, "worktree-empty")) err = w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) + s.NoError(err) + s.True(status.IsClean()) target, err := w.Filesystem.Readlink("bar") - c.Assert(target, Equals, "not-exists") - c.Assert(err, IsNil) + s.Equal("not-exists", target) + s.NoError(err) } -func (s *WorktreeSuite) TestCheckoutSparse(c *C) { +func (s *WorktreeSuite) TestCheckoutSparse() { fs := memfs.New() r, err := Clone(memory.NewStorage(), fs, &CloneOptions{ - URL: s.GetBasicLocalRepositoryURL(), + URL: s.GetBasicLocalRepositoryURL(), + NoCheckout: true, }) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) sparseCheckoutDirectories := []string{"go", "json", "php"} - c.Assert(w.Checkout(&CheckoutOptions{ + s.NoError(w.Checkout(&CheckoutOptions{ SparseCheckoutDirectories: sparseCheckoutDirectories, - }), IsNil) + })) fis, err := fs.ReadDir("/") - c.Assert(err, IsNil) + s.NoError(err) for _, fi := range fis { - c.Assert(fi.IsDir(), Equals, true) + s.True(fi.IsDir()) var oneOfSparseCheckoutDirs bool for _, sparseCheckoutDirectory := range sparseCheckoutDirectories { @@ -508,130 +514,130 @@ func (s *WorktreeSuite) TestCheckoutSparse(c *C) { oneOfSparseCheckoutDirs = true } } - c.Assert(oneOfSparseCheckoutDirs, Equals, true) + s.True(oneOfSparseCheckoutDirs) } } -func (s *WorktreeSuite) TestFilenameNormalization(c *C) { +func (s *WorktreeSuite) TestFilenameNormalization() { if runtime.GOOS == "windows" { - c.Skip("windows paths may contain non utf-8 sequences") + s.T().Skip("windows paths may contain non utf-8 sequences") } - url, clean := s.TemporalDir() - defer clean() + url, err := os.MkdirTemp("", "") + s.NoError(err) path := fixtures.Basic().ByTag("worktree").One().Worktree().Root() server, err := PlainClone(url, false, &CloneOptions{ URL: path, }) - c.Assert(err, IsNil) + s.NoError(err) filename := "페" w, err := server.Worktree() - c.Assert(err, IsNil) + s.NoError(err) writeFile := func(path string) { - err := util.WriteFile(w.Filesystem, path, []byte("foo"), 0755) - c.Assert(err, IsNil) + err := util.WriteFile(w.Filesystem, path, []byte("foo"), 0o755) + s.NoError(err) } writeFile(filename) origHash, err := w.Add(filename) - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Commit("foo", &CommitOptions{Author: defaultSignature()}) - c.Assert(err, IsNil) + s.NoError(err) r, err := Clone(memory.NewStorage(), memfs.New(), &CloneOptions{ URL: url, }) - c.Assert(err, IsNil) + s.NoError(err) w, err = r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) + s.NoError(err) + s.True(status.IsClean()) err = w.Filesystem.Remove(filename) - c.Assert(err, IsNil) + s.NoError(err) modFilename := norm.NFKD.String(filename) writeFile(modFilename) _, err = w.Add(filename) - c.Assert(err, IsNil) + s.NoError(err) modHash, err := w.Add(modFilename) - c.Assert(err, IsNil) + s.NoError(err) // At this point we've got two files with the same content. // Hence their hashes must be the same. - c.Assert(origHash == modHash, Equals, true) + s.True(origHash == modHash) status, err = w.Status() - c.Assert(err, IsNil) + s.NoError(err) // However, their names are different and the work tree is still dirty. - c.Assert(status.IsClean(), Equals, false) + s.False(status.IsClean()) // Revert back the deletion of the first file. writeFile(filename) _, err = w.Add(filename) - c.Assert(err, IsNil) + s.NoError(err) status, err = w.Status() - c.Assert(err, IsNil) + s.NoError(err) // Still dirty - the second file is added. - c.Assert(status.IsClean(), Equals, false) + s.False(status.IsClean()) _, err = w.Remove(modFilename) - c.Assert(err, IsNil) + s.NoError(err) status, err = w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) + s.NoError(err) + s.True(status.IsClean()) } -func (s *WorktreeSuite) TestCheckoutSubmodule(c *C) { +func (s *WorktreeSuite) TestCheckoutSubmodule() { url := "https://github.com/git-fixtures/submodule.git" - r := s.NewRepositoryWithEmptyWorktree(fixtures.ByURL(url).One()) + r := NewRepositoryWithEmptyWorktree(fixtures.ByURL(url).One()) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) err = w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) + s.NoError(err) + s.True(status.IsClean()) } -func (s *WorktreeSuite) TestCheckoutSubmoduleInitialized(c *C) { +func (s *WorktreeSuite) TestCheckoutSubmoduleInitialized() { url := "https://github.com/git-fixtures/submodule.git" r := s.NewRepository(fixtures.ByURL(url).One()) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) sub, err := w.Submodules() - c.Assert(err, IsNil) + s.NoError(err) err = sub.Update(&SubmoduleUpdateOptions{Init: true}) - c.Assert(err, IsNil) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) + s.NoError(err) + s.True(status.IsClean()) } -func (s *WorktreeSuite) TestCheckoutRelativePathSubmoduleInitialized(c *C) { +func (s *WorktreeSuite) TestCheckoutRelativePathSubmoduleInitialized() { url := "https://github.com/git-fixtures/submodule.git" r := s.NewRepository(fixtures.ByURL(url).One()) // modify the .gitmodules from original one - file, err := r.wt.OpenFile(".gitmodules", os.O_WRONLY|os.O_TRUNC, 0666) - c.Assert(err, IsNil) + file, err := r.wt.OpenFile(".gitmodules", os.O_WRONLY|os.O_TRUNC, 0o666) + s.NoError(err) n, err := io.WriteString(file, `[submodule "basic"] path = basic @@ -639,50 +645,50 @@ func (s *WorktreeSuite) TestCheckoutRelativePathSubmoduleInitialized(c *C) { [submodule "itself"] path = itself url = ../submodule.git`) - c.Assert(err, IsNil) - c.Assert(n, Not(Equals), 0) + s.NoError(err) + s.NotEqual(0, n) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) w.Add(".gitmodules") w.Commit("test", &CommitOptions{}) // test submodule path modules, err := w.readGitmodulesFile() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(modules.Submodules["basic"].URL, Equals, "../basic.git") - c.Assert(modules.Submodules["itself"].URL, Equals, "../submodule.git") + s.Equal("../basic.git", modules.Submodules["basic"].URL) + s.Equal("../submodule.git", modules.Submodules["itself"].URL) basicSubmodule, err := w.Submodule("basic") - c.Assert(err, IsNil) + s.NoError(err) basicRepo, err := basicSubmodule.Repository() - c.Assert(err, IsNil) + s.NoError(err) basicRemotes, err := basicRepo.Remotes() - c.Assert(err, IsNil) - c.Assert(basicRemotes[0].Config().URLs[0], Equals, "https://github.com/git-fixtures/basic.git") + s.NoError(err) + s.Equal("https://github.com/git-fixtures/basic.git", basicRemotes[0].Config().URLs[0]) itselfSubmodule, err := w.Submodule("itself") - c.Assert(err, IsNil) + s.NoError(err) itselfRepo, err := itselfSubmodule.Repository() - c.Assert(err, IsNil) + s.NoError(err) itselfRemotes, err := itselfRepo.Remotes() - c.Assert(err, IsNil) - c.Assert(itselfRemotes[0].Config().URLs[0], Equals, "https://github.com/git-fixtures/submodule.git") + s.NoError(err) + s.Equal("https://github.com/git-fixtures/submodule.git", itselfRemotes[0].Config().URLs[0]) sub, err := w.Submodules() - c.Assert(err, IsNil) + s.NoError(err) err = sub.Update(&SubmoduleUpdateOptions{Init: true, RecurseSubmodules: DefaultSubmoduleRecursionDepth}) - c.Assert(err, IsNil) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) + s.NoError(err) + s.True(status.IsClean()) } -func (s *WorktreeSuite) TestCheckoutIndexMem(c *C) { +func (s *WorktreeSuite) TestCheckoutIndexMem() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -690,28 +696,27 @@ func (s *WorktreeSuite) TestCheckoutIndexMem(c *C) { } err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) idx, err := s.Repository.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) - c.Assert(idx.Entries[0].Hash.String(), Equals, "32858aad3c383ed1ff0a0f9bdf231d54a00c9e88") - c.Assert(idx.Entries[0].Name, Equals, ".gitignore") - c.Assert(idx.Entries[0].Mode, Equals, filemode.Regular) - c.Assert(idx.Entries[0].ModifiedAt.IsZero(), Equals, false) - c.Assert(idx.Entries[0].Size, Equals, uint32(189)) + s.NoError(err) + s.Len(idx.Entries, 9) + s.Equal("32858aad3c383ed1ff0a0f9bdf231d54a00c9e88", idx.Entries[0].Hash.String()) + s.Equal(".gitignore", idx.Entries[0].Name) + s.Equal(filemode.Regular, idx.Entries[0].Mode) + s.False(idx.Entries[0].ModifiedAt.IsZero()) + s.Equal(uint32(189), idx.Entries[0].Size) // ctime, dev, inode, uid and gid are not supported on memfs fs - c.Assert(idx.Entries[0].CreatedAt.IsZero(), Equals, true) - c.Assert(idx.Entries[0].Dev, Equals, uint32(0)) - c.Assert(idx.Entries[0].Inode, Equals, uint32(0)) - c.Assert(idx.Entries[0].UID, Equals, uint32(0)) - c.Assert(idx.Entries[0].GID, Equals, uint32(0)) + s.True(idx.Entries[0].CreatedAt.IsZero()) + s.Equal(uint32(0), idx.Entries[0].Dev) + s.Equal(uint32(0), idx.Entries[0].Inode) + s.Equal(uint32(0), idx.Entries[0].UID) + s.Equal(uint32(0), idx.Entries[0].GID) } -func (s *WorktreeSuite) TestCheckoutIndexOS(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *WorktreeSuite) TestCheckoutIndexOS() { + fs := s.TemporalFilesystem() w := &Worktree{ r: s.Repository, @@ -719,27 +724,27 @@ func (s *WorktreeSuite) TestCheckoutIndexOS(c *C) { } err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) idx, err := s.Repository.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) - c.Assert(idx.Entries[0].Hash.String(), Equals, "32858aad3c383ed1ff0a0f9bdf231d54a00c9e88") - c.Assert(idx.Entries[0].Name, Equals, ".gitignore") - c.Assert(idx.Entries[0].Mode, Equals, filemode.Regular) - c.Assert(idx.Entries[0].ModifiedAt.IsZero(), Equals, false) - c.Assert(idx.Entries[0].Size, Equals, uint32(189)) - - c.Assert(idx.Entries[0].CreatedAt.IsZero(), Equals, false) + s.NoError(err) + s.Len(idx.Entries, 9) + s.Equal("32858aad3c383ed1ff0a0f9bdf231d54a00c9e88", idx.Entries[0].Hash.String()) + s.Equal(".gitignore", idx.Entries[0].Name) + s.Equal(filemode.Regular, idx.Entries[0].Mode) + s.False(idx.Entries[0].ModifiedAt.IsZero()) + s.Equal(uint32(189), idx.Entries[0].Size) + + s.False(idx.Entries[0].CreatedAt.IsZero()) if runtime.GOOS != "windows" { - c.Assert(idx.Entries[0].Dev, Not(Equals), uint32(0)) - c.Assert(idx.Entries[0].Inode, Not(Equals), uint32(0)) - c.Assert(idx.Entries[0].UID, Not(Equals), uint32(0)) - c.Assert(idx.Entries[0].GID, Not(Equals), uint32(0)) + s.NotEqual(uint32(0), idx.Entries[0].Dev) + s.NotEqual(uint32(0), idx.Entries[0].Inode) + s.NotEqual(uint32(0), idx.Entries[0].UID) + s.NotEqual(uint32(0), idx.Entries[0].GID) } } -func (s *WorktreeSuite) TestCheckoutBranch(c *C) { +func (s *WorktreeSuite) TestCheckoutBranch() { w := &Worktree{ r: s.Repository, Filesystem: memfs.New(), @@ -748,18 +753,18 @@ func (s *WorktreeSuite) TestCheckoutBranch(c *C) { err := w.Checkout(&CheckoutOptions{ Branch: "refs/heads/branch", }) - c.Assert(err, IsNil) + s.NoError(err) head, err := w.r.Head() - c.Assert(err, IsNil) - c.Assert(head.Name().String(), Equals, "refs/heads/branch") + s.NoError(err) + s.Equal("refs/heads/branch", head.Name().String()) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) + s.NoError(err) + s.True(status.IsClean()) } -func (s *WorktreeSuite) TestCheckoutCreateWithHash(c *C) { +func (s *WorktreeSuite) TestCheckoutCreateWithHash() { w := &Worktree{ r: s.Repository, Filesystem: memfs.New(), @@ -770,19 +775,19 @@ func (s *WorktreeSuite) TestCheckoutCreateWithHash(c *C) { Branch: "refs/heads/foo", Hash: plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"), }) - c.Assert(err, IsNil) + s.NoError(err) head, err := w.r.Head() - c.Assert(err, IsNil) - c.Assert(head.Name().String(), Equals, "refs/heads/foo") - c.Assert(head.Hash(), Equals, plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9")) + s.NoError(err) + s.Equal("refs/heads/foo", head.Name().String()) + s.Equal(plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"), head.Hash()) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) + s.NoError(err) + s.True(status.IsClean()) } -func (s *WorktreeSuite) TestCheckoutCreate(c *C) { +func (s *WorktreeSuite) TestCheckoutCreate() { w := &Worktree{ r: s.Repository, Filesystem: memfs.New(), @@ -792,19 +797,19 @@ func (s *WorktreeSuite) TestCheckoutCreate(c *C) { Create: true, Branch: "refs/heads/foo", }) - c.Assert(err, IsNil) + s.NoError(err) head, err := w.r.Head() - c.Assert(err, IsNil) - c.Assert(head.Name().String(), Equals, "refs/heads/foo") - c.Assert(head.Hash(), Equals, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) + s.NoError(err) + s.Equal("refs/heads/foo", head.Name().String()) + s.Equal(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"), head.Hash()) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) + s.NoError(err) + s.True(status.IsClean()) } -func (s *WorktreeSuite) TestCheckoutBranchAndHash(c *C) { +func (s *WorktreeSuite) TestCheckoutBranchAndHash() { w := &Worktree{ r: s.Repository, Filesystem: memfs.New(), @@ -815,10 +820,10 @@ func (s *WorktreeSuite) TestCheckoutBranchAndHash(c *C) { Hash: plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"), }) - c.Assert(err, Equals, ErrBranchHashExclusive) + s.ErrorIs(err, ErrBranchHashExclusive) } -func (s *WorktreeSuite) TestCheckoutCreateMissingBranch(c *C) { +func (s *WorktreeSuite) TestCheckoutCreateMissingBranch() { w := &Worktree{ r: s.Repository, Filesystem: memfs.New(), @@ -828,10 +833,10 @@ func (s *WorktreeSuite) TestCheckoutCreateMissingBranch(c *C) { Create: true, }) - c.Assert(err, Equals, ErrCreateRequiresBranch) + s.ErrorIs(err, ErrCreateRequiresBranch) } -func (s *WorktreeSuite) TestCheckoutCreateInvalidBranch(c *C) { +func (s *WorktreeSuite) TestCheckoutCreateInvalidBranch() { w := &Worktree{ r: s.Repository, Filesystem: memfs.New(), @@ -851,52 +856,52 @@ func (s *WorktreeSuite) TestCheckoutCreateInvalidBranch(c *C) { Branch: name, }) - c.Assert(err, Equals, plumbing.ErrInvalidReferenceName) + s.ErrorIs(err, plumbing.ErrInvalidReferenceName) } } -func (s *WorktreeSuite) TestCheckoutTag(c *C) { +func (s *WorktreeSuite) TestCheckoutTag() { f := fixtures.ByTag("tags").One() - r := s.NewRepositoryWithEmptyWorktree(f) + r := NewRepositoryWithEmptyWorktree(f) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) err = w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) head, err := w.r.Head() - c.Assert(err, IsNil) - c.Assert(head.Name().String(), Equals, "refs/heads/master") + s.NoError(err) + s.Equal("refs/heads/master", head.Name().String()) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) + s.NoError(err) + s.True(status.IsClean()) err = w.Checkout(&CheckoutOptions{Branch: "refs/tags/lightweight-tag"}) - c.Assert(err, IsNil) + s.NoError(err) head, err = w.r.Head() - c.Assert(err, IsNil) - c.Assert(head.Name().String(), Equals, "HEAD") - c.Assert(head.Hash().String(), Equals, "f7b877701fbf855b44c0a9e86f3fdce2c298b07f") + s.NoError(err) + s.Equal("HEAD", head.Name().String()) + s.Equal("f7b877701fbf855b44c0a9e86f3fdce2c298b07f", head.Hash().String()) err = w.Checkout(&CheckoutOptions{Branch: "refs/tags/commit-tag"}) - c.Assert(err, IsNil) + s.NoError(err) head, err = w.r.Head() - c.Assert(err, IsNil) - c.Assert(head.Name().String(), Equals, "HEAD") - c.Assert(head.Hash().String(), Equals, "f7b877701fbf855b44c0a9e86f3fdce2c298b07f") + s.NoError(err) + s.Equal("HEAD", head.Name().String()) + s.Equal("f7b877701fbf855b44c0a9e86f3fdce2c298b07f", head.Hash().String()) err = w.Checkout(&CheckoutOptions{Branch: "refs/tags/tree-tag"}) - c.Assert(err, NotNil) + s.NotNil(err) head, err = w.r.Head() - c.Assert(err, IsNil) - c.Assert(head.Name().String(), Equals, "HEAD") + s.NoError(err) + s.Equal("HEAD", head.Name().String()) } -func (s *WorktreeSuite) TestCheckoutTagHash(c *C) { +func (s *WorktreeSuite) TestCheckoutTagHash() { f := fixtures.ByTag("tags").One() - r := s.NewRepositoryWithEmptyWorktree(f) + r := NewRepositoryWithEmptyWorktree(f) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) for _, hash := range []string{ "b742a2a9fa0afcfa9a6fad080980fbc26b007c69", // annotated tag @@ -906,14 +911,14 @@ func (s *WorktreeSuite) TestCheckoutTagHash(c *C) { err = w.Checkout(&CheckoutOptions{ Hash: plumbing.NewHash(hash), }) - c.Assert(err, IsNil) + s.NoError(err) head, err := w.r.Head() - c.Assert(err, IsNil) - c.Assert(head.Name().String(), Equals, "HEAD") + s.NoError(err) + s.Equal("HEAD", head.Name().String()) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) + s.NoError(err) + s.True(status.IsClean()) } for _, hash := range []string{ @@ -923,47 +928,47 @@ func (s *WorktreeSuite) TestCheckoutTagHash(c *C) { err = w.Checkout(&CheckoutOptions{ Hash: plumbing.NewHash(hash), }) - c.Assert(err, NotNil) + s.NotNil(err) } } -func (s *WorktreeSuite) TestCheckoutBisect(c *C) { +func (s *WorktreeSuite) TestCheckoutBisect() { if testing.Short() { - c.Skip("skipping test in short mode.") + s.T().Skip("skipping test in short mode.") } - s.testCheckoutBisect(c, "https://github.com/src-d/go-git.git") + s.testCheckoutBisect("https://github.com/src-d/go-git.git") } -func (s *WorktreeSuite) TestCheckoutBisectSubmodules(c *C) { - s.testCheckoutBisect(c, "https://github.com/git-fixtures/submodule.git") +func (s *WorktreeSuite) TestCheckoutBisectSubmodules() { + s.testCheckoutBisect("https://github.com/git-fixtures/submodule.git") } // TestCheckoutBisect simulates a git bisect going through the git history and // checking every commit over the previous commit -func (s *WorktreeSuite) testCheckoutBisect(c *C, url string) { +func (s *WorktreeSuite) testCheckoutBisect(url string) { f := fixtures.ByURL(url).One() - r := s.NewRepositoryWithEmptyWorktree(f) + r := NewRepositoryWithEmptyWorktree(f) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) iter, err := w.r.Log(&LogOptions{}) - c.Assert(err, IsNil) + s.NoError(err) iter.ForEach(func(commit *object.Commit) error { err := w.Checkout(&CheckoutOptions{Hash: commit.Hash}) - c.Assert(err, IsNil) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) + s.NoError(err) + s.True(status.IsClean()) return nil }) } -func (s *WorktreeSuite) TestStatus(c *C) { +func (s *WorktreeSuite) TestStatus() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -971,94 +976,94 @@ func (s *WorktreeSuite) TestStatus(c *C) { } status, err := w.Status() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(status.IsClean(), Equals, false) - c.Assert(status, HasLen, 9) + s.False(status.IsClean()) + s.Len(status, 9) } -func (s *WorktreeSuite) TestStatusEmpty(c *C) { +func (s *WorktreeSuite) TestStatusEmpty() { fs := memfs.New() storage := memory.NewStorage() r, err := Init(storage, fs) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) - c.Assert(status, NotNil) + s.NoError(err) + s.True(status.IsClean()) + s.NotNil(status) } -func (s *WorktreeSuite) TestStatusCheckedInBeforeIgnored(c *C) { +func (s *WorktreeSuite) TestStatusCheckedInBeforeIgnored() { fs := memfs.New() storage := memory.NewStorage() r, err := Init(storage, fs) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) - err = util.WriteFile(fs, "fileToIgnore", []byte("Initial data"), 0755) - c.Assert(err, IsNil) + err = util.WriteFile(fs, "fileToIgnore", []byte("Initial data"), 0o755) + s.NoError(err) _, err = w.Add("fileToIgnore") - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Commit("Added file that will be ignored later", defaultTestCommitOptions()) - c.Assert(err, IsNil) + s.NoError(err) - err = util.WriteFile(fs, ".gitignore", []byte("fileToIgnore\nsecondIgnoredFile"), 0755) - c.Assert(err, IsNil) + err = util.WriteFile(fs, ".gitignore", []byte("fileToIgnore\nsecondIgnoredFile"), 0o755) + s.NoError(err) _, err = w.Add(".gitignore") - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Commit("Added .gitignore", defaultTestCommitOptions()) - c.Assert(err, IsNil) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) - c.Assert(status, NotNil) + s.NoError(err) + s.True(status.IsClean()) + s.NotNil(status) - err = util.WriteFile(fs, "secondIgnoredFile", []byte("Should be completely ignored"), 0755) - c.Assert(err, IsNil) + err = util.WriteFile(fs, "secondIgnoredFile", []byte("Should be completely ignored"), 0o755) + s.NoError(err) status = nil status, err = w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) - c.Assert(status, NotNil) + s.NoError(err) + s.True(status.IsClean()) + s.NotNil(status) - err = util.WriteFile(fs, "fileToIgnore", []byte("Updated data"), 0755) - c.Assert(err, IsNil) + err = util.WriteFile(fs, "fileToIgnore", []byte("Updated data"), 0o755) + s.NoError(err) status = nil status, err = w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, false) - c.Assert(status, NotNil) + s.NoError(err) + s.False(status.IsClean()) + s.NotNil(status) } -func (s *WorktreeSuite) TestStatusEmptyDirty(c *C) { +func (s *WorktreeSuite) TestStatusEmptyDirty() { fs := memfs.New() - err := util.WriteFile(fs, "foo", []byte("foo"), 0755) - c.Assert(err, IsNil) + err := util.WriteFile(fs, "foo", []byte("foo"), 0o755) + s.NoError(err) storage := memory.NewStorage() r, err := Init(storage, fs) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, false) - c.Assert(status, HasLen, 1) + s.NoError(err) + s.False(status.IsClean()) + s.Len(status, 1) } -func (s *WorktreeSuite) TestStatusUnmodified(c *C) { +func (s *WorktreeSuite) TestStatusUnmodified() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1066,26 +1071,26 @@ func (s *WorktreeSuite) TestStatusUnmodified(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) status, err := w.StatusWithOptions(StatusOptions{Strategy: Preload}) - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) - c.Assert(status.IsUntracked("LICENSE"), Equals, false) + s.NoError(err) + s.True(status.IsClean()) + s.False(status.IsUntracked("LICENSE")) - c.Assert(status.File("LICENSE").Staging, Equals, Unmodified) - c.Assert(status.File("LICENSE").Worktree, Equals, Unmodified) + s.Equal(Unmodified, status.File("LICENSE").Staging) + s.Equal(Unmodified, status.File("LICENSE").Worktree) status, err = w.StatusWithOptions(StatusOptions{Strategy: Empty}) - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) - c.Assert(status.IsUntracked("LICENSE"), Equals, false) + s.NoError(err) + s.True(status.IsClean()) + s.False(status.IsUntracked("LICENSE")) - c.Assert(status.File("LICENSE").Staging, Equals, Untracked) - c.Assert(status.File("LICENSE").Worktree, Equals, Untracked) + s.Equal(Untracked, status.File("LICENSE").Staging) + s.Equal(Untracked, status.File("LICENSE").Worktree) } -func (s *WorktreeSuite) TestReset(c *C) { +func (s *WorktreeSuite) TestReset() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1095,25 +1100,25 @@ func (s *WorktreeSuite) TestReset(c *C) { commit := plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9") err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) branch, err := w.r.Reference(plumbing.Master, false) - c.Assert(err, IsNil) - c.Assert(branch.Hash(), Not(Equals), commit) + s.NoError(err) + s.NotEqual(commit, branch.Hash()) err = w.Reset(&ResetOptions{Mode: MergeReset, Commit: commit}) - c.Assert(err, IsNil) + s.NoError(err) branch, err = w.r.Reference(plumbing.Master, false) - c.Assert(err, IsNil) - c.Assert(branch.Hash(), Equals, commit) + s.NoError(err) + s.Equal(commit, branch.Hash()) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) + s.NoError(err) + s.True(status.IsClean()) } -func (s *WorktreeSuite) TestResetWithUntracked(c *C) { +func (s *WorktreeSuite) TestResetWithUntracked() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1123,20 +1128,20 @@ func (s *WorktreeSuite) TestResetWithUntracked(c *C) { commit := plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9") err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) - err = util.WriteFile(fs, "foo", nil, 0755) - c.Assert(err, IsNil) + err = util.WriteFile(fs, "foo", nil, 0o755) + s.NoError(err) err = w.Reset(&ResetOptions{Mode: MergeReset, Commit: commit}) - c.Assert(err, IsNil) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) + s.NoError(err) + s.True(status.IsClean()) } -func (s *WorktreeSuite) TestResetSoft(c *C) { +func (s *WorktreeSuite) TestResetSoft() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1146,22 +1151,22 @@ func (s *WorktreeSuite) TestResetSoft(c *C) { commit := plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9") err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) err = w.Reset(&ResetOptions{Mode: SoftReset, Commit: commit}) - c.Assert(err, IsNil) + s.NoError(err) branch, err := w.r.Reference(plumbing.Master, false) - c.Assert(err, IsNil) - c.Assert(branch.Hash(), Equals, commit) + s.NoError(err) + s.Equal(commit, branch.Hash()) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, false) - c.Assert(status.File("CHANGELOG").Staging, Equals, Added) + s.NoError(err) + s.False(status.IsClean()) + s.Equal(Added, status.File("CHANGELOG").Staging) } -func (s *WorktreeSuite) TestResetMixed(c *C) { +func (s *WorktreeSuite) TestResetMixed() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1171,22 +1176,22 @@ func (s *WorktreeSuite) TestResetMixed(c *C) { commit := plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9") err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) err = w.Reset(&ResetOptions{Mode: MixedReset, Commit: commit}) - c.Assert(err, IsNil) + s.NoError(err) branch, err := w.r.Reference(plumbing.Master, false) - c.Assert(err, IsNil) - c.Assert(branch.Hash(), Equals, commit) + s.NoError(err) + s.Equal(commit, branch.Hash()) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, false) - c.Assert(status.File("CHANGELOG").Staging, Equals, Untracked) + s.NoError(err) + s.False(status.IsClean()) + s.Equal(Untracked, status.File("CHANGELOG").Staging) } -func (s *WorktreeSuite) TestResetMerge(c *C) { +func (s *WorktreeSuite) TestResetMerge() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1197,31 +1202,31 @@ func (s *WorktreeSuite) TestResetMerge(c *C) { commitB := plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9") err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) err = w.Reset(&ResetOptions{Mode: MergeReset, Commit: commitA}) - c.Assert(err, IsNil) + s.NoError(err) branch, err := w.r.Reference(plumbing.Master, false) - c.Assert(err, IsNil) - c.Assert(branch.Hash(), Equals, commitA) + s.NoError(err) + s.Equal(commitA, branch.Hash()) f, err := fs.Create(".gitignore") - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("foo")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) err = w.Reset(&ResetOptions{Mode: MergeReset, Commit: commitB}) - c.Assert(err, Equals, ErrUnstagedChanges) + s.ErrorIs(err, ErrUnstagedChanges) branch, err = w.r.Reference(plumbing.Master, false) - c.Assert(err, IsNil) - c.Assert(branch.Hash(), Equals, commitA) + s.NoError(err) + s.Equal(commitA, branch.Hash()) } -func (s *WorktreeSuite) TestResetHard(c *C) { +func (s *WorktreeSuite) TestResetHard() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1231,24 +1236,62 @@ func (s *WorktreeSuite) TestResetHard(c *C) { commit := plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9") err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) f, err := fs.Create(".gitignore") - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("foo")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) err = w.Reset(&ResetOptions{Mode: HardReset, Commit: commit}) - c.Assert(err, IsNil) + s.NoError(err) branch, err := w.r.Reference(plumbing.Master, false) - c.Assert(err, IsNil) - c.Assert(branch.Hash(), Equals, commit) + s.NoError(err) + s.Equal(commit, branch.Hash()) +} + +func (s *WorktreeSuite) TestResetHardSubFolders() { + fs := memfs.New() + w := &Worktree{ + r: s.Repository, + Filesystem: fs, + } + + err := w.Checkout(&CheckoutOptions{}) + s.NoError(err) + + err = fs.MkdirAll("dir", os.ModePerm) + s.NoError(err) + tf, err := fs.Create("dir/testfile.txt") + s.NoError(err) + _, err = tf.Write([]byte("testfile content")) + s.NoError(err) + err = tf.Close() + s.NoError(err) + _, err = w.Add("dir/testfile.txt") + s.NoError(err) + _, err = w.Commit("testcommit", &CommitOptions{Author: &object.Signature{Name: "name", Email: "email"}}) + s.NoError(err) + + err = fs.Remove("dir/testfile.txt") + s.NoError(err) + + status, err := w.Status() + s.NoError(err) + s.False(status.IsClean()) + + err = w.Reset(&ResetOptions{Files: []string{"./dir/testfile.txt"}, Mode: HardReset}) + s.NoError(err) + + status, err = w.Status() + s.NoError(err) + s.True(status.IsClean()) } -func (s *WorktreeSuite) TestResetHardWithGitIgnore(c *C) { +func (s *WorktreeSuite) TestResetHardWithGitIgnore() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1256,43 +1299,66 @@ func (s *WorktreeSuite) TestResetHardWithGitIgnore(c *C) { } err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) tf, err := fs.Create("newTestFile.txt") - c.Assert(err, IsNil) + s.NoError(err) _, err = tf.Write([]byte("testfile content")) - c.Assert(err, IsNil) + s.NoError(err) err = tf.Close() - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Add("newTestFile.txt") - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Commit("testcommit", &CommitOptions{Author: &object.Signature{Name: "name", Email: "email"}}) - c.Assert(err, IsNil) + s.NoError(err) err = fs.Remove("newTestFile.txt") - c.Assert(err, IsNil) + s.NoError(err) f, err := fs.Create(".gitignore") - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("foo\n")) - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("newTestFile.txt\n")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, false) + s.NoError(err) + s.False(status.IsClean()) err = w.Reset(&ResetOptions{Mode: HardReset}) - c.Assert(err, IsNil) + s.NoError(err) status, err = w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) + s.NoError(err) + s.True(status.IsClean()) +} + +func (s *WorktreeSuite) TestResetSparsely() { + fs := memfs.New() + w := &Worktree{ + r: s.Repository, + Filesystem: fs, + } + + sparseResetDirs := []string{"php"} + + err := w.ResetSparsely(&ResetOptions{Mode: HardReset}, sparseResetDirs) + s.NoError(err) + + files, err := fs.ReadDir("/") + s.NoError(err) + s.Len(files, 1) + s.Equal("php", files[0].Name()) + + files, err = fs.ReadDir("/php") + s.NoError(err) + s.Len(files, 1) + s.Equal("crappy.php", files[0].Name()) } -func (s *WorktreeSuite) TestStatusAfterCheckout(c *C) { +func (s *WorktreeSuite) TestStatusAfterCheckout() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1300,17 +1366,15 @@ func (s *WorktreeSuite) TestStatusAfterCheckout(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, true) - + s.NoError(err) + s.True(status.IsClean()) } -func (s *WorktreeSuite) TestStatusModified(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *WorktreeSuite) TestStatusModified() { + fs := s.TemporalFilesystem() w := &Worktree{ r: s.Repository, @@ -1318,22 +1382,22 @@ func (s *WorktreeSuite) TestStatusModified(c *C) { } err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) f, err := fs.Create(".gitignore") - c.Assert(err, IsNil) + s.NoError(err) _, err = f.Write([]byte("foo")) - c.Assert(err, IsNil) + s.NoError(err) err = f.Close() - c.Assert(err, IsNil) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, false) - c.Assert(status.File(".gitignore").Worktree, Equals, Modified) + s.NoError(err) + s.False(status.IsClean()) + s.Equal(Modified, status.File(".gitignore").Worktree) } -func (s *WorktreeSuite) TestStatusIgnored(c *C) { +func (s *WorktreeSuite) TestStatusIgnored() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1353,13 +1417,13 @@ func (s *WorktreeSuite) TestStatusIgnored(c *C) { f.Close() status, _ := w.Status() - c.Assert(len(status), Equals, 3) + s.Len(status, 3) _, ok := status["another/file"] - c.Assert(ok, Equals, true) + s.True(ok) _, ok = status["vendor/github.com/file"] - c.Assert(ok, Equals, true) + s.True(ok) _, ok = status["vendor/gopkg.in/file"] - c.Assert(ok, Equals, true) + s.True(ok) f, _ = fs.Create(".gitignore") f.Write([]byte("vendor/g*/")) @@ -1369,18 +1433,18 @@ func (s *WorktreeSuite) TestStatusIgnored(c *C) { f.Close() status, _ = w.Status() - c.Assert(len(status), Equals, 4) + s.Len(status, 4) _, ok = status[".gitignore"] - c.Assert(ok, Equals, true) + s.True(ok) _, ok = status["another/file"] - c.Assert(ok, Equals, true) + s.True(ok) _, ok = status["vendor/.gitignore"] - c.Assert(ok, Equals, true) + s.True(ok) _, ok = status["vendor/github.com/file"] - c.Assert(ok, Equals, true) + s.True(ok) } -func (s *WorktreeSuite) TestStatusUntracked(c *C) { +func (s *WorktreeSuite) TestStatusUntracked() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1388,21 +1452,20 @@ func (s *WorktreeSuite) TestStatusUntracked(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) f, err := w.Filesystem.Create("foo") - c.Assert(err, IsNil) - c.Assert(f.Close(), IsNil) + s.NoError(err) + s.Nil(f.Close()) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.File("foo").Staging, Equals, Untracked) - c.Assert(status.File("foo").Worktree, Equals, Untracked) + s.NoError(err) + s.Equal(Untracked, status.File("foo").Staging) + s.Equal(Untracked, status.File("foo").Worktree) } -func (s *WorktreeSuite) TestStatusDeleted(c *C) { - fs, clean := s.TemporalFilesystem() - defer clean() +func (s *WorktreeSuite) TestStatusDeleted() { + fs := s.TemporalFilesystem() w := &Worktree{ r: s.Repository, @@ -1410,46 +1473,46 @@ func (s *WorktreeSuite) TestStatusDeleted(c *C) { } err := w.Checkout(&CheckoutOptions{}) - c.Assert(err, IsNil) + s.NoError(err) err = fs.Remove(".gitignore") - c.Assert(err, IsNil) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status.IsClean(), Equals, false) - c.Assert(status.File(".gitignore").Worktree, Equals, Deleted) + s.NoError(err) + s.False(status.IsClean()) + s.Equal(Deleted, status.File(".gitignore").Worktree) } -func (s *WorktreeSuite) TestSubmodule(c *C) { +func (s *WorktreeSuite) TestSubmodule() { path := fixtures.ByTag("submodule").One().Worktree().Root() r, err := PlainOpen(path) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) m, err := w.Submodule("basic") - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(m.Config().Name, Equals, "basic") + s.Equal("basic", m.Config().Name) } -func (s *WorktreeSuite) TestSubmodules(c *C) { +func (s *WorktreeSuite) TestSubmodules() { path := fixtures.ByTag("submodule").One().Worktree().Root() r, err := PlainOpen(path) - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) l, err := w.Submodules() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(l, HasLen, 2) + s.Len(l, 2) } -func (s *WorktreeSuite) TestAddUntracked(c *C) { +func (s *WorktreeSuite) TestAddUntracked() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1457,43 +1520,43 @@ func (s *WorktreeSuite) TestAddUntracked(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) idx, err := w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) + s.NoError(err) + s.Len(idx.Entries, 9) err = util.WriteFile(w.Filesystem, "foo", []byte("FOO"), 0755) - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Add("foo") - c.Assert(hash.String(), Equals, "d96c7efbfec2814ae0301ad054dc8d9fc416c9b5") - c.Assert(err, IsNil) + s.Equal("d96c7efbfec2814ae0301ad054dc8d9fc416c9b5", hash.String()) + s.NoError(err) idx, err = w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 10) + s.NoError(err) + s.Len(idx.Entries, 10) e, err := idx.Entry("foo") - c.Assert(err, IsNil) - c.Assert(e.Hash, Equals, hash) - c.Assert(e.Mode, Equals, filemode.Executable) + s.NoError(err) + s.Equal(hash, e.Hash) + s.Equal(filemode.Executable, e.Mode) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 1) + s.NoError(err) + s.Len(status, 1) file := status.File("foo") - c.Assert(file.Staging, Equals, Added) - c.Assert(file.Worktree, Equals, Unmodified) + s.Equal(Added, file.Staging) + s.Equal(Unmodified, file.Worktree) obj, err := w.r.Storer.EncodedObject(plumbing.BlobObject, hash) - c.Assert(err, IsNil) - c.Assert(obj, NotNil) - c.Assert(obj.Size(), Equals, int64(3)) + s.NoError(err) + s.NotNil(obj) + s.Equal(int64(3), obj.Size()) } -func (s *WorktreeSuite) TestIgnored(c *C) { +func (s *WorktreeSuite) TestIgnored() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1504,25 +1567,25 @@ func (s *WorktreeSuite) TestIgnored(c *C) { w.Excludes = append(w.Excludes, gitignore.ParsePattern("foo", nil)) err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) idx, err := w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) + s.NoError(err) + s.Len(idx.Entries, 9) - err = util.WriteFile(w.Filesystem, "foo", []byte("FOO"), 0755) - c.Assert(err, IsNil) + err = util.WriteFile(w.Filesystem, "foo", []byte("FOO"), 0o755) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 0) + s.NoError(err) + s.Len(status, 0) file := status.File("foo") - c.Assert(file.Staging, Equals, Untracked) - c.Assert(file.Worktree, Equals, Untracked) + s.Equal(Untracked, file.Staging) + s.Equal(Untracked, file.Worktree) } -func (s *WorktreeSuite) TestExcludedNoGitignore(c *C) { +func (s *WorktreeSuite) TestExcludedNoGitignore() { f := fixtures.ByTag("empty").One() r := s.NewRepository(f) @@ -1533,24 +1596,24 @@ func (s *WorktreeSuite) TestExcludedNoGitignore(c *C) { } _, err := fs.Open(".gitignore") - c.Assert(err, Equals, os.ErrNotExist) + s.ErrorIs(err, os.ErrNotExist) w.Excludes = make([]gitignore.Pattern, 0) w.Excludes = append(w.Excludes, gitignore.ParsePattern("foo", nil)) - err = util.WriteFile(w.Filesystem, "foo", []byte("FOO"), 0755) - c.Assert(err, IsNil) + err = util.WriteFile(w.Filesystem, "foo", []byte("FOO"), 0o755) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 0) + s.NoError(err) + s.Len(status, 0) file := status.File("foo") - c.Assert(file.Staging, Equals, Untracked) - c.Assert(file.Worktree, Equals, Untracked) + s.Equal(Untracked, file.Staging) + s.Equal(Untracked, file.Worktree) } -func (s *WorktreeSuite) TestAddModified(c *C) { +func (s *WorktreeSuite) TestAddModified() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1558,38 +1621,38 @@ func (s *WorktreeSuite) TestAddModified(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) idx, err := w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) + s.NoError(err) + s.Len(idx.Entries, 9) - err = util.WriteFile(w.Filesystem, "LICENSE", []byte("FOO"), 0644) - c.Assert(err, IsNil) + err = util.WriteFile(w.Filesystem, "LICENSE", []byte("FOO"), 0o644) + s.NoError(err) hash, err := w.Add("LICENSE") - c.Assert(err, IsNil) - c.Assert(hash.String(), Equals, "d96c7efbfec2814ae0301ad054dc8d9fc416c9b5") + s.NoError(err) + s.Equal("d96c7efbfec2814ae0301ad054dc8d9fc416c9b5", hash.String()) idx, err = w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) + s.NoError(err) + s.Len(idx.Entries, 9) e, err := idx.Entry("LICENSE") - c.Assert(err, IsNil) - c.Assert(e.Hash, Equals, hash) - c.Assert(e.Mode, Equals, filemode.Regular) + s.NoError(err) + s.Equal(hash, e.Hash) + s.Equal(filemode.Regular, e.Mode) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 1) + s.NoError(err) + s.Len(status, 1) file := status.File("LICENSE") - c.Assert(file.Staging, Equals, Modified) - c.Assert(file.Worktree, Equals, Unmodified) + s.Equal(Modified, file.Staging) + s.Equal(Unmodified, file.Worktree) } -func (s *WorktreeSuite) TestAddUnmodified(c *C) { +func (s *WorktreeSuite) TestAddUnmodified() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1597,14 +1660,14 @@ func (s *WorktreeSuite) TestAddUnmodified(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Add("LICENSE") - c.Assert(hash.String(), Equals, "c192bd6a24ea1ab01d78686e417c8bdc7c3d197f") - c.Assert(err, IsNil) + s.Equal("c192bd6a24ea1ab01d78686e417c8bdc7c3d197f", hash.String()) + s.NoError(err) } -func (s *WorktreeSuite) TestAddRemoved(c *C) { +func (s *WorktreeSuite) TestAddRemoved() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1612,33 +1675,33 @@ func (s *WorktreeSuite) TestAddRemoved(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) idx, err := w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) + s.NoError(err) + s.Len(idx.Entries, 9) err = w.Filesystem.Remove("LICENSE") - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Add("LICENSE") - c.Assert(err, IsNil) - c.Assert(hash.String(), Equals, "c192bd6a24ea1ab01d78686e417c8bdc7c3d197f") + s.NoError(err) + s.Equal("c192bd6a24ea1ab01d78686e417c8bdc7c3d197f", hash.String()) e, err := idx.Entry("LICENSE") - c.Assert(err, IsNil) - c.Assert(e.Hash, Equals, hash) - c.Assert(e.Mode, Equals, filemode.Regular) + s.NoError(err) + s.Equal(hash, e.Hash) + s.Equal(filemode.Regular, e.Mode) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 1) + s.NoError(err) + s.Len(status, 1) file := status.File("LICENSE") - c.Assert(file.Staging, Equals, Deleted) + s.Equal(Deleted, file.Staging) } -func (s *WorktreeSuite) TestAddRemovedInDirectory(c *C) { +func (s *WorktreeSuite) TestAddRemovedInDirectory() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1646,44 +1709,44 @@ func (s *WorktreeSuite) TestAddRemovedInDirectory(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) idx, err := w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) + s.NoError(err) + s.Len(idx.Entries, 9) err = w.Filesystem.Remove("go/example.go") - c.Assert(err, IsNil) + s.NoError(err) err = w.Filesystem.Remove("json/short.json") - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Add("go") - c.Assert(err, IsNil) - c.Assert(hash.IsZero(), Equals, true) + s.NoError(err) + s.True(hash.IsZero()) e, err := idx.Entry("go/example.go") - c.Assert(err, IsNil) - c.Assert(e.Hash, Equals, plumbing.NewHash("880cd14280f4b9b6ed3986d6671f907d7cc2a198")) - c.Assert(e.Mode, Equals, filemode.Regular) + s.NoError(err) + s.Equal(plumbing.NewHash("880cd14280f4b9b6ed3986d6671f907d7cc2a198"), e.Hash) + s.Equal(filemode.Regular, e.Mode) e, err = idx.Entry("json/short.json") - c.Assert(err, IsNil) - c.Assert(e.Hash, Equals, plumbing.NewHash("c8f1d8c61f9da76f4cb49fd86322b6e685dba956")) - c.Assert(e.Mode, Equals, filemode.Regular) + s.NoError(err) + s.Equal(plumbing.NewHash("c8f1d8c61f9da76f4cb49fd86322b6e685dba956"), e.Hash) + s.Equal(filemode.Regular, e.Mode) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 2) + s.NoError(err) + s.Len(status, 2) file := status.File("go/example.go") - c.Assert(file.Staging, Equals, Deleted) + s.Equal(Deleted, file.Staging) file = status.File("json/short.json") - c.Assert(file.Staging, Equals, Unmodified) + s.Equal(Unmodified, file.Staging) } -func (s *WorktreeSuite) TestAddRemovedInDirectoryWithTrailingSlash(c *C) { +func (s *WorktreeSuite) TestAddRemovedInDirectoryWithTrailingSlash() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1691,44 +1754,44 @@ func (s *WorktreeSuite) TestAddRemovedInDirectoryWithTrailingSlash(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) idx, err := w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) + s.NoError(err) + s.Len(idx.Entries, 9) err = w.Filesystem.Remove("go/example.go") - c.Assert(err, IsNil) + s.NoError(err) err = w.Filesystem.Remove("json/short.json") - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Add("go/") - c.Assert(err, IsNil) - c.Assert(hash.IsZero(), Equals, true) + s.NoError(err) + s.True(hash.IsZero()) e, err := idx.Entry("go/example.go") - c.Assert(err, IsNil) - c.Assert(e.Hash, Equals, plumbing.NewHash("880cd14280f4b9b6ed3986d6671f907d7cc2a198")) - c.Assert(e.Mode, Equals, filemode.Regular) + s.NoError(err) + s.Equal(plumbing.NewHash("880cd14280f4b9b6ed3986d6671f907d7cc2a198"), e.Hash) + s.Equal(filemode.Regular, e.Mode) e, err = idx.Entry("json/short.json") - c.Assert(err, IsNil) - c.Assert(e.Hash, Equals, plumbing.NewHash("c8f1d8c61f9da76f4cb49fd86322b6e685dba956")) - c.Assert(e.Mode, Equals, filemode.Regular) + s.NoError(err) + s.Equal(plumbing.NewHash("c8f1d8c61f9da76f4cb49fd86322b6e685dba956"), e.Hash) + s.Equal(filemode.Regular, e.Mode) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 2) + s.NoError(err) + s.Len(status, 2) file := status.File("go/example.go") - c.Assert(file.Staging, Equals, Deleted) + s.Equal(Deleted, file.Staging) file = status.File("json/short.json") - c.Assert(file.Staging, Equals, Unmodified) + s.Equal(Unmodified, file.Staging) } -func (s *WorktreeSuite) TestAddRemovedInDirectoryDot(c *C) { +func (s *WorktreeSuite) TestAddRemovedInDirectoryDot() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1736,71 +1799,71 @@ func (s *WorktreeSuite) TestAddRemovedInDirectoryDot(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) idx, err := w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) + s.NoError(err) + s.Len(idx.Entries, 9) err = w.Filesystem.Remove("go/example.go") - c.Assert(err, IsNil) + s.NoError(err) err = w.Filesystem.Remove("json/short.json") - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Add(".") - c.Assert(err, IsNil) - c.Assert(hash.IsZero(), Equals, true) + s.NoError(err) + s.True(hash.IsZero()) e, err := idx.Entry("go/example.go") - c.Assert(err, IsNil) - c.Assert(e.Hash, Equals, plumbing.NewHash("880cd14280f4b9b6ed3986d6671f907d7cc2a198")) - c.Assert(e.Mode, Equals, filemode.Regular) + s.NoError(err) + s.Equal(plumbing.NewHash("880cd14280f4b9b6ed3986d6671f907d7cc2a198"), e.Hash) + s.Equal(filemode.Regular, e.Mode) e, err = idx.Entry("json/short.json") - c.Assert(err, IsNil) - c.Assert(e.Hash, Equals, plumbing.NewHash("c8f1d8c61f9da76f4cb49fd86322b6e685dba956")) - c.Assert(e.Mode, Equals, filemode.Regular) + s.NoError(err) + s.Equal(plumbing.NewHash("c8f1d8c61f9da76f4cb49fd86322b6e685dba956"), e.Hash) + s.Equal(filemode.Regular, e.Mode) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 2) + s.NoError(err) + s.Len(status, 2) file := status.File("go/example.go") - c.Assert(file.Staging, Equals, Deleted) + s.Equal(Deleted, file.Staging) file = status.File("json/short.json") - c.Assert(file.Staging, Equals, Deleted) + s.Equal(Deleted, file.Staging) } -func (s *WorktreeSuite) TestAddSymlink(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *WorktreeSuite) TestAddSymlink() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainInit(dir, false) - c.Assert(err, IsNil) - err = util.WriteFile(r.wt, "foo", []byte("qux"), 0644) - c.Assert(err, IsNil) + s.NoError(err) + err = util.WriteFile(r.wt, "foo", []byte("qux"), 0o644) + s.NoError(err) err = r.wt.Symlink("foo", "bar") - c.Assert(err, IsNil) + s.NoError(err) w, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) h, err := w.Add("foo") - c.Assert(err, IsNil) - c.Assert(h, Not(Equals), plumbing.NewHash("19102815663d23f8b75a47e7a01965dcdc96468c")) + s.NoError(err) + s.NotEqual(plumbing.NewHash("19102815663d23f8b75a47e7a01965dcdc96468c"), h) h, err = w.Add("bar") - c.Assert(err, IsNil) - c.Assert(h, Equals, plumbing.NewHash("19102815663d23f8b75a47e7a01965dcdc96468c")) + s.NoError(err) + s.Equal(plumbing.NewHash("19102815663d23f8b75a47e7a01965dcdc96468c"), h) obj, err := w.r.Storer.EncodedObject(plumbing.BlobObject, h) - c.Assert(err, IsNil) - c.Assert(obj, NotNil) - c.Assert(obj.Size(), Equals, int64(3)) + s.NoError(err) + s.NotNil(obj) + s.Equal(int64(3), obj.Size()) } -func (s *WorktreeSuite) TestAddDirectory(c *C) { +func (s *WorktreeSuite) TestAddDirectory() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1808,56 +1871,56 @@ func (s *WorktreeSuite) TestAddDirectory(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) idx, err := w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) + s.NoError(err) + s.Len(idx.Entries, 9) - err = util.WriteFile(w.Filesystem, "qux/foo", []byte("FOO"), 0755) - c.Assert(err, IsNil) - err = util.WriteFile(w.Filesystem, "qux/baz/bar", []byte("BAR"), 0755) - c.Assert(err, IsNil) + err = util.WriteFile(w.Filesystem, "qux/foo", []byte("FOO"), 0o755) + s.NoError(err) + err = util.WriteFile(w.Filesystem, "qux/baz/bar", []byte("BAR"), 0o755) + s.NoError(err) h, err := w.Add("qux") - c.Assert(err, IsNil) - c.Assert(h.IsZero(), Equals, true) + s.NoError(err) + s.True(h.IsZero()) idx, err = w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 11) + s.NoError(err) + s.Len(idx.Entries, 11) e, err := idx.Entry("qux/foo") - c.Assert(err, IsNil) - c.Assert(e.Mode, Equals, filemode.Executable) + s.NoError(err) + s.Equal(filemode.Executable, e.Mode) e, err = idx.Entry("qux/baz/bar") - c.Assert(err, IsNil) - c.Assert(e.Mode, Equals, filemode.Executable) + s.NoError(err) + s.Equal(filemode.Executable, e.Mode) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 2) + s.NoError(err) + s.Len(status, 2) file := status.File("qux/foo") - c.Assert(file.Staging, Equals, Added) - c.Assert(file.Worktree, Equals, Unmodified) + s.Equal(Added, file.Staging) + s.Equal(Unmodified, file.Worktree) file = status.File("qux/baz/bar") - c.Assert(file.Staging, Equals, Added) - c.Assert(file.Worktree, Equals, Unmodified) + s.Equal(Added, file.Staging) + s.Equal(Unmodified, file.Worktree) } -func (s *WorktreeSuite) TestAddDirectoryErrorNotFound(c *C) { +func (s *WorktreeSuite) TestAddDirectoryErrorNotFound() { r, _ := Init(memory.NewStorage(), memfs.New()) w, _ := r.Worktree() h, err := w.Add("foo") - c.Assert(err, NotNil) - c.Assert(h.IsZero(), Equals, true) + s.NotNil(err) + s.True(h.IsZero()) } -func (s *WorktreeSuite) TestAddAll(c *C) { +func (s *WorktreeSuite) TestAddAll() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1865,45 +1928,45 @@ func (s *WorktreeSuite) TestAddAll(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) idx, err := w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) + s.NoError(err) + s.Len(idx.Entries, 9) - err = util.WriteFile(w.Filesystem, "file1", []byte("file1"), 0644) - c.Assert(err, IsNil) + err = util.WriteFile(w.Filesystem, "file1", []byte("file1"), 0o644) + s.NoError(err) - err = util.WriteFile(w.Filesystem, "file2", []byte("file2"), 0644) - c.Assert(err, IsNil) + err = util.WriteFile(w.Filesystem, "file2", []byte("file2"), 0o644) + s.NoError(err) - err = util.WriteFile(w.Filesystem, "file3", []byte("ignore me"), 0644) - c.Assert(err, IsNil) + err = util.WriteFile(w.Filesystem, "file3", []byte("ignore me"), 0o644) + s.NoError(err) w.Excludes = make([]gitignore.Pattern, 0) w.Excludes = append(w.Excludes, gitignore.ParsePattern("file3", nil)) err = w.AddWithOptions(&AddOptions{All: true}) - c.Assert(err, IsNil) + s.NoError(err) idx, err = w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 11) + s.NoError(err) + s.Len(idx.Entries, 11) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 2) + s.NoError(err) + s.Len(status, 2) file1 := status.File("file1") - c.Assert(file1.Staging, Equals, Added) + s.Equal(Added, file1.Staging) file2 := status.File("file2") - c.Assert(file2.Staging, Equals, Added) + s.Equal(Added, file2.Staging) file3 := status.File("file3") - c.Assert(file3.Staging, Equals, Untracked) - c.Assert(file3.Worktree, Equals, Untracked) + s.Equal(Untracked, file3.Staging) + s.Equal(Untracked, file3.Worktree) } -func (s *WorktreeSuite) TestAddGlob(c *C) { +func (s *WorktreeSuite) TestAddGlob() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1911,60 +1974,119 @@ func (s *WorktreeSuite) TestAddGlob(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) idx, err := w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) + s.NoError(err) + s.Len(idx.Entries, 9) - err = util.WriteFile(w.Filesystem, "qux/qux", []byte("QUX"), 0755) - c.Assert(err, IsNil) - err = util.WriteFile(w.Filesystem, "qux/baz", []byte("BAZ"), 0755) - c.Assert(err, IsNil) - err = util.WriteFile(w.Filesystem, "qux/bar/baz", []byte("BAZ"), 0755) - c.Assert(err, IsNil) + err = util.WriteFile(w.Filesystem, "qux/qux", []byte("QUX"), 0o755) + s.NoError(err) + err = util.WriteFile(w.Filesystem, "qux/baz", []byte("BAZ"), 0o755) + s.NoError(err) + err = util.WriteFile(w.Filesystem, "qux/bar/baz", []byte("BAZ"), 0o755) + s.NoError(err) err = w.AddWithOptions(&AddOptions{Glob: w.Filesystem.Join("qux", "b*")}) - c.Assert(err, IsNil) + s.NoError(err) idx, err = w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 11) + s.NoError(err) + s.Len(idx.Entries, 11) e, err := idx.Entry("qux/baz") - c.Assert(err, IsNil) - c.Assert(e.Mode, Equals, filemode.Executable) + s.NoError(err) + s.Equal(filemode.Executable, e.Mode) e, err = idx.Entry("qux/bar/baz") - c.Assert(err, IsNil) - c.Assert(e.Mode, Equals, filemode.Executable) + s.NoError(err) + s.Equal(filemode.Executable, e.Mode) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 3) + s.NoError(err) + s.Len(status, 3) file := status.File("qux/qux") - c.Assert(file.Staging, Equals, Untracked) - c.Assert(file.Worktree, Equals, Untracked) + s.Equal(Untracked, file.Staging) + s.Equal(Untracked, file.Worktree) file = status.File("qux/baz") - c.Assert(file.Staging, Equals, Added) - c.Assert(file.Worktree, Equals, Unmodified) + s.Equal(Added, file.Staging) + s.Equal(Unmodified, file.Worktree) file = status.File("qux/bar/baz") - c.Assert(file.Staging, Equals, Added) - c.Assert(file.Worktree, Equals, Unmodified) + s.Equal(Added, file.Staging) + s.Equal(Unmodified, file.Worktree) +} + +func (s *WorktreeSuite) TestAddFilenameStartingWithDot() { + fs := memfs.New() + w := &Worktree{ + r: s.Repository, + Filesystem: fs, + } + + err := w.Checkout(&CheckoutOptions{Force: true}) + s.NoError(err) + + idx, err := w.r.Storer.Index() + s.NoError(err) + s.Len(idx.Entries, 9) + + err = util.WriteFile(w.Filesystem, "qux", []byte("QUX"), 0o755) + s.NoError(err) + err = util.WriteFile(w.Filesystem, "baz", []byte("BAZ"), 0o755) + s.NoError(err) + err = util.WriteFile(w.Filesystem, "foo/bar/baz", []byte("BAZ"), 0o755) + s.NoError(err) + + _, err = w.Add("./qux") + s.NoError(err) + + _, err = w.Add("./baz") + s.NoError(err) + + _, err = w.Add("foo/bar/../bar/./baz") + s.NoError(err) + + idx, err = w.r.Storer.Index() + s.NoError(err) + s.Len(idx.Entries, 12) + + e, err := idx.Entry("qux") + s.NoError(err) + s.Equal(filemode.Executable, e.Mode) + + e, err = idx.Entry("baz") + s.NoError(err) + s.Equal(filemode.Executable, e.Mode) + + status, err := w.Status() + s.NoError(err) + s.Len(status, 3) + + file := status.File("qux") + s.Equal(Added, file.Staging) + s.Equal(Unmodified, file.Worktree) + + file = status.File("baz") + s.Equal(Added, file.Staging) + s.Equal(Unmodified, file.Worktree) + + file = status.File("foo/bar/baz") + s.Equal(Added, file.Staging) + s.Equal(Unmodified, file.Worktree) } -func (s *WorktreeSuite) TestAddGlobErrorNoMatches(c *C) { +func (s *WorktreeSuite) TestAddGlobErrorNoMatches() { r, _ := Init(memory.NewStorage(), memfs.New()) w, _ := r.Worktree() err := w.AddGlob("foo") - c.Assert(err, Equals, ErrGlobNoMatches) + s.ErrorIs(err, ErrGlobNoMatches) } -func (s *WorktreeSuite) TestAddSkipStatusAddedPath(c *C) { +func (s *WorktreeSuite) TestAddSkipStatusAddedPath() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -1972,36 +2094,36 @@ func (s *WorktreeSuite) TestAddSkipStatusAddedPath(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) idx, err := w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) + s.NoError(err) + s.Len(idx.Entries, 9) - err = util.WriteFile(w.Filesystem, "file1", []byte("file1"), 0644) - c.Assert(err, IsNil) + err = util.WriteFile(w.Filesystem, "file1", []byte("file1"), 0o644) + s.NoError(err) err = w.AddWithOptions(&AddOptions{Path: "file1", SkipStatus: true}) - c.Assert(err, IsNil) + s.NoError(err) idx, err = w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 10) + s.NoError(err) + s.Len(idx.Entries, 10) e, err := idx.Entry("file1") - c.Assert(err, IsNil) - c.Assert(e.Mode, Equals, filemode.Regular) + s.NoError(err) + s.Equal(filemode.Regular, e.Mode) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 1) + s.NoError(err) + s.Len(status, 1) file := status.File("file1") - c.Assert(file.Staging, Equals, Added) - c.Assert(file.Worktree, Equals, Unmodified) + s.Equal(Added, file.Staging) + s.Equal(Unmodified, file.Worktree) } -func (s *WorktreeSuite) TestAddSkipStatusModifiedPath(c *C) { +func (s *WorktreeSuite) TestAddSkipStatusModifiedPath() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -2009,36 +2131,36 @@ func (s *WorktreeSuite) TestAddSkipStatusModifiedPath(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) idx, err := w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) + s.NoError(err) + s.Len(idx.Entries, 9) - err = util.WriteFile(w.Filesystem, "LICENSE", []byte("file1"), 0644) - c.Assert(err, IsNil) + err = util.WriteFile(w.Filesystem, "LICENSE", []byte("file1"), 0o644) + s.NoError(err) err = w.AddWithOptions(&AddOptions{Path: "LICENSE", SkipStatus: true}) - c.Assert(err, IsNil) + s.NoError(err) idx, err = w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) + s.NoError(err) + s.Len(idx.Entries, 9) e, err := idx.Entry("LICENSE") - c.Assert(err, IsNil) - c.Assert(e.Mode, Equals, filemode.Regular) + s.NoError(err) + s.Equal(filemode.Regular, e.Mode) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 1) + s.NoError(err) + s.Len(status, 1) file := status.File("LICENSE") - c.Assert(file.Staging, Equals, Modified) - c.Assert(file.Worktree, Equals, Unmodified) + s.Equal(Modified, file.Staging) + s.Equal(Unmodified, file.Worktree) } -func (s *WorktreeSuite) TestAddSkipStatusNonModifiedPath(c *C) { +func (s *WorktreeSuite) TestAddSkipStatusNonModifiedPath() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -2046,33 +2168,33 @@ func (s *WorktreeSuite) TestAddSkipStatusNonModifiedPath(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) idx, err := w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) + s.NoError(err) + s.Len(idx.Entries, 9) err = w.AddWithOptions(&AddOptions{Path: "LICENSE", SkipStatus: true}) - c.Assert(err, IsNil) + s.NoError(err) idx, err = w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) + s.NoError(err) + s.Len(idx.Entries, 9) e, err := idx.Entry("LICENSE") - c.Assert(err, IsNil) - c.Assert(e.Mode, Equals, filemode.Regular) + s.NoError(err) + s.Equal(filemode.Regular, e.Mode) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 0) + s.NoError(err) + s.Len(status, 0) file := status.File("LICENSE") - c.Assert(file.Staging, Equals, Untracked) - c.Assert(file.Worktree, Equals, Untracked) + s.Equal(Untracked, file.Staging) + s.Equal(Untracked, file.Worktree) } -func (s *WorktreeSuite) TestAddSkipStatusWithIgnoredPath(c *C) { +func (s *WorktreeSuite) TestAddSkipStatusWithIgnoredPath() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -2080,51 +2202,51 @@ func (s *WorktreeSuite) TestAddSkipStatusWithIgnoredPath(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) idx, err := w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 9) + s.NoError(err) + s.Len(idx.Entries, 9) - err = util.WriteFile(fs, ".gitignore", []byte("fileToIgnore\n"), 0755) - c.Assert(err, IsNil) + err = util.WriteFile(fs, ".gitignore", []byte("fileToIgnore\n"), 0o755) + s.NoError(err) _, err = w.Add(".gitignore") - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Commit("Added .gitignore", defaultTestCommitOptions()) - c.Assert(err, IsNil) + s.NoError(err) - err = util.WriteFile(fs, "fileToIgnore", []byte("file to ignore"), 0644) - c.Assert(err, IsNil) + err = util.WriteFile(fs, "fileToIgnore", []byte("file to ignore"), 0o644) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 0) + s.NoError(err) + s.Len(status, 0) file := status.File("fileToIgnore") - c.Assert(file.Staging, Equals, Untracked) - c.Assert(file.Worktree, Equals, Untracked) + s.Equal(Untracked, file.Staging) + s.Equal(Untracked, file.Worktree) err = w.AddWithOptions(&AddOptions{Path: "fileToIgnore", SkipStatus: true}) - c.Assert(err, IsNil) + s.NoError(err) idx, err = w.r.Storer.Index() - c.Assert(err, IsNil) - c.Assert(idx.Entries, HasLen, 10) + s.NoError(err) + s.Len(idx.Entries, 10) e, err := idx.Entry("fileToIgnore") - c.Assert(err, IsNil) - c.Assert(e.Mode, Equals, filemode.Regular) + s.NoError(err) + s.Equal(filemode.Regular, e.Mode) status, err = w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 1) + s.NoError(err) + s.Len(status, 1) file = status.File("fileToIgnore") - c.Assert(file.Staging, Equals, Added) - c.Assert(file.Worktree, Equals, Unmodified) + s.Equal(Added, file.Staging) + s.Equal(Unmodified, file.Worktree) } -func (s *WorktreeSuite) TestRemove(c *C) { +func (s *WorktreeSuite) TestRemove() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -2132,19 +2254,19 @@ func (s *WorktreeSuite) TestRemove(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Remove("LICENSE") - c.Assert(hash.String(), Equals, "c192bd6a24ea1ab01d78686e417c8bdc7c3d197f") - c.Assert(err, IsNil) + s.Equal("c192bd6a24ea1ab01d78686e417c8bdc7c3d197f", hash.String()) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 1) - c.Assert(status.File("LICENSE").Staging, Equals, Deleted) + s.NoError(err) + s.Len(status, 1) + s.Equal(Deleted, status.File("LICENSE").Staging) } -func (s *WorktreeSuite) TestRemoveNotExistentEntry(c *C) { +func (s *WorktreeSuite) TestRemoveNotExistentEntry() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -2152,14 +2274,14 @@ func (s *WorktreeSuite) TestRemoveNotExistentEntry(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Remove("not-exists") - c.Assert(hash.IsZero(), Equals, true) - c.Assert(err, NotNil) + s.True(hash.IsZero()) + s.NotNil(err) } -func (s *WorktreeSuite) TestRemoveDirectory(c *C) { +func (s *WorktreeSuite) TestRemoveDirectory() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -2167,23 +2289,23 @@ func (s *WorktreeSuite) TestRemoveDirectory(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Remove("json") - c.Assert(hash.IsZero(), Equals, true) - c.Assert(err, IsNil) + s.True(hash.IsZero()) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 2) - c.Assert(status.File("json/long.json").Staging, Equals, Deleted) - c.Assert(status.File("json/short.json").Staging, Equals, Deleted) + s.NoError(err) + s.Len(status, 2) + s.Equal(Deleted, status.File("json/long.json").Staging) + s.Equal(Deleted, status.File("json/short.json").Staging) _, err = w.Filesystem.Stat("json") - c.Assert(os.IsNotExist(err), Equals, true) + s.True(os.IsNotExist(err)) } -func (s *WorktreeSuite) TestRemoveDirectoryUntracked(c *C) { +func (s *WorktreeSuite) TestRemoveDirectoryUntracked() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -2191,27 +2313,27 @@ func (s *WorktreeSuite) TestRemoveDirectoryUntracked(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) - err = util.WriteFile(w.Filesystem, "json/foo", []byte("FOO"), 0755) - c.Assert(err, IsNil) + err = util.WriteFile(w.Filesystem, "json/foo", []byte("FOO"), 0o755) + s.NoError(err) hash, err := w.Remove("json") - c.Assert(hash.IsZero(), Equals, true) - c.Assert(err, IsNil) + s.True(hash.IsZero()) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 3) - c.Assert(status.File("json/long.json").Staging, Equals, Deleted) - c.Assert(status.File("json/short.json").Staging, Equals, Deleted) - c.Assert(status.File("json/foo").Staging, Equals, Untracked) + s.NoError(err) + s.Len(status, 3) + s.Equal(Deleted, status.File("json/long.json").Staging) + s.Equal(Deleted, status.File("json/short.json").Staging) + s.Equal(Untracked, status.File("json/foo").Staging) _, err = w.Filesystem.Stat("json") - c.Assert(err, IsNil) + s.NoError(err) } -func (s *WorktreeSuite) TestRemoveDeletedFromWorktree(c *C) { +func (s *WorktreeSuite) TestRemoveDeletedFromWorktree() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -2219,22 +2341,22 @@ func (s *WorktreeSuite) TestRemoveDeletedFromWorktree(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) err = fs.Remove("LICENSE") - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Remove("LICENSE") - c.Assert(hash.String(), Equals, "c192bd6a24ea1ab01d78686e417c8bdc7c3d197f") - c.Assert(err, IsNil) + s.Equal("c192bd6a24ea1ab01d78686e417c8bdc7c3d197f", hash.String()) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 1) - c.Assert(status.File("LICENSE").Staging, Equals, Deleted) + s.NoError(err) + s.Len(status, 1) + s.Equal(Deleted, status.File("LICENSE").Staging) } -func (s *WorktreeSuite) TestRemoveGlob(c *C) { +func (s *WorktreeSuite) TestRemoveGlob() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -2242,18 +2364,18 @@ func (s *WorktreeSuite) TestRemoveGlob(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) err = w.RemoveGlob(w.Filesystem.Join("json", "l*")) - c.Assert(err, IsNil) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 1) - c.Assert(status.File("json/long.json").Staging, Equals, Deleted) + s.NoError(err) + s.Len(status, 1) + s.Equal(Deleted, status.File("json/long.json").Staging) } -func (s *WorktreeSuite) TestRemoveGlobDirectory(c *C) { +func (s *WorktreeSuite) TestRemoveGlobDirectory() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -2261,22 +2383,22 @@ func (s *WorktreeSuite) TestRemoveGlobDirectory(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) err = w.RemoveGlob("js*") - c.Assert(err, IsNil) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 2) - c.Assert(status.File("json/short.json").Staging, Equals, Deleted) - c.Assert(status.File("json/long.json").Staging, Equals, Deleted) + s.NoError(err) + s.Len(status, 2) + s.Equal(Deleted, status.File("json/short.json").Staging) + s.Equal(Deleted, status.File("json/long.json").Staging) _, err = w.Filesystem.Stat("json") - c.Assert(os.IsNotExist(err), Equals, true) + s.True(os.IsNotExist(err)) } -func (s *WorktreeSuite) TestRemoveGlobDirectoryDeleted(c *C) { +func (s *WorktreeSuite) TestRemoveGlobDirectoryDeleted() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -2284,25 +2406,25 @@ func (s *WorktreeSuite) TestRemoveGlobDirectoryDeleted(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) err = fs.Remove("json/short.json") - c.Assert(err, IsNil) + s.NoError(err) - err = util.WriteFile(w.Filesystem, "json/foo", []byte("FOO"), 0755) - c.Assert(err, IsNil) + err = util.WriteFile(w.Filesystem, "json/foo", []byte("FOO"), 0o755) + s.NoError(err) err = w.RemoveGlob("js*") - c.Assert(err, IsNil) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 3) - c.Assert(status.File("json/short.json").Staging, Equals, Deleted) - c.Assert(status.File("json/long.json").Staging, Equals, Deleted) + s.NoError(err) + s.Len(status, 3) + s.Equal(Deleted, status.File("json/short.json").Staging) + s.Equal(Deleted, status.File("json/long.json").Staging) } -func (s *WorktreeSuite) TestMove(c *C) { +func (s *WorktreeSuite) TestMove() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -2310,21 +2432,20 @@ func (s *WorktreeSuite) TestMove(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Move("LICENSE", "foo") - c.Check(hash.String(), Equals, "c192bd6a24ea1ab01d78686e417c8bdc7c3d197f") - c.Assert(err, IsNil) + s.Equal("c192bd6a24ea1ab01d78686e417c8bdc7c3d197f", hash.String()) + s.NoError(err) status, err := w.Status() - c.Assert(err, IsNil) - c.Assert(status, HasLen, 2) - c.Assert(status.File("LICENSE").Staging, Equals, Deleted) - c.Assert(status.File("foo").Staging, Equals, Added) - + s.NoError(err) + s.Len(status, 2) + s.Equal(Deleted, status.File("LICENSE").Staging) + s.Equal(Added, status.File("foo").Staging) } -func (s *WorktreeSuite) TestMoveNotExistentEntry(c *C) { +func (s *WorktreeSuite) TestMoveNotExistentEntry() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -2332,14 +2453,14 @@ func (s *WorktreeSuite) TestMoveNotExistentEntry(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Move("not-exists", "foo") - c.Assert(hash.IsZero(), Equals, true) - c.Assert(err, NotNil) + s.True(hash.IsZero()) + s.NotNil(err) } -func (s *WorktreeSuite) TestMoveToExistent(c *C) { +func (s *WorktreeSuite) TestMoveToExistent() { fs := memfs.New() w := &Worktree{ r: s.Repository, @@ -2347,88 +2468,88 @@ func (s *WorktreeSuite) TestMoveToExistent(c *C) { } err := w.Checkout(&CheckoutOptions{Force: true}) - c.Assert(err, IsNil) + s.NoError(err) hash, err := w.Move(".gitignore", "LICENSE") - c.Assert(hash.IsZero(), Equals, true) - c.Assert(err, Equals, ErrDestinationExists) + s.True(hash.IsZero()) + s.ErrorIs(err, ErrDestinationExists) } -func (s *WorktreeSuite) TestClean(c *C) { +func (s *WorktreeSuite) TestClean() { fs := fixtures.ByTag("dirty").One().Worktree() // Open the repo. fs, err := fs.Chroot("repo") - c.Assert(err, IsNil) + s.NoError(err) r, err := PlainOpen(fs.Root()) - c.Assert(err, IsNil) + s.NoError(err) wt, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) // Status before cleaning. status, err := wt.Status() - c.Assert(err, IsNil) - c.Assert(len(status), Equals, 2) + s.NoError(err) + s.Len(status, 2) err = wt.Clean(&CleanOptions{}) - c.Assert(err, IsNil) + s.NoError(err) // Status after cleaning. status, err = wt.Status() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(len(status), Equals, 1) + s.Len(status, 1) fi, err := fs.Lstat("pkgA") - c.Assert(err, IsNil) - c.Assert(fi.IsDir(), Equals, true) + s.NoError(err) + s.True(fi.IsDir()) // Clean with Dir: true. err = wt.Clean(&CleanOptions{Dir: true}) - c.Assert(err, IsNil) + s.NoError(err) status, err = wt.Status() - c.Assert(err, IsNil) + s.NoError(err) - c.Assert(len(status), Equals, 0) + s.Len(status, 0) // An empty dir should be deleted, as well. _, err = fs.Lstat("pkgA") - c.Assert(err, ErrorMatches, ".*(no such file or directory.*|.*file does not exist)*.") + s.ErrorIs(err, os.ErrNotExist) } -func (s *WorktreeSuite) TestCleanBare(c *C) { +func (s *WorktreeSuite) TestCleanBare() { storer := memory.NewStorage() r, err := Init(storer, nil) - c.Assert(err, IsNil) - c.Assert(r, NotNil) + s.NoError(err) + s.NotNil(r) wtfs := memfs.New() err = wtfs.MkdirAll("worktree", os.ModePerm) - c.Assert(err, IsNil) + s.NoError(err) wtfs, err = wtfs.Chroot("worktree") - c.Assert(err, IsNil) + s.NoError(err) r, err = Open(storer, wtfs) - c.Assert(err, IsNil) + s.NoError(err) wt, err := r.Worktree() - c.Assert(err, IsNil) + s.NoError(err) _, err = wt.Filesystem.Lstat(".") - c.Assert(err, IsNil) + s.NoError(err) // Clean with Dir: true. err = wt.Clean(&CleanOptions{Dir: true}) - c.Assert(err, IsNil) + s.NoError(err) // Root worktree directory must remain after cleaning _, err = wt.Filesystem.Lstat(".") - c.Assert(err, IsNil) + s.NoError(err) } func TestAlternatesRepo(t *testing.T) { @@ -2467,7 +2588,7 @@ func TestAlternatesRepo(t *testing.T) { assert.Equal(t, commit1.String(), commit2.String()) } -func (s *WorktreeSuite) TestGrep(c *C) { +func (s *WorktreeSuite) TestGrep() { cases := []struct { name string options GrepOptions @@ -2655,23 +2776,23 @@ func (s *WorktreeSuite) TestGrep(c *C) { path := fixtures.Basic().ByTag("worktree").One().Worktree().Root() - dir, clean := s.TemporalDir() - defer clean() + dir, err := os.MkdirTemp("", "") + s.NoError(err) server, err := PlainClone(dir, false, &CloneOptions{ URL: path, }) - c.Assert(err, IsNil) + s.NoError(err) w, err := server.Worktree() - c.Assert(err, IsNil) + s.NoError(err) for _, tc := range cases { gr, err := w.Grep(&tc.options) if tc.wantError != nil { - c.Assert(err, Equals, tc.wantError) + s.ErrorIs(err, tc.wantError) } else { - c.Assert(err, IsNil) + s.NoError(err) } // Iterate through the results and check if the wanted result is present @@ -2685,7 +2806,7 @@ func (s *WorktreeSuite) TestGrep(c *C) { } } if !found { - c.Errorf("unexpected grep results for %q, expected result to contain: %v", tc.name, wantResult) + s.T().Errorf("unexpected grep results for %q, expected result to contain: %v", tc.name, wantResult) } } @@ -2700,13 +2821,13 @@ func (s *WorktreeSuite) TestGrep(c *C) { } } if found { - c.Errorf("unexpected grep results for %q, expected result to NOT contain: %v", tc.name, dontWantResult) + s.T().Errorf("unexpected grep results for %q, expected result to NOT contain: %v", tc.name, dontWantResult) } } } } -func (s *WorktreeSuite) TestGrepBare(c *C) { +func (s *WorktreeSuite) TestGrepBare() { cases := []struct { name string options GrepOptions @@ -2739,20 +2860,20 @@ func (s *WorktreeSuite) TestGrepBare(c *C) { path := fixtures.Basic().ByTag("worktree").One().Worktree().Root() - dir, clean := s.TemporalDir() - defer clean() + dir, err := os.MkdirTemp("", "") + s.NoError(err) r, err := PlainClone(dir, true, &CloneOptions{ URL: path, }) - c.Assert(err, IsNil) + s.NoError(err) for _, tc := range cases { gr, err := r.Grep(&tc.options) if tc.wantError != nil { - c.Assert(err, Equals, tc.wantError) + s.ErrorIs(err, tc.wantError) } else { - c.Assert(err, IsNil) + s.NoError(err) } // Iterate through the results and check if the wanted result is present @@ -2766,7 +2887,7 @@ func (s *WorktreeSuite) TestGrepBare(c *C) { } } if !found { - c.Errorf("unexpected grep results for %q, expected result to contain: %v", tc.name, wantResult) + s.T().Errorf("unexpected grep results for %q, expected result to contain: %v", tc.name, wantResult) } } @@ -2781,15 +2902,15 @@ func (s *WorktreeSuite) TestGrepBare(c *C) { } } if found { - c.Errorf("unexpected grep results for %q, expected result to NOT contain: %v", tc.name, dontWantResult) + s.T().Errorf("unexpected grep results for %q, expected result to NOT contain: %v", tc.name, dontWantResult) } } } } -func (s *WorktreeSuite) TestResetLingeringDirectories(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *WorktreeSuite) TestResetLingeringDirectories() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) commitOpts := &CommitOptions{Author: &object.Signature{ Name: "foo", @@ -2798,72 +2919,72 @@ func (s *WorktreeSuite) TestResetLingeringDirectories(c *C) { }} repo, err := PlainInit(dir, false) - c.Assert(err, IsNil) + s.NoError(err) w, err := repo.Worktree() - c.Assert(err, IsNil) + s.NoError(err) os.WriteFile(filepath.Join(dir, "README"), []byte("placeholder"), 0o644) _, err = w.Add(".") - c.Assert(err, IsNil) + s.NoError(err) initialHash, err := w.Commit("Initial commit", commitOpts) - c.Assert(err, IsNil) + s.NoError(err) os.MkdirAll(filepath.Join(dir, "a", "b"), 0o755) os.WriteFile(filepath.Join(dir, "a", "b", "1"), []byte("1"), 0o644) _, err = w.Add(".") - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Commit("Add file in nested sub-directories", commitOpts) - c.Assert(err, IsNil) + s.NoError(err) // reset to initial commit, which should remove a/b/1, a/b, and a err = w.Reset(&ResetOptions{ Commit: initialHash, Mode: HardReset, }) - c.Assert(err, IsNil) + s.NoError(err) _, err = os.Stat(filepath.Join(dir, "a", "b", "1")) - c.Assert(errors.Is(err, os.ErrNotExist), Equals, true) + s.True(errors.Is(err, os.ErrNotExist)) _, err = os.Stat(filepath.Join(dir, "a", "b")) - c.Assert(errors.Is(err, os.ErrNotExist), Equals, true) + s.True(errors.Is(err, os.ErrNotExist)) _, err = os.Stat(filepath.Join(dir, "a")) - c.Assert(errors.Is(err, os.ErrNotExist), Equals, true) + s.True(errors.Is(err, os.ErrNotExist)) } -func (s *WorktreeSuite) TestAddAndCommit(c *C) { +func (s *WorktreeSuite) TestAddAndCommit() { expectedFiles := 2 - dir, clean := s.TemporalDir() - defer clean() + dir, err := os.MkdirTemp("", "") + s.NoError(err) repo, err := PlainInit(dir, false) - c.Assert(err, IsNil) + s.NoError(err) w, err := repo.Worktree() - c.Assert(err, IsNil) + s.NoError(err) os.WriteFile(filepath.Join(dir, "foo"), []byte("bar"), 0o644) os.WriteFile(filepath.Join(dir, "bar"), []byte("foo"), 0o644) _, err = w.Add(".") - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Commit("Test Add And Commit", &CommitOptions{Author: &object.Signature{ Name: "foo", Email: "foo@foo.foo", When: time.Now(), }}) - c.Assert(err, IsNil) + s.NoError(err) iter, err := w.r.Log(&LogOptions{}) - c.Assert(err, IsNil) + s.NoError(err) filesFound := 0 err = iter.ForEach(func(c *object.Commit) error { @@ -2878,103 +2999,103 @@ func (s *WorktreeSuite) TestAddAndCommit(c *C) { }) return err }) - c.Assert(err, IsNil) - c.Assert(filesFound, Equals, expectedFiles) + s.NoError(err) + s.Equal(expectedFiles, filesFound) } -func (s *WorktreeSuite) TestAddAndCommitEmpty(c *C) { - dir, clean := s.TemporalDir() - defer clean() +func (s *WorktreeSuite) TestAddAndCommitEmpty() { + dir, err := os.MkdirTemp("", "") + s.NoError(err) repo, err := PlainInit(dir, false) - c.Assert(err, IsNil) + s.NoError(err) w, err := repo.Worktree() - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Add(".") - c.Assert(err, IsNil) + s.NoError(err) _, err = w.Commit("Test Add And Commit", &CommitOptions{Author: &object.Signature{ Name: "foo", Email: "foo@foo.foo", When: time.Now(), }}) - c.Assert(err, Equals, ErrEmptyCommit) + s.ErrorIs(err, ErrEmptyCommit) } -func (s *WorktreeSuite) TestLinkedWorktree(c *C) { +func (s *WorktreeSuite) TestLinkedWorktree() { fs := fixtures.ByTag("linked-worktree").One().Worktree() // Open main repo. { fs, err := fs.Chroot("main") - c.Assert(err, IsNil) + s.NoError(err) repo, err := PlainOpenWithOptions(fs.Root(), &PlainOpenOptions{EnableDotGitCommonDir: true}) - c.Assert(err, IsNil) + s.NoError(err) wt, err := repo.Worktree() - c.Assert(err, IsNil) + s.NoError(err) status, err := wt.Status() - c.Assert(err, IsNil) - c.Assert(len(status), Equals, 2) // 2 files + s.NoError(err) + s.Len(status, 2) // 2 files head, err := repo.Head() - c.Assert(err, IsNil) - c.Assert(string(head.Name()), Equals, "refs/heads/master") + s.NoError(err) + s.Equal("refs/heads/master", string(head.Name())) } // Open linked-worktree #1. { fs, err := fs.Chroot("linked-worktree-1") - c.Assert(err, IsNil) + s.NoError(err) repo, err := PlainOpenWithOptions(fs.Root(), &PlainOpenOptions{EnableDotGitCommonDir: true}) - c.Assert(err, IsNil) + s.NoError(err) wt, err := repo.Worktree() - c.Assert(err, IsNil) + s.NoError(err) status, err := wt.Status() - c.Assert(err, IsNil) - c.Assert(len(status), Equals, 3) // 3 files + s.NoError(err) + s.Len(status, 3) // 3 files _, ok := status["linked-worktree-1-unique-file.txt"] - c.Assert(ok, Equals, true) + s.True(ok) head, err := repo.Head() - c.Assert(err, IsNil) - c.Assert(string(head.Name()), Equals, "refs/heads/linked-worktree-1") + s.NoError(err) + s.Equal("refs/heads/linked-worktree-1", string(head.Name())) } // Open linked-worktree #2. { fs, err := fs.Chroot("linked-worktree-2") - c.Assert(err, IsNil) + s.NoError(err) repo, err := PlainOpenWithOptions(fs.Root(), &PlainOpenOptions{EnableDotGitCommonDir: true}) - c.Assert(err, IsNil) + s.NoError(err) wt, err := repo.Worktree() - c.Assert(err, IsNil) + s.NoError(err) status, err := wt.Status() - c.Assert(err, IsNil) - c.Assert(len(status), Equals, 3) // 3 files + s.NoError(err) + s.Len(status, 3) // 3 files _, ok := status["linked-worktree-2-unique-file.txt"] - c.Assert(ok, Equals, true) + s.True(ok) head, err := repo.Head() - c.Assert(err, IsNil) - c.Assert(string(head.Name()), Equals, "refs/heads/branch-with-different-name") + s.NoError(err) + s.Equal("refs/heads/branch-with-different-name", string(head.Name())) } // Open linked-worktree #2. { fs, err := fs.Chroot("linked-worktree-invalid-commondir") - c.Assert(err, IsNil) + s.NoError(err) _, err = PlainOpenWithOptions(fs.Root(), &PlainOpenOptions{EnableDotGitCommonDir: true}) - c.Assert(err, Equals, ErrRepositoryIncomplete) + s.ErrorIs(err, ErrRepositoryIncomplete) } } @@ -3053,3 +3174,173 @@ func TestWindowsValidPath(t *testing.T) { }) } } + +var statusCodeNames = map[StatusCode]string{ + Unmodified: "Unmodified", + Untracked: "Untracked", + Modified: "Modified", + Added: "Added", + Deleted: "Deleted", + Renamed: "Renamed", + Copied: "Copied", + UpdatedButUnmerged: "UpdatedButUnmerged", +} + +func setupForRestore(s *WorktreeSuite) (fs billy.Filesystem, w *Worktree, names []string) { + fs = memfs.New() + w = &Worktree{ + r: s.Repository, + Filesystem: fs, + } + + err := w.Checkout(&CheckoutOptions{}) + s.NoError(err) + + names = []string{"foo", "CHANGELOG", "LICENSE", "binary.jpg"} + verifyStatus(s, "Checkout", w, names, []FileStatus{ + {Worktree: Untracked, Staging: Untracked}, + {Worktree: Untracked, Staging: Untracked}, + {Worktree: Untracked, Staging: Untracked}, + {Worktree: Untracked, Staging: Untracked}, + }) + + // Touch of bunch of files including create a new file and delete an exsiting file + for _, name := range names { + err = util.WriteFile(fs, name, []byte("Foo Bar"), 0o755) + s.NoError(err) + } + err = util.RemoveAll(fs, names[3]) + s.NoError(err) + + // Confirm the status after doing the edits without staging anything + verifyStatus(s, "Edits", w, names, []FileStatus{ + {Worktree: Untracked, Staging: Untracked}, + {Worktree: Modified, Staging: Unmodified}, + {Worktree: Modified, Staging: Unmodified}, + {Worktree: Deleted, Staging: Unmodified}, + }) + + // Stage all files and verify the updated status + for _, name := range names { + _, err = w.Add(name) + s.NoError(err) + } + verifyStatus(s, "Staged", w, names, []FileStatus{ + {Worktree: Unmodified, Staging: Added}, + {Worktree: Unmodified, Staging: Modified}, + {Worktree: Unmodified, Staging: Modified}, + {Worktree: Unmodified, Staging: Deleted}, + }) + + // Add secondary changes to a file to make sure we only restore the staged file + err = util.WriteFile(fs, names[1], []byte("Foo Bar:11"), 0755) + s.NoError(err) + err = util.WriteFile(fs, names[2], []byte("Foo Bar:22"), 0755) + s.NoError(err) + + verifyStatus(s, "Secondary Edits", w, names, []FileStatus{ + {Worktree: Unmodified, Staging: Added}, + {Worktree: Modified, Staging: Modified}, + {Worktree: Modified, Staging: Modified}, + {Worktree: Unmodified, Staging: Deleted}, + }) + + return +} + +func verifyStatus(s *WorktreeSuite, marker string, w *Worktree, files []string, statuses []FileStatus) { + s.Len(statuses, len(files)) + + status, err := w.Status() + s.NoError(err) + + for i, file := range files { + current := status.File(file) + expected := statuses[i] + s.Equal(expected.Worktree, current.Worktree, fmt.Sprintf("%s - [%d] : %s Worktree %s != %s", marker, i, file, statusCodeNames[current.Worktree], statusCodeNames[expected.Worktree])) + s.Equal(expected.Staging, current.Staging, fmt.Sprintf("%s - [%d] : %s Staging %s != %s", marker, i, file, statusCodeNames[current.Staging], statusCodeNames[expected.Staging])) + } +} + +func (s *WorktreeSuite) TestRestoreStaged() { + fs, w, names := setupForRestore(s) + + // Attempt without files should throw an error like the git restore --staged + opts := RestoreOptions{Staged: true} + err := w.Restore(&opts) + s.ErrorIs(err, ErrNoRestorePaths) + + // Restore Staged files in 2 groups and confirm status + opts.Files = []string{names[0], "./" + names[1]} + err = w.Restore(&opts) + s.NoError(err) + verifyStatus(s, "Restored First", w, names, []FileStatus{ + {Worktree: Untracked, Staging: Untracked}, + {Worktree: Modified, Staging: Unmodified}, + {Worktree: Modified, Staging: Modified}, + {Worktree: Unmodified, Staging: Deleted}, + }) + + // Make sure the restore didn't overwrite our secondary changes + contents, err := util.ReadFile(fs, names[1]) + s.NoError(err) + s.Equal("Foo Bar:11", string(contents)) + + opts.Files = []string{"./" + names[2], names[3]} + err = w.Restore(&opts) + s.NoError(err) + verifyStatus(s, "Restored Second", w, names, []FileStatus{ + {Worktree: Untracked, Staging: Untracked}, + {Worktree: Modified, Staging: Unmodified}, + {Worktree: Modified, Staging: Unmodified}, + {Worktree: Deleted, Staging: Unmodified}, + }) + + // Make sure the restore didn't overwrite our secondary changes + contents, err = util.ReadFile(fs, names[2]) + s.NoError(err) + s.Equal("Foo Bar:22", string(contents)) +} + +func (s *WorktreeSuite) TestRestoreWorktree() { + _, w, names := setupForRestore(s) + + // Attempt without files should throw an error like the git restore + opts := RestoreOptions{} + err := w.Restore(&opts) + s.ErrorIs(err, ErrNoRestorePaths) + + opts.Files = []string{names[0], names[1]} + err = w.Restore(&opts) + s.ErrorIs(err, ErrRestoreWorktreeOnlyNotSupported) +} + +func (s *WorktreeSuite) TestRestoreBoth() { + _, w, names := setupForRestore(s) + + // Attempt without files should throw an error like the git restore --staged --worktree + opts := RestoreOptions{Staged: true, Worktree: true} + err := w.Restore(&opts) + s.ErrorIs(err, ErrNoRestorePaths) + + // Restore Staged files in 2 groups and confirm status + opts.Files = []string{names[0], names[1]} + err = w.Restore(&opts) + s.NoError(err) + verifyStatus(s, "Restored First", w, names, []FileStatus{ + {Worktree: Untracked, Staging: Untracked}, + {Worktree: Untracked, Staging: Untracked}, + {Worktree: Modified, Staging: Modified}, + {Worktree: Unmodified, Staging: Deleted}, + }) + + opts.Files = []string{names[2], names[3]} + err = w.Restore(&opts) + s.NoError(err) + verifyStatus(s, "Restored Second", w, names, []FileStatus{ + {Worktree: Untracked, Staging: Untracked}, + {Worktree: Untracked, Staging: Untracked}, + {Worktree: Untracked, Staging: Untracked}, + {Worktree: Untracked, Staging: Untracked}, + }) +} diff --git a/worktree_unix_other.go b/worktree_unix_other.go index 5b16e70b7..cc89ef8d8 100644 --- a/worktree_unix_other.go +++ b/worktree_unix_other.go @@ -6,7 +6,7 @@ import ( "syscall" "time" - "github.com/go-git/go-git/v5/plumbing/format/index" + "github.com/jesseduffield/go-git/v5/plumbing/format/index" ) func init() { diff --git a/worktree_windows.go b/worktree_windows.go index 1928f9712..e98f0773e 100644 --- a/worktree_windows.go +++ b/worktree_windows.go @@ -7,7 +7,7 @@ import ( "syscall" "time" - "github.com/go-git/go-git/v5/plumbing/format/index" + "github.com/jesseduffield/go-git/v5/plumbing/format/index" ) func init() {