How to Run Tests for IPATool: Step‑by‑Step Guide

To run tests for IPATool, execute go generate ./... to create mocks and embedded assets, then run go test -v ./... to compile and execute the full unit test suite across all packages.

IPATool is a pure‑Go command‑line application for searching and downloading iOS IPA files from the App Store. Because the repository relies on code generation for mock implementations and static assets, running the test suite requires executing a generation step before the standard test command will compile successfully.

Step‑by‑Step Test Execution

The IPATool repository follows standard Go testing conventions. Validating the codebase locally requires two primary commands, followed by optional package‑specific targeting.

Generate Required Code

The project uses go:generate directives (for example, to generate mocks with go‑mock and embed static assets). These generated files must exist before the compiler can resolve dependencies.

Run the generation command from the repository root:

go generate ./...

Skipping this step results in compilation errors, as test files in packages like pkg/appstore and internal/sap/unicorn import generated code that does not exist prior to execution.

Execute the Complete Test Suite

Once generation completes, invoke the full test suite. The go.mod file declares the module as github.com/majd/ipatool/v2 and requires Go 1.25.

Execute all tests with verbose output:

go test -v ./...

This command recursively discovers every *_test.go file in the repository, including tests for the keychain credential store, the appstore client, and the unicorn download engine. The -v flag prints individual test names and outcomes, providing immediate feedback on failures.

Target Specific Packages

For rapid iteration during development, limit the test scope to a single package. For example, to validate only the App Store logic:

go test -v ./pkg/appstore

Similarly, you can test the secure storage layer or the extraction engine in isolation:

go test -v ./pkg/keychain
go test -v ./internal/sap/unicorn

Understanding the Test Infrastructure

IPATool’s testing strategy combines unit tests for isolated packages with continuous integration across multiple platforms.

Critical Packages Under Test

The repository organizes testable code into several key directories, each containing corresponding *_test.go files:

• pkg/keychain/ – Validates secure credential storage operations, including get, set, and remove functionality.
• pkg/appstore/ – Tests the core client logic for App Store API interactions and IPA metadata handling.
• internal/sap/unicorn/ – Exercises the engine responsible for IPA download and extraction, ensuring binary manipulation logic functions correctly.

CI/CD Validation

The GitHub Actions workflow defined in .github/workflows/unit-tests.yml enforces cross‑platform reliability. The workflow executes go generate ./... followed by go test -v ./... across three runners: Ubuntu, Windows, and Windows‑ARM. This matrix guarantees that the command sequence works identically on all supported operating systems.

According to the IPATool source code, the README.md file (lines 99‑104) documents these exact commands for developers who prefer to verify functionality locally rather than relying on CI.

Summary

• Generate first: Always execute go generate ./... before testing to create mocks and embedded assets required for compilation.
• Test broadly: Use go test -v ./... to run the complete suite across all packages in the github.com/majd/ipatool/v2 module.
• Target narrowly: Run go test -v ./pkg/appstore (or similar) to test specific components during development.
• Mirror CI: The workflow in .github/workflows/unit-tests.yml validates the same commands on Linux, Windows, and Windows‑ARM runners.

Frequently Asked Questions

What Go version is required to run IPATool tests?

The go.mod file at the repository root specifies Go 1.25 as the minimum required version. Attempting to compile or test the project with earlier Go versions will likely result in build failures due to language features or dependency requirements used throughout the codebase.

Why do tests fail with "undefined" errors before running go generate?

IPATool relies on code generation to produce mock interfaces and embedded static assets. Packages such as pkg/appstore and internal/sap/unicorn import these generated types, which do not exist in the repository until you execute go generate ./.... Running generation creates the necessary files, allowing the compiler to resolve all symbols.

How do I run the exact same tests as the CI pipeline?

Execute the two commands found in .github/workflows/unit-tests.yml: first go generate ./..., then go test -v ./.... The CI pipeline runs these commands on Ubuntu, Windows, and Windows‑ARM runners, ensuring the test suite passes across all supported platforms using the same sequence you run locally.

Where are the test files located in the repository?

Test files follow Go naming conventions, using the pattern *_test.go. You can find them alongside implementation code in directories such as pkg/keychain/, pkg/appstore/, and internal/sap/unicorn/. Running go test -v ./... from the root discovers and executes every test file automatically.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}