pointfreeco/swift-snapshot-testing 1.13.0 on GitHub

What's Changed

Added: Inline Snapshot Testing (#764). This allows your text-based snapshots to live right in the test source code, rather than in an external file:

While the library has had experimental support for this feature since 1.5.0 thanks to @rjchatfield (#199), we've finally put the finishing touches to it:
- Inline snapshot testing is available in a separate InlineSnapshotTesting module. To use inline snapshot testing, add a dependency on this module and update your existing imports:
```
-import SnapshotTesting
+import InlineSnapshotTesting
```
  The feature has been rewritten to use SwiftSyntax. While a heavyweight dependency, it is a more reasonable tool for generating Swift code than string substitution, and will be an increasingly common dependency as the de facto tool for writing Swift macros.
  The main SnapshotTesting module does not depend on SwiftSyntax, so existing snapshot tests will not incur cost of compiling SwiftSyntax.
- The API now follows the same structure as assertSnapshot, except it uses a trailing closure to capture the inline snapshot. This makes it easy to update an existing snapshot test to use inline snapshots:
```
-assertSnapshot(of: user, as: .json)
+assertInlineSnapshot(of: user, as .json)
```
  After this assertion runs, the test source code is updated in place:
```
assertInlineSnapshot(of: user, as: .json) {
  """
  {
    "id" : 42,
    "isAdmin" : true,
    "name" : "Blob"
  }
  """
}
```
  These trailing closures are easy to select in Xcode in order to delete and re-record a snapshot: simply double-click one of the braces to highlight the closure, delete, and run the test.
- Inline snapshotting's assertInlineSnapshot testing tool is fully customizable so that you can build your own testing helpers on top of it without your users even knowing they are using snapshot testing. In fact, we do this to create a testing tool that helps us test the Swift code that powers Point-Free. It's called assertRequest, and it allows you to simultaneously assert the request being made to the server (including URL, query parameters, headers, POST body) as well as the response from the server (including status code and headers).
  For example, to test that when a request is made for a user to join a team subscription, we can write the following:
```
await assertRequest(
  connection(
    from: request(
      to: .teamInviteCode(.join(code: subscription.teamInviteCode, email: nil)),
      session: .loggedIn(as: currentUser)
    )
  )
)
```
  And when we first run the test it will automatically expand:
```
await assertRequest(
  connection(
    from: request(
      to: .teamInviteCode(.join(code: subscription.teamInviteCode, email: nil)),
      session: .loggedIn(as: currentUser)
    )
  )
) {
  """
  POST http://localhost:8080/join/subscriptions-team_invite_code3
  Cookie: pf_session={"userId":"00000000-0000-0000-0000-000000000001"}
  """
} response: {
  """
  302 Found
  Location: /account
  Referrer-Policy: strict-origin-when-cross-origin
  Set-Cookie: pf_session={"flash":{"message":"You now have access to Point-Free!","priority":"notice"},"userId":"00000000-0000-0000-0000-000000000001"}; Expires=Sat, 29 Jan 2028 00:00:00 GMT; Path=/
  X-Content-Type-Options: nosniff
  X-Download-Options: noopen
  X-Frame-Options: SAMEORIGIN
  X-Permitted-Cross-Domain-Policies: none
  X-XSS-Protection: 1; mode=block
  """
}
```
  This shows that the response redirects the use back to their account page and shows them the flash message that they now have full access to Point-Free. This makes writing complex and nuanced tests incredibly easy, and so there is no reason to not write lots of tests for all the subtle edge cases of your application's logic.
Added: DocC documentation (#765). The SnapshotTesting and InlineSnapshotTesting are fully documented using DocC.
Infrastructure: swift-format support (#765). The library is now auto-formatted using swift-format.

Full Changelog: 1.12.0...0.13.0