Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

https://github.com/rzane/absinthe_conn_test

Helpful utilities for testing your GraphQL API
https://github.com/rzane/absinthe_conn_test

absinthe elixir graphql phoenix testing uploads

Last synced: 5 days ago
JSON representation

Helpful utilities for testing your GraphQL API

Lists

README

        

# Absinthe.ConnTest

This package makes it really convenient to execute GraphQL queries and mutations
against your Phoenix Endpoint.

Executing queries as HTTP requests helps to ensure that your application behaves
the same way under test as it does under normal circumstances.

## Installation

The package can be installed by adding `absinthe_conn_test` to your list of
dependencies in `mix.exs`:

```elixir
def deps do
[
{:absinthe_conn_test, "~> 0.1.0"}
]
end
```

## Setup

You'll probably want to import this module in your `ConnCase`.

```elixir
# test/support/conn_case.ex

defmodule MyAppWeb.ConnCase do
use ExUnit.CaseTemplate

using do
quote do
# ...etc, etc

# Import this library
import Absinthe.ConnTest

# The default endpoint for testing
@endpoint MyAppWeb.Endpoint

# The default URL for your GraphQL API
@graphql "/graphql"
end
end

# ... etc, etc
end
```

## Testing

A simple test might look something like this:

```elixir
defmodule MyAppWeb.Schema.UsersTest do
use MyAppWeb.ConnCase

@say_hello """
query SayHello($name: String!) {
hello(name: $name)
}
"""

test "hello", %{conn: conn} do
assert {:ok, %{"hello" => "Hello, Ray!"}} =
graphql(conn, @say_hello, name: "Ray")
end
end
```

### Importing queries

Yuck, it's kind of annoying to write your queries in your test file. Let's move
them to dedicated `.graphql` file:

```graphql
# test/fixtures/queries.graphql

query SayHello($name: String!) {
hello(name: $name)
}
```

Now, you can import those queries, and they'll become test functions!

```elixir
defmodule MyAppWeb.Schema.UsersTest do
use MyAppWeb.ConnCase

import_queries "test/fixtures/queries.graphql"

test "hello", %{conn: conn} do
assert {:ok, %{"hello" => "Hello, Ray!"}} = say_hello(conn, name: "Ray")
end
end
```

Note that in the example above the `SayHello` query became a function `say_hello`.

### Errors

Errors are returned in a concise format:

```elixir
test "produces an error message", %{conn: conn} do
assert {:error, ["is invalid"]} = create_user(conn, data: %{})
end
```

If your error contains extensions, it'll look like this:

```elixir
test "produces an error message with extensions", %{conn: conn} do
assert {:error, [{"is invalid", %{"code" => "VALIDATION_ERROR"}}]} =
create_user(conn, data: %{})
end
```

### Fragments

Yup, they're supported too. It will also resolve `#import` expressions.

```graphql
# test/fixtures/users.graphql

fragment User on User {
id
name
}
```

```graphql
#import "./user.graphql"

query ListUsers {
users {
...User
}
}
```

### File Uploads

If you attempt to send a [`%Plug.Upload{}`](https://hexdocs.pm/plug/Plug.Upload.html)
to your API, this library will extract it for you in accordance with Absinthe's [file
upload specification](https://hexdocs.pm/absinthe/file-uploads.html).

```graphql
# test/fixtures/queries.graphl

mutation UploadImage($image: Upload!) {
uploadImage(image: $image)
}
```

```elixir
import_queries "test/fixtures/queries.graphql"

test "uploading an image", %{conn: conn} do
image = %Plug.Upload{
filename: "foo.png",
path: "test/fixtures/image.png"
}

assert {:ok, } = upload_image(conn, image: image)
end
```