query_test.go

package redash_test

import (
	"bytes"
	"context"
	"encoding/json"
	"io"
	"net/http"
	"regexp"
	"strings"
	"testing"
	"time"

	"github.com/araddon/dateparse"
	"github.com/jarcoal/httpmock"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"github.com/winebarrel/redash-go/v2"
)

func Test_ListQueries_OK(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		assert.Equal("page=1&page_size=25", req.URL.Query().Encode())
		return httpmock.NewStringResponse(http.StatusOK, `
			{
				"count": 1,
				"page": 1,
				"page_size": 25,
				"results": [
					{
						"api_key": "api_key",
						"created_at": "2023-02-10T01:23:45.000Z",
						"data_source_id": 1,
						"description": "description",
						"id": 1,
						"is_archived": false,
						"is_draft": false,
						"is_favorite": false,
						"is_safe": true,
						"last_modified_by_id": 1,
						"latest_query_data_id": 1,
						"name": "my-query",
						"options": {
							"parameters": []
						},
						"query": "select 1",
						"query_hash": "query_hash",
						"retrieved_at": "2023-02-10T01:23:45.000Z",
						"runtime": 0.1,
						"schedule": {
							"day_of_week": null,
							"interval": 60,
							"time": null,
							"until": "2023-02-11"
						},
						"tags": [],
						"updated_at": "2023-02-10T01:23:45.000Z",
						"user": {},
						"version": 1
					}
				]
			}
		`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	res, err := client.ListQueries(context.Background(), &redash.ListQueriesInput{
		OnlyFavorites: false,
		Page:          1,
		PageSize:      25,
	})
	assert.NoError(err)
	assert.Equal(&redash.QueryPage{
		Count:    1,
		Page:     1,
		PageSize: 25,
		Results: []redash.Query{
			{
				APIKey:            "api_key",
				CanEdit:           false,
				CreatedAt:         dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				DataSourceID:      1,
				Description:       "description",
				ID:                1,
				IsArchived:        false,
				IsDraft:           false,
				IsFavorite:        false,
				IsSafe:            true,
				LastModifiedBy:    nil,
				LastModifiedByID:  1,
				LatestQueryDataID: 1,
				Name:              "my-query",
				Options:           redash.QueryOptions{Parameters: []redash.QueryOptionsParameter{}},
				Query:             "select 1",
				QueryHash:         "query_hash",
				RetrievedAt:       dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				Runtime:           0.1,
				Schedule: &redash.QueueSchedule{
					DayOfWeek: "",
					Interval:  60,
					Time:      "",
					Until:     "2023-02-11",
				},
				Tags:           []string{},
				UpdatedAt:      dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				User:           redash.User{},
				Version:        1,
				Visualizations: nil,
			},
		},
	}, res)
}

func Test_ListQueries_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.ListQueries(context.Background(), &redash.ListQueriesInput{
		OnlyFavorites: false,
		Page:          1,
		PageSize:      25,
	})
	assert.ErrorContains(err, "GET api/queries failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_ListQueries_IOErr(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries", func(req *http.Request) (*http.Response, error) {
		return testIOErrResp, nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.ListQueries(context.Background(), &redash.ListQueriesInput{
		OnlyFavorites: false,
		Page:          1,
		PageSize:      25,
	})
	assert.ErrorContains(err, "read response body failed: IO error")
}

func Test_ListQueries_WithQ(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		assert.Equal("page=1&page_size=25&q=my-query", req.URL.Query().Encode())
		return httpmock.NewStringResponse(http.StatusOK, `
			{
				"count": 1,
				"page": 1,
				"page_size": 25,
				"results": [
					{
						"api_key": "api_key",
						"created_at": "2023-02-10T01:23:45.000Z",
						"data_source_id": 1,
						"description": "description",
						"id": 1,
						"is_archived": false,
						"is_draft": false,
						"is_favorite": false,
						"is_safe": true,
						"last_modified_by_id": 1,
						"latest_query_data_id": 1,
						"name": "my-query",
						"options": {
							"parameters": []
						},
						"query": "select 1",
						"query_hash": "query_hash",
						"retrieved_at": "2023-02-10T01:23:45.000Z",
						"runtime": 0.1,
						"schedule": {
							"day_of_week": null,
							"interval": 60,
							"time": null,
							"until": "2023-02-11"
						},
						"tags": [],
						"updated_at": "2023-02-10T01:23:45.000Z",
						"user": {},
						"version": 1
					}
				]
			}
		`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	res, err := client.ListQueries(context.Background(), &redash.ListQueriesInput{
		OnlyFavorites: false,
		Page:          1,
		PageSize:      25,
		Q:             "my-query",
	})
	assert.NoError(err)
	assert.Equal(&redash.QueryPage{
		Count:    1,
		Page:     1,
		PageSize: 25,
		Results: []redash.Query{
			{
				APIKey:            "api_key",
				CanEdit:           false,
				CreatedAt:         dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				DataSourceID:      1,
				Description:       "description",
				ID:                1,
				IsArchived:        false,
				IsDraft:           false,
				IsFavorite:        false,
				IsSafe:            true,
				LastModifiedBy:    nil,
				LastModifiedByID:  1,
				LatestQueryDataID: 1,
				Name:              "my-query",
				Options:           redash.QueryOptions{Parameters: []redash.QueryOptionsParameter{}},
				Query:             "select 1",
				QueryHash:         "query_hash",
				RetrievedAt:       dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				Runtime:           0.1,
				Schedule: &redash.QueueSchedule{
					DayOfWeek: "",
					Interval:  60,
					Time:      "",
					Until:     "2023-02-11",
				},
				Tags:           []string{},
				UpdatedAt:      dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				User:           redash.User{},
				Version:        1,
				Visualizations: nil,
			},
		},
	}, res)
}

func Test_GetQuery_OK(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `
			{
				"api_key": "api_key",
				"can_edit": true,
				"created_at": "2023-02-10T01:23:45.000Z",
				"data_source_id": 1,
				"description": "description",
				"id": 1,
				"is_archived": false,
				"is_draft": false,
				"is_favorite": false,
				"is_safe": true,
				"last_modified_by": {},
				"latest_query_data_id": 1,
				"name": "my-query",
				"options": {
					"parameters": []
				},
				"query": "select 1",
				"query_hash": "query_hash",
				"schedule": {
					"day_of_week": null,
					"interval": 60,
					"time": null,
					"until": "2023-02-11"
				},
				"tags": [],
				"updated_at": "2023-02-10T01:23:45.000Z",
				"user": {},
				"version": 1,
				"visualizations": [
					{
						"created_at": "2023-02-10T01:23:45.000Z",
						"description": "description",
						"id": 1,
						"name": "Table",
						"options": {},
						"type": "TABLE",
						"updated_at": "2023-02-10T01:23:45.000Z"
					}
				]
			}
		`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	res, err := client.GetQuery(context.Background(), 1)
	assert.NoError(err)
	assert.Equal(&redash.Query{
		APIKey:            "api_key",
		CanEdit:           true,
		CreatedAt:         dateparse.MustParse("2023-02-10T01:23:45.000Z"),
		DataSourceID:      1,
		Description:       "description",
		ID:                1,
		IsArchived:        false,
		IsDraft:           false,
		IsFavorite:        false,
		IsSafe:            true,
		LastModifiedBy:    &redash.User{},
		LastModifiedByID:  0,
		LatestQueryDataID: 1,
		Name:              "my-query",
		Options:           redash.QueryOptions{Parameters: []redash.QueryOptionsParameter{}},
		Query:             "select 1",
		QueryHash:         "query_hash",
		RetrievedAt:       time.Time{},
		Runtime:           0,
		Schedule: &redash.QueueSchedule{
			DayOfWeek: "",
			Interval:  60,
			Time:      "",
			Until:     "2023-02-11",
		},
		Tags:      []string{},
		UpdatedAt: dateparse.MustParse("2023-02-10T01:23:45.000Z"),
		User:      redash.User{},
		Version:   1,
		Visualizations: []redash.Visualization{
			{
				CreatedAt:   dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				Description: "description",
				ID:          1,
				Name:        "Table",
				Options:     map[string]any{},
				Query:       redash.Query{},
				Type:        "TABLE",
				UpdatedAt:   dateparse.MustParse("2023-02-10T01:23:45.000Z"),
			},
		},
	}, res)
}

func Test_GetQuery_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.GetQuery(context.Background(), 1)
	assert.ErrorContains(err, "GET api/queries/1 failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_GetQuery_IOErr(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1", func(req *http.Request) (*http.Response, error) {
		return testIOErrResp, nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.GetQuery(context.Background(), 1)
	assert.ErrorContains(err, "read response body failed: IO error")
}

func Test_CreateQuery_OK(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		require.NotNil(req.Body)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{"data_source_id":1,"description":"description","name":"my-query","query":"select 1","schedule":{"interval":60,"time":null,"until":null,"day_of_week":null}}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, `
			{
				"api_key": "api_key",
				"can_edit": true,
				"created_at": "2023-02-10T01:23:45.000Z",
				"data_source_id": 1,
				"description": "description",
				"id": 1,
				"is_archived": false,
				"is_draft": false,
				"is_favorite": false,
				"is_safe": true,
				"last_modified_by": {},
				"latest_query_data_id": 1,
				"name": "my-query",
				"options": {
					"parameters": []
				},
				"query": "select 1",
				"query_hash": "query_hash",
				"schedule": {
					"day_of_week": null,
					"interval": 60,
					"time": null,
					"until": "2023-02-11"
				},
				"tags": [],
				"updated_at": "2023-02-10T01:23:45.000Z",
				"user": {},
				"version": 1,
				"visualizations": [
					{
						"created_at": "2023-02-10T01:23:45.000Z",
						"description": "description",
						"id": 1,
						"name": "Table",
						"options": {},
						"type": "TABLE",
						"updated_at": "2023-02-10T01:23:45.000Z"
					}
				]
			}
		`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	res, err := client.CreateQuery(context.Background(), &redash.CreateQueryInput{
		DataSourceID: 1,
		Description:  "description",
		Name:         "my-query",
		Query:        "select 1",
		Schedule: &redash.CreateQueryInputSchedule{
			Interval: 60,
		},
	})
	assert.NoError(err)
	assert.Equal(&redash.Query{
		APIKey:            "api_key",
		CanEdit:           true,
		CreatedAt:         dateparse.MustParse("2023-02-10T01:23:45.000Z"),
		DataSourceID:      1,
		Description:       "description",
		ID:                1,
		IsArchived:        false,
		IsDraft:           false,
		IsFavorite:        false,
		IsSafe:            true,
		LastModifiedBy:    &redash.User{},
		LastModifiedByID:  0,
		LatestQueryDataID: 1,
		Name:              "my-query",
		Options:           redash.QueryOptions{Parameters: []redash.QueryOptionsParameter{}},
		Query:             "select 1",
		QueryHash:         "query_hash",
		RetrievedAt:       time.Time{},
		Runtime:           0,
		Schedule: &redash.QueueSchedule{
			DayOfWeek: "",
			Interval:  60,
			Time:      "",
			Until:     "2023-02-11",
		},
		Tags:      []string{},
		UpdatedAt: dateparse.MustParse("2023-02-10T01:23:45.000Z"),
		User:      redash.User{},
		Version:   1,
		Visualizations: []redash.Visualization{
			{
				CreatedAt:   dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				Description: "description",
				ID:          1,
				Name:        "Table",
				Options:     map[string]any{},
				Query:       redash.Query{},
				Type:        "TABLE",
				UpdatedAt:   dateparse.MustParse("2023-02-10T01:23:45.000Z"),
			},
		},
	}, res)
}

func Test_CreateQuery_OK_WithoutOmittingSchedule(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		require.NotNil(req.Body)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{"data_source_id":1,"description":"description","name":"my-query","query":"select 1","schedule":null}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, `{"id":1}`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.CreateQuery(context.Background(), &redash.CreateQueryInput{
		DataSourceID:            1,
		Description:             "description",
		Name:                    "my-query",
		Query:                   "select 1",
		WithoutOmittingSchedule: true,
	})
	assert.NoError(err)
}

func Test_CreateQuery_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.CreateQuery(context.Background(), &redash.CreateQueryInput{
		DataSourceID: 1,
		Description:  "description",
		Name:         "my-query",
		Query:        "select 1",
		Schedule: &redash.CreateQueryInputSchedule{
			Interval: 60,
		},
	})
	assert.ErrorContains(err, "POST api/queries failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_CreateQuery_IOErr(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries", func(req *http.Request) (*http.Response, error) {
		return testIOErrResp, nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.CreateQuery(context.Background(), &redash.CreateQueryInput{
		DataSourceID: 1,
		Description:  "description",
		Name:         "my-query",
		Query:        "select 1",
		Schedule: &redash.CreateQueryInputSchedule{
			Interval: 60,
		},
	})
	assert.ErrorContains(err, "read response body failed: IO error")
}

func Test_UpdateQuery_OK(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		require.NotNil(req.Body)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{"data_source_id":1,"description":"description","name":"my-query","query":"select 1","schedule":{"interval":60,"time":null,"until":null,"day_of_week":null}}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, `
			{
				"api_key": "api_key",
				"can_edit": true,
				"created_at": "2023-02-10T01:23:45.000Z",
				"data_source_id": 1,
				"description": "description",
				"id": 1,
				"is_archived": false,
				"is_draft": false,
				"is_favorite": false,
				"is_safe": true,
				"last_modified_by": {},
				"latest_query_data_id": 1,
				"name": "my-query",
				"options": {
					"parameters": []
				},
				"query": "select 1",
				"query_hash": "query_hash",
				"schedule": {
					"day_of_week": null,
					"interval": 60,
					"time": null,
					"until": "2023-02-11"
				},
				"tags": [],
				"updated_at": "2023-02-10T01:23:45.000Z",
				"user": {},
				"version": 1,
				"visualizations": [
					{
						"created_at": "2023-02-10T01:23:45.000Z",
						"description": "description",
						"id": 1,
						"name": "Table",
						"options": {},
						"type": "TABLE",
						"updated_at": "2023-02-10T01:23:45.000Z"
					}
				]
			}
		`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	res, err := client.UpdateQuery(context.Background(), 1, &redash.UpdateQueryInput{
		DataSourceID: 1,
		Description:  "description",
		Name:         "my-query",
		Query:        "select 1",
		Schedule: &redash.UpdateQueryInputSchedule{
			Interval: 60,
		},
	})
	assert.NoError(err)
	assert.Equal(&redash.Query{
		APIKey:            "api_key",
		CanEdit:           true,
		CreatedAt:         dateparse.MustParse("2023-02-10T01:23:45.000Z"),
		DataSourceID:      1,
		Description:       "description",
		ID:                1,
		IsArchived:        false,
		IsDraft:           false,
		IsFavorite:        false,
		IsSafe:            true,
		LastModifiedBy:    &redash.User{},
		LastModifiedByID:  0,
		LatestQueryDataID: 1,
		Name:              "my-query",
		Options:           redash.QueryOptions{Parameters: []redash.QueryOptionsParameter{}},
		Query:             "select 1",
		QueryHash:         "query_hash",
		RetrievedAt:       time.Time{},
		Runtime:           0,
		Schedule: &redash.QueueSchedule{
			DayOfWeek: "",
			Interval:  60,
			Time:      "",
			Until:     "2023-02-11",
		},
		Tags:      []string{},
		UpdatedAt: dateparse.MustParse("2023-02-10T01:23:45.000Z"),
		User:      redash.User{},
		Version:   1,
		Visualizations: []redash.Visualization{
			{
				CreatedAt:   dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				Description: "description",
				ID:          1,
				Name:        "Table",
				Options:     map[string]any{},
				Query:       redash.Query{},
				Type:        "TABLE",
				UpdatedAt:   dateparse.MustParse("2023-02-10T01:23:45.000Z"),
			},
		},
	}, res)
}

func Test_UpdateQuery_OK_Publish(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		require.NotNil(req.Body)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{"data_source_id":1,"description":"description","name":"my-query","query":"select 1","schedule":{"interval":60,"time":null,"until":null,"day_of_week":null},"is_draft":false}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, `
			{
				"api_key": "api_key",
				"can_edit": true,
				"created_at": "2023-02-10T01:23:45.000Z",
				"data_source_id": 1,
				"description": "description",
				"id": 1,
				"is_archived": false,
				"is_draft": false,
				"is_favorite": false,
				"is_safe": true,
				"last_modified_by": {},
				"latest_query_data_id": 1,
				"name": "my-query",
				"options": {
					"parameters": []
				},
				"query": "select 1",
				"query_hash": "query_hash",
				"schedule": {
					"day_of_week": null,
					"interval": 60,
					"time": null,
					"until": "2023-02-11"
				},
				"tags": [],
				"updated_at": "2023-02-10T01:23:45.000Z",
				"user": {},
				"version": 1,
				"visualizations": [
					{
						"created_at": "2023-02-10T01:23:45.000Z",
						"description": "description",
						"id": 1,
						"name": "Table",
						"options": {},
						"type": "TABLE",
						"updated_at": "2023-02-10T01:23:45.000Z"
					}
				]
			}
		`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	isDraft := false

	res, err := client.UpdateQuery(context.Background(), 1, &redash.UpdateQueryInput{
		DataSourceID: 1,
		Description:  "description",
		Name:         "my-query",
		Query:        "select 1",
		Schedule: &redash.UpdateQueryInputSchedule{
			Interval: 60,
		},
		IsDraft: &isDraft,
	})
	assert.NoError(err)
	assert.Equal(&redash.Query{
		APIKey:            "api_key",
		CanEdit:           true,
		CreatedAt:         dateparse.MustParse("2023-02-10T01:23:45.000Z"),
		DataSourceID:      1,
		Description:       "description",
		ID:                1,
		IsArchived:        false,
		IsDraft:           false,
		IsFavorite:        false,
		IsSafe:            true,
		LastModifiedBy:    &redash.User{},
		LastModifiedByID:  0,
		LatestQueryDataID: 1,
		Name:              "my-query",
		Options:           redash.QueryOptions{Parameters: []redash.QueryOptionsParameter{}},
		Query:             "select 1",
		QueryHash:         "query_hash",
		RetrievedAt:       time.Time{},
		Runtime:           0,
		Schedule: &redash.QueueSchedule{
			DayOfWeek: "",
			Interval:  60,
			Time:      "",
			Until:     "2023-02-11",
		},
		Tags:      []string{},
		UpdatedAt: dateparse.MustParse("2023-02-10T01:23:45.000Z"),
		User:      redash.User{},
		Version:   1,
		Visualizations: []redash.Visualization{
			{
				CreatedAt:   dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				Description: "description",
				ID:          1,
				Name:        "Table",
				Options:     map[string]any{},
				Query:       redash.Query{},
				Type:        "TABLE",
				UpdatedAt:   dateparse.MustParse("2023-02-10T01:23:45.000Z"),
			},
		},
	}, res)
}

func Test_UpdateQuery_OK_WithoutOmittingSchedule(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		require.NotNil(req.Body)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{"name":"my-query","schedule":null}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, `{"id":1}`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.UpdateQuery(context.Background(), 1, &redash.UpdateQueryInput{
		Name:                    "my-query",
		WithoutOmittingSchedule: true,
	})
	assert.NoError(err)
}

func Test_UpdateQuery_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.UpdateQuery(context.Background(), 1, &redash.UpdateQueryInput{
		DataSourceID: 1,
		Description:  "description",
		Name:         "my-query",
		Query:        "select 1",
		Schedule: &redash.UpdateQueryInputSchedule{
			Interval: 60,
		},
	})
	assert.ErrorContains(err, "POST api/queries/1 failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_UpdateQuery_IOErr(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1", func(req *http.Request) (*http.Response, error) {
		return testIOErrResp, nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.UpdateQuery(context.Background(), 1, &redash.UpdateQueryInput{
		DataSourceID: 1,
		Description:  "description",
		Name:         "my-query",
		Query:        "select 1",
		Schedule: &redash.UpdateQueryInputSchedule{
			Interval: 60,
		},
	})
	assert.ErrorContains(err, "read response body failed: IO error")
}

func Test_PublishQuery_OK(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		require.NotNil(req.Body)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{"is_draft":false}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, ``), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	err := client.PublishQuery(context.Background(), 1)
	assert.NoError(err)
}

func Test_PublishQuery_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	err := client.PublishQuery(context.Background(), 1)
	assert.ErrorContains(err, "POST api/queries/1 failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_UnpublishQuery_OK(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		require.NotNil(req.Body)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{"is_draft":true}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, ``), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	err := client.UnpublishQuery(context.Background(), 1)
	assert.NoError(err)
}

func Test_UnpublishQuery_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	err := client.UnpublishQuery(context.Background(), 1)
	assert.ErrorContains(err, "POST api/queries/1 failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_ArchiveQuery_OK(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodDelete, "https://redash.example.com/api/queries/1", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, ``), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	err := client.ArchiveQuery(context.Background(), 1)
	assert.NoError(err)
}

func Test_ArchiveQuery_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodDelete, "https://redash.example.com/api/queries/1", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	err := client.ArchiveQuery(context.Background(), 1)
	assert.ErrorContains(err, "DELETE api/queries/1 failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_CreateFavoriteQuery_OK(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/favorite", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, ``), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	err := client.CreateFavoriteQuery(context.Background(), 1)
	assert.NoError(err)
}

func Test_CreateFavoriteQuery_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/favorite", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusInternalServerError, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	err := client.CreateFavoriteQuery(context.Background(), 1)
	assert.ErrorContains(err, "POST api/queries/1/favorite failed: HTTP status code not OK: 500 Internal Server Error\nerror")
}

func Test_ForkQuery_OK(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/fork", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `
			{
				"api_key": "api_key",
				"can_edit": true,
				"created_at": "2023-02-10T01:23:45.000Z",
				"data_source_id": 1,
				"description": "description",
				"id": 1,
				"is_archived": false,
				"is_draft": false,
				"is_favorite": false,
				"is_safe": true,
				"last_modified_by": {},
				"latest_query_data_id": 1,
				"name": "my-query",
				"options": {
					"parameters": []
				},
				"query": "select 1",
				"query_hash": "query_hash",
				"schedule": {
					"day_of_week": null,
					"interval": 60,
					"time": null,
					"until": "2023-02-11"
				},
				"tags": [],
				"updated_at": "2023-02-10T01:23:45.000Z",
				"user": {},
				"version": 1,
				"visualizations": [
					{
						"created_at": "2023-02-10T01:23:45.000Z",
						"description": "description",
						"id": 1,
						"name": "Table",
						"options": {},
						"type": "TABLE",
						"updated_at": "2023-02-10T01:23:45.000Z"
					}
				]
			}
		`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	res, err := client.ForkQuery(context.Background(), 1)
	assert.NoError(err)
	assert.Equal(&redash.Query{
		APIKey:            "api_key",
		CanEdit:           true,
		CreatedAt:         dateparse.MustParse("2023-02-10T01:23:45.000Z"),
		DataSourceID:      1,
		Description:       "description",
		ID:                1,
		IsArchived:        false,
		IsDraft:           false,
		IsFavorite:        false,
		IsSafe:            true,
		LastModifiedBy:    &redash.User{},
		LastModifiedByID:  0,
		LatestQueryDataID: 1,
		Name:              "my-query",
		Options:           redash.QueryOptions{Parameters: []redash.QueryOptionsParameter{}},
		Query:             "select 1",
		QueryHash:         "query_hash",
		RetrievedAt:       time.Time{},
		Runtime:           0,
		Schedule: &redash.QueueSchedule{
			DayOfWeek: "",
			Interval:  60,
			Time:      "",
			Until:     "2023-02-11",
		},
		Tags:      []string{},
		UpdatedAt: dateparse.MustParse("2023-02-10T01:23:45.000Z"),
		User:      redash.User{},
		Version:   1,
		Visualizations: []redash.Visualization{
			{
				CreatedAt:   dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				Description: "description",
				ID:          1,
				Name:        "Table",
				Options:     map[string]any{},
				Query:       redash.Query{},
				Type:        "TABLE",
				UpdatedAt:   dateparse.MustParse("2023-02-10T01:23:45.000Z"),
			},
		},
	}, res)
}

func Test_ForkQuery_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/fork", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.ForkQuery(context.Background(), 1)
	assert.ErrorContains(err, "POST api/queries/1/fork failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_ForkQuery_IOErr(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/fork", func(req *http.Request) (*http.Response, error) {
		return testIOErrResp, nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.ForkQuery(context.Background(), 1)
	assert.ErrorContains(err, "read response body failed: IO error")
}

func Test_GetQueryResultsJSON_OK(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1/results.json", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `{"foo":"bar"}`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	err := client.GetQueryResultsJSON(context.Background(), 1, &buf)
	assert.NoError(err)
	assert.Equal(`{"foo":"bar"}`, buf.String())
}

func Test_GetQueryResultsJSON_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1/results.json", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	err := client.GetQueryResultsJSON(context.Background(), 1, &buf)
	assert.ErrorContains(err, "GET api/queries/1/results.json failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_GetQueryResultsJSON_IOErr(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1/results.json", func(req *http.Request) (*http.Response, error) {
		return testIOErrResp, nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	err := client.GetQueryResultsJSON(context.Background(), 1, &buf)
	assert.ErrorContains(err, "IO error")
}

func Test_JsonToGetQueryResultsOutput_OK(t *testing.T) {
	assert := assert.New(t)
	queryResult := `{"query_result": {"id": 73, "query_hash": "9c12398e42fb85a93a3b1c726f0844b4", "query": "select now()", "data": {"columns": [{"name": "now", "friendly_name": "now", "type": "datetime"}], "rows": [{"now": "2024-06-09T06:14:32.922Z"}]}, "data_source_id": 93, "runtime": 0.021225452423095703, "retrieved_at": "2024-06-09T06:14:32.930Z"}}`
	out, err := redash.JsonToGetQueryResultsOutput([]byte(queryResult))
	assert.NoError(err)
	assert.Equal(
		&redash.GetQueryResultsOutput{
			QueryResult: redash.GetQueryResultsOutputQueryResult{
				ID:        73,
				QueryHash: "9c12398e42fb85a93a3b1c726f0844b4",
				Query:     "select now()",
				Data: redash.GetQueryResultsOutputQueryResultData{
					Columns: []redash.GetQueryResultsOutputQueryResultDataColumn{
						{Name: "now", FriendlyName: "now", Type: "datetime"},
					},
					Rows: []map[string]interface{}{
						{"now": "2024-06-09T06:14:32.922Z"},
					},
				},
				DataSourceID: 93,
				Runtime:      0.021225452423095703,
				RetrievedAt:  time.Date(2024, time.June, 9, 6, 14, 32, 930000000, time.UTC),
			},
		},
		out,
	)
}

func Test_JsonToGetQueryResultsOutput_Err(t *testing.T) {
	assert := assert.New(t)
	_, err := redash.JsonToGetQueryResultsOutput([]byte(`}{`))
	assert.ErrorContains(err, "invalid character '}' looking for beginning of value")
}

func Test_GetQueryResultsStruct_OK(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1/results.json", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `{"query_result": {"id": 73, "query_hash": "9c12398e42fb85a93a3b1c726f0844b4", "query": "select now()", "data": {"columns": [{"name": "now", "friendly_name": "now", "type": "datetime"}], "rows": [{"now": "2024-06-09T06:14:32.922Z"}]}, "data_source_id": 93, "runtime": 0.021225452423095703, "retrieved_at": "2024-06-09T06:14:32.930Z"}}`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	out, err := client.GetQueryResultsStruct(context.Background(), 1)
	assert.NoError(err)
	assert.Equal(
		&redash.GetQueryResultsOutput{
			QueryResult: redash.GetQueryResultsOutputQueryResult{
				ID:        73,
				QueryHash: "9c12398e42fb85a93a3b1c726f0844b4",
				Query:     "select now()",
				Data: redash.GetQueryResultsOutputQueryResultData{
					Columns: []redash.GetQueryResultsOutputQueryResultDataColumn{
						{Name: "now", FriendlyName: "now", Type: "datetime"},
					},
					Rows: []map[string]interface{}{
						{"now": "2024-06-09T06:14:32.922Z"},
					},
				},
				DataSourceID: 93,
				Runtime:      0.021225452423095703,
				RetrievedAt:  time.Date(2024, time.June, 9, 6, 14, 32, 930000000, time.UTC),
			},
		},
		out,
	)
}

func Test_GetQueryResultsStruct_Err(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1/results.json", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `}{`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.GetQueryResultsStruct(context.Background(), 1)
	assert.ErrorContains(err, "invalid character '}' looking for beginning of value")
}

func Test_GetQueryResultsStruct_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1/results.json", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.GetQueryResultsStruct(context.Background(), 1)
	assert.ErrorContains(err, "GET api/queries/1/results.json failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_GetQueryResultsStruct_IOErr(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1/results.json", func(req *http.Request) (*http.Response, error) {
		return testIOErrResp, nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.GetQueryResultsStruct(context.Background(), 1)
	assert.ErrorContains(err, "IO error")
}

func Test_GetQueryResultsCSV_OK(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1/results.csv", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `foo,bar`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	err := client.GetQueryResultsCSV(context.Background(), 1, &buf)
	assert.NoError(err)
	assert.Equal(`foo,bar`, buf.String())
}

func Test_GetQueryResultsCSV_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1/results.csv", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	err := client.GetQueryResultsCSV(context.Background(), 1, &buf)
	assert.ErrorContains(err, "GET api/queries/1/results.csv failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_GetQueryResultsCSV_IOErr(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1/results.csv", func(req *http.Request) (*http.Response, error) {
		return testIOErrResp, nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	err := client.GetQueryResultsCSV(context.Background(), 1, &buf)
	assert.ErrorContains(err, "IO error")
}

func Test_GetQueryResults_OK(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1/results.json", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `{"foo":"bar"}`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	err := client.GetQueryResults(context.Background(), 1, "json", &buf)
	assert.NoError(err)
	assert.Equal(`{"foo":"bar"}`, buf.String())
}

func Test_GetQueryResults_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1/results.json", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	err := client.GetQueryResults(context.Background(), 1, "json", &buf)
	assert.ErrorContains(err, "GET api/queries/1/results.json failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_GetQueryResults_IOErr(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1/results.json", func(req *http.Request) (*http.Response, error) {
		return testIOErrResp, nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	err := client.GetQueryResults(context.Background(), 1, "json", &buf)
	assert.ErrorContains(err, "IO error")
}

func Test_GetQueryResults_OK_WithNil(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1/results.json", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `{"foo":"bar"}`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	err := client.GetQueryResults(context.Background(), 1, "json", nil)
	assert.ErrorContains(err, "out(io.Writer) is nil")
}

func Test_GetQueryResultByID_OK(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/query_results/1", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `{"foo":"bar"}`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	err := client.GetQueryResultByID(context.Background(), 1, "", &buf)
	assert.NoError(err)
	assert.Equal(`{"foo":"bar"}`, buf.String())
}

func Test_GetQueryResultByID_OK_WithExt(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/query_results/1.xlsx", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `{"foo":"bar"}`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	err := client.GetQueryResultByID(context.Background(), 1, "xlsx", &buf)
	assert.NoError(err)
	assert.Equal(`{"foo":"bar"}`, buf.String())
}

func Test_GetQueryResultByID_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/query_results/1.json", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	err := client.GetQueryResultByID(context.Background(), 1, "json", &buf)
	assert.ErrorContains(err, "GET api/query_results/1.json failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_GetQueryResultByID_IOErr(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/query_results/1", func(req *http.Request) (*http.Response, error) {
		return testIOErrResp, nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	err := client.GetQueryResultByID(context.Background(), 1, "", &buf)
	assert.ErrorContains(err, "IO error")
}

func Test_GetQueryResultByID_ArgErr(t *testing.T) {
	assert := assert.New(t)
	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	err := client.GetQueryResultByID(context.Background(), 1, "", nil)
	assert.ErrorContains(err, "out(io.Writer) is nil")
}

func Test_ExecQueryJSON_OK(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/results", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		require.NotNil(req.Body)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, `{"foo":"bar"}`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	jobId, err := client.ExecQueryJSON(context.Background(), 1, &redash.ExecQueryJSONInput{}, &buf)
	assert.NoError(err)
	assert.Equal(`{"foo":"bar"}`, buf.String())
	assert.Empty(jobId)
}

func Test_ExecQueryJSON_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/results", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	_, err := client.ExecQueryJSON(context.Background(), 1, &redash.ExecQueryJSONInput{}, &buf)
	assert.ErrorContains(err, "POST api/queries/1/results failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_ExecQueryJSON_IOErr(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/results", func(req *http.Request) (*http.Response, error) {
		return testIOErrResp, nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	_, err := client.ExecQueryJSON(context.Background(), 1, &redash.ExecQueryJSONInput{}, &buf)
	assert.ErrorContains(err, "IO error")
}

func Test_ExecQueryJSON_OK_WithNil(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/results", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		require.NotNil(req.Body)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, `{"foo":"bar"}`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	jobId, err := client.ExecQueryJSON(context.Background(), 1, &redash.ExecQueryJSONInput{}, nil)
	assert.NoError(err)
	assert.Empty(jobId)
}

func Test_ExecQueryJSON_OK_WithParams(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/results", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		require.NotNil(req.Body)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{"parameters":{"date_param":"2020-01-01","date_range_param":{"end":"2020-12-31","start":"2020-01-01"},"number_param":100},"apply_auto_limit":true,"max_age":1800}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, `{"foo":"bar"}`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	jobId, err := client.ExecQueryJSON(context.Background(), 1, &redash.ExecQueryJSONInput{
		Parameters: map[string]any{
			"number_param": 100,
			"date_param":   "2020-01-01",
			"date_range_param": map[string]string{
				"start": "2020-01-01",
				"end":   "2020-12-31",
			},
		},
		ApplyAutoLimit: true,
		MaxAge:         1800,
	}, &buf)
	assert.NoError(err)
	assert.Equal(`{"foo":"bar"}`, buf.String())
	assert.Empty(jobId)
}

func Test_ExecQueryJSON_OK_WithMaxAgeZero(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/results", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		require.NotNil(req.Body)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{"parameters":{"date_param":"2020-01-01","date_range_param":{"end":"2020-12-31","start":"2020-01-01"},"number_param":100},"apply_auto_limit":true,"max_age":0}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, `{"foo":"bar"}`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	jobId, err := client.ExecQueryJSON(context.Background(), 1, &redash.ExecQueryJSONInput{
		Parameters: map[string]any{
			"number_param": 100,
			"date_param":   "2020-01-01",
			"date_range_param": map[string]string{
				"start": "2020-01-01",
				"end":   "2020-12-31",
			},
		},
		ApplyAutoLimit:        true,
		WithoutOmittingMaxAge: true,
	}, &buf)
	assert.NoError(err)
	assert.Equal(`{"foo":"bar"}`, buf.String())
	assert.Empty(jobId)
}

func Test_ExecQueryJSON_ReturnJob(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/results", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		require.NotNil(req.Body)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, `{"job": {"status": 1, "error": "", "id": "623b290a-7fd9-4ea6-a2a6-96f9c9101f51", "query_result_id": null,	"status": 1, "updated_at": 0}}`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	job, err := client.ExecQueryJSON(context.Background(), 1, &redash.ExecQueryJSONInput{}, nil)
	assert.NoError(err)
	assert.Equal(&redash.JobResponse{
		Job: redash.Job{
			Error:         "",
			ID:            "623b290a-7fd9-4ea6-a2a6-96f9c9101f51",
			QueryResultID: 0,
			Status:        1,
			UpdatedAt:     float64(0),
		},
	}, job)
}

func Test_WaitQueryJSON_OK(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/results", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		require.NotNil(req.Body)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, `{"job": {"status": 1, "error": "", "id": "623b290a-7fd9-4ea6-a2a6-96f9c9101f51", "query_result_id": null,	"status": 1, "updated_at": 0}}`), nil
	})

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/jobs/623b290a-7fd9-4ea6-a2a6-96f9c9101f51", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `
			{
				"job": {
					"error": "",
					"id": "623b290a-7fd9-4ea6-a2a6-96f9c9101f51",
					"query_result_id": 1,
					"status": 3,
					"updated_at": 0
				}
			}
		`), nil
	})

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1/results.json", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `{"foo":"bar"}`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	job, err := client.ExecQueryJSON(context.Background(), 1, &redash.ExecQueryJSONInput{}, &buf)
	assert.NoError(err)
	err = client.WaitQueryJSON(context.Background(), 1, job, nil, &buf)
	assert.NoError(err)
	assert.Equal(`{"foo":"bar"}`, buf.String())
}

func Test_WaitQueryJSON_Err_GetJob(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/results", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		require.NotNil(req.Body)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, `{"job": {"status": 1, "error": "", "id": "623b290a-7fd9-4ea6-a2a6-96f9c9101f51", "query_result_id": null,	"status": 1, "updated_at": 0}}`), nil
	})

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/jobs/623b290a-7fd9-4ea6-a2a6-96f9c9101f51", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	job, err := client.ExecQueryJSON(context.Background(), 1, &redash.ExecQueryJSONInput{}, &buf)
	assert.NoError(err)
	err = client.WaitQueryJSON(context.Background(), 1, job, nil, &buf)
	assert.ErrorContains(err, "GET api/jobs/623b290a-7fd9-4ea6-a2a6-96f9c9101f51 failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_WaitQueryJSON_Err_GetQueryResultsJSON(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/results", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		require.NotNil(req.Body)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, `{"job": {"status": 1, "error": "", "id": "623b290a-7fd9-4ea6-a2a6-96f9c9101f51", "query_result_id": null,	"status": 1, "updated_at": 0}}`), nil
	})

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/jobs/623b290a-7fd9-4ea6-a2a6-96f9c9101f51", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `
			{
				"job": {
					"error": "",
					"id": "623b290a-7fd9-4ea6-a2a6-96f9c9101f51",
					"query_result_id": 1,
					"status": 3,
					"updated_at": 0
				}
			}
		`), nil
	})

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1/results.json", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	job, err := client.ExecQueryJSON(context.Background(), 1, &redash.ExecQueryJSONInput{}, &buf)
	assert.NoError(err)
	err = client.WaitQueryJSON(context.Background(), 1, job, nil, &buf)
	assert.ErrorContains(err, "GET api/queries/1/results.json failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_WaitQueryStruct_OK(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/results", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		require.NotNil(req.Body)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, `{"job": {"status": 1, "error": "", "id": "623b290a-7fd9-4ea6-a2a6-96f9c9101f51", "query_result_id": null,	"status": 1, "updated_at": 0}}`), nil
	})

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/jobs/623b290a-7fd9-4ea6-a2a6-96f9c9101f51", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `
			{
				"job": {
					"error": "",
					"id": "623b290a-7fd9-4ea6-a2a6-96f9c9101f51",
					"query_result_id": 1,
					"status": 3,
					"updated_at": 0
				}
			}
		`), nil
	})

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1/results.json", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `{"query_result": {"id": 73, "query_hash": "9c12398e42fb85a93a3b1c726f0844b4", "query": "select now()", "data": {"columns": [{"name": "now", "friendly_name": "now", "type": "datetime"}], "rows": [{"now": "2024-06-09T06:14:32.922Z"}]}, "data_source_id": 93, "runtime": 0.021225452423095703, "retrieved_at": "2024-06-09T06:14:32.930Z"}}`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	job, err := client.ExecQueryJSON(context.Background(), 1, &redash.ExecQueryJSONInput{}, &buf)
	assert.NoError(err)
	out, err := client.WaitQueryStruct(context.Background(), 1, job, nil, &buf)
	assert.NoError(err)
	assert.Equal(&redash.GetQueryResultsOutput{
		QueryResult: redash.GetQueryResultsOutputQueryResult{
			ID:        73,
			QueryHash: "9c12398e42fb85a93a3b1c726f0844b4",
			Query:     "select now()",
			Data: redash.GetQueryResultsOutputQueryResultData{
				Columns: []redash.GetQueryResultsOutputQueryResultDataColumn{
					{Name: "now", FriendlyName: "now", Type: "datetime"},
				},
				Rows: []map[string]interface{}{
					{"now": "2024-06-09T06:14:32.922Z"},
				},
			},
			DataSourceID: 93,
			Runtime:      0.021225452423095703,
			RetrievedAt:  time.Date(2024, time.June, 9, 6, 14, 32, 930000000, time.UTC),
		},
	}, out)
}

func Test_WaitQueryStruct_Err_WaitQueryJSON(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/results", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		require.NotNil(req.Body)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, `{"job": {"status": 1, "error": "", "id": "623b290a-7fd9-4ea6-a2a6-96f9c9101f51", "query_result_id": null,	"status": 1, "updated_at": 0}}`), nil
	})

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/jobs/623b290a-7fd9-4ea6-a2a6-96f9c9101f51", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	job, err := client.ExecQueryJSON(context.Background(), 1, &redash.ExecQueryJSONInput{}, &buf)
	assert.NoError(err)
	_, err = client.WaitQueryStruct(context.Background(), 1, job, nil, &buf)
	assert.ErrorContains(err, "GET api/jobs/623b290a-7fd9-4ea6-a2a6-96f9c9101f51 failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_WaitQueryStruct_JsonToGetQueryResultsOutput(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/results", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		require.NotNil(req.Body)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, `{"job": {"status": 1, "error": "", "id": "623b290a-7fd9-4ea6-a2a6-96f9c9101f51", "query_result_id": null,	"status": 1, "updated_at": 0}}`), nil
	})

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/jobs/623b290a-7fd9-4ea6-a2a6-96f9c9101f51", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `
			{
				"job": {
					"error": "",
					"id": "623b290a-7fd9-4ea6-a2a6-96f9c9101f51",
					"query_result_id": 1,
					"status": 3,
					"updated_at": 0
				}
			}
		`), nil
	})

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/1/results.json", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `}{`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	var buf bytes.Buffer
	job, err := client.ExecQueryJSON(context.Background(), 1, &redash.ExecQueryJSONInput{}, &buf)
	assert.NoError(err)
	_, err = client.WaitQueryStruct(context.Background(), 1, job, nil, &buf)
	assert.ErrorContains(err, "invalid character '}' looking for beginning of value")
}

func Test_GetQueryTags_OK(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/tags", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `
			{
				"tags": [
					{
						"count": 1,
						"name": "my-tag"
					}
				]
			}
		`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	res, err := client.GetQueryTags(context.Background())
	assert.NoError(err)
	assert.Equal(&redash.QueryTags{
		Tags: []redash.QueryTagsTag{
			{
				Name:  "my-tag",
				Count: 1,
			},
		},
	}, res)
}

func Test_GetQueryTags_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/tags", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.GetQueryTags(context.Background())
	assert.ErrorContains(err, "GET api/queries/tags failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_GetQueryTags_IOErr(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/tags", func(req *http.Request) (*http.Response, error) {
		return testIOErrResp, nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.GetQueryTags(context.Background())
	assert.ErrorContains(err, "read response body failed: IO error")
}

func Test_RefreshQuery_OK(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/refresh", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `
			{
				"job": {
					"error": "",
					"id": "baaf5b97-6419-4db3-a60c-ef8b4e290376",
					"query_result_id": null,
					"result": null,
					"status": 1,
					"updated_at": 0
				}
			}
		`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	job, err := client.RefreshQuery(context.Background(), 1, nil)
	assert.NoError(err)
	assert.Equal(&redash.JobResponse{
		Job: redash.Job{
			Error:         "",
			ID:            "baaf5b97-6419-4db3-a60c-ef8b4e290376",
			QueryResultID: 0,
			Status:        1,
			UpdatedAt:     float64(0),
		},
	}, job)
}

func Test_RefreshQuery_OK_WithInput(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/refresh", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{"apply_auto_limit":true}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, `
			{
				"job": {
					"error": "",
					"id": "baaf5b97-6419-4db3-a60c-ef8b4e290376",
					"query_result_id": null,
					"result": null,
					"status": 1,
					"updated_at": 0
				}
			}
		`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	job, err := client.RefreshQuery(context.Background(), 1, &redash.RefreshQueryInput{
		ApplyAutoLimit: true,
	})
	assert.NoError(err)
	assert.Equal(&redash.JobResponse{
		Job: redash.Job{
			Error:         "",
			ID:            "baaf5b97-6419-4db3-a60c-ef8b4e290376",
			QueryResultID: 0,
			Status:        1,
			UpdatedAt:     float64(0),
		},
	}, job)
}

func Test_RefreshQuery_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/refresh", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.RefreshQuery(context.Background(), 1, nil)
	assert.ErrorContains(err, "POST api/queries/1/refresh failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_RefreshQuery_IOErr(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/1/refresh", func(req *http.Request) (*http.Response, error) {
		return testIOErrResp, nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.RefreshQuery(context.Background(), 1, nil)
	assert.ErrorContains(err, "read response body failed: IO error")
}

func Test_SearchQueries_OK(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/search", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		assert.Equal("q=my-query", req.URL.Query().Encode())
		return httpmock.NewStringResponse(http.StatusOK, `
			{
				"count": 1,
				"page": 1,
				"page_size": 25,
				"results": [
					{
						"api_key": "api_key",
						"created_at": "2023-02-10T01:23:45.000Z",
						"data_source_id": 1,
						"description": "description",
						"id": 1,
						"is_archived": false,
						"is_draft": false,
						"is_favorite": false,
						"is_safe": true,
						"last_modified_by_id": 1,
						"latest_query_data_id": 1,
						"name": "my-query",
						"options": {
							"parameters": []
						},
						"query": "select 1",
						"query_hash": "query_hash",
						"retrieved_at": "2023-02-10T01:23:45.000Z",
						"runtime": 0.1,
						"schedule": {
							"day_of_week": null,
							"interval": 60,
							"time": null,
							"until": "2023-02-11"
						},
						"tags": [],
						"updated_at": "2023-02-10T01:23:45.000Z",
						"user": {},
						"version": 1
					}
				]
			}
		`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	res, err := client.SearchQueries(context.Background(), &redash.SearchQueriesInput{
		Q: "my-query",
	})
	assert.NoError(err)
	assert.Equal(&redash.QueryPage{
		Count:    1,
		Page:     1,
		PageSize: 25,
		Results: []redash.Query{
			{
				APIKey:            "api_key",
				CanEdit:           false,
				CreatedAt:         dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				DataSourceID:      1,
				Description:       "description",
				ID:                1,
				IsArchived:        false,
				IsDraft:           false,
				IsFavorite:        false,
				IsSafe:            true,
				LastModifiedBy:    nil,
				LastModifiedByID:  1,
				LatestQueryDataID: 1,
				Name:              "my-query",
				Options:           redash.QueryOptions{Parameters: []redash.QueryOptionsParameter{}},
				Query:             "select 1",
				QueryHash:         "query_hash",
				RetrievedAt:       dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				Runtime:           0.1,
				Schedule: &redash.QueueSchedule{
					DayOfWeek: "",
					Interval:  60,
					Time:      "",
					Until:     "2023-02-11",
				},
				Tags:           []string{},
				UpdatedAt:      dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				User:           redash.User{},
				Version:        1,
				Visualizations: nil,
			},
		},
	}, res)
}

func Test_SearchQueries_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/search", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.SearchQueries(context.Background(), &redash.SearchQueriesInput{
		Q: "my-query",
	})
	assert.ErrorContains(err, "GET api/queries/search failed: HTTP status code not OK: 503")
}

func Test_SearchQueries_IOErr(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/search", func(req *http.Request) (*http.Response, error) {
		return testIOErrResp, nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.SearchQueries(context.Background(), &redash.SearchQueriesInput{
		Q: "my-query",
	})
	assert.ErrorContains(err, "read response body failed: IO error")
}

func Test_ListMyQueries_OK(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/my", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		assert.Equal("page=1&page_size=25&q=my-query", req.URL.Query().Encode())
		return httpmock.NewStringResponse(http.StatusOK, `
			{
				"count": 1,
				"page": 1,
				"page_size": 25,
				"results": [
					{
						"api_key": "api_key",
						"created_at": "2023-02-10T01:23:45.000Z",
						"data_source_id": 1,
						"description": "description",
						"id": 1,
						"is_archived": false,
						"is_draft": false,
						"is_favorite": false,
						"is_safe": true,
						"last_modified_by_id": 1,
						"latest_query_data_id": 1,
						"name": "my-query",
						"options": {
							"parameters": []
						},
						"query": "select 1",
						"query_hash": "query_hash",
						"retrieved_at": "2023-02-10T01:23:45.000Z",
						"runtime": 0.1,
						"schedule": {
							"day_of_week": null,
							"interval": 60,
							"time": null,
							"until": "2023-02-11"
						},
						"tags": [],
						"updated_at": "2023-02-10T01:23:45.000Z",
						"user": {},
						"version": 1
					}
				]
			}
		`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	res, err := client.ListMyQueries(context.Background(), &redash.ListMyQueriesInput{
		Page:     1,
		PageSize: 25,
		Q:        "my-query",
	})
	assert.NoError(err)
	assert.Equal(&redash.QueryPage{
		Count:    1,
		Page:     1,
		PageSize: 25,
		Results: []redash.Query{
			{
				APIKey:            "api_key",
				CanEdit:           false,
				CreatedAt:         dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				DataSourceID:      1,
				Description:       "description",
				ID:                1,
				IsArchived:        false,
				IsDraft:           false,
				IsFavorite:        false,
				IsSafe:            true,
				LastModifiedBy:    nil,
				LastModifiedByID:  1,
				LatestQueryDataID: 1,
				Name:              "my-query",
				Options:           redash.QueryOptions{Parameters: []redash.QueryOptionsParameter{}},
				Query:             "select 1",
				QueryHash:         "query_hash",
				RetrievedAt:       dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				Runtime:           0.1,
				Schedule: &redash.QueueSchedule{
					DayOfWeek: "",
					Interval:  60,
					Time:      "",
					Until:     "2023-02-11",
				},
				Tags:           []string{},
				UpdatedAt:      dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				User:           redash.User{},
				Version:        1,
				Visualizations: nil,
			},
		},
	}, res)
}

func Test_ListMyQueries_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/my", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.ListMyQueries(context.Background(), &redash.ListMyQueriesInput{
		Page:     1,
		PageSize: 25,
		Q:        "my-query",
	})
	assert.ErrorContains(err, "GET api/queries/my failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_ListMyQueries_IOErr(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/my", func(req *http.Request) (*http.Response, error) {
		return testIOErrResp, nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.ListMyQueries(context.Background(), &redash.ListMyQueriesInput{
		Page:     1,
		PageSize: 25,
		Q:        "my-query",
	})
	assert.ErrorContains(err, "read response body failed: IO error")
}

func Test_ListFavoriteQueries_OK(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/favorites", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		assert.Equal("page=1&page_size=25&q=my-query", req.URL.Query().Encode())
		return httpmock.NewStringResponse(http.StatusOK, `
			{
				"count": 1,
				"page": 1,
				"page_size": 25,
				"results": [
					{
						"api_key": "api_key",
						"created_at": "2023-02-10T01:23:45.000Z",
						"data_source_id": 1,
						"description": "description",
						"id": 1,
						"is_archived": false,
						"is_draft": false,
						"is_favorite": false,
						"is_safe": true,
						"last_modified_by_id": 1,
						"latest_query_data_id": 1,
						"name": "my-query",
						"options": {
							"parameters": []
						},
						"query": "select 1",
						"query_hash": "query_hash",
						"retrieved_at": "2023-02-10T01:23:45.000Z",
						"runtime": 0.1,
						"schedule": {
							"day_of_week": null,
							"interval": 60,
							"time": null,
							"until": "2023-02-11"
						},
						"tags": [],
						"updated_at": "2023-02-10T01:23:45.000Z",
						"user": {},
						"version": 1
					}
				]
			}
		`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	res, err := client.ListFavoriteQueries(context.Background(), &redash.ListFavoriteQueriesInput{
		Page:     1,
		PageSize: 25,
		Q:        "my-query",
	})
	assert.NoError(err)
	assert.Equal(&redash.QueryPage{
		Count:    1,
		Page:     1,
		PageSize: 25,
		Results: []redash.Query{
			{
				APIKey:            "api_key",
				CanEdit:           false,
				CreatedAt:         dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				DataSourceID:      1,
				Description:       "description",
				ID:                1,
				IsArchived:        false,
				IsDraft:           false,
				IsFavorite:        false,
				IsSafe:            true,
				LastModifiedBy:    nil,
				LastModifiedByID:  1,
				LatestQueryDataID: 1,
				Name:              "my-query",
				Options:           redash.QueryOptions{Parameters: []redash.QueryOptionsParameter{}},
				Query:             "select 1",
				QueryHash:         "query_hash",
				RetrievedAt:       dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				Runtime:           0.1,
				Schedule: &redash.QueueSchedule{
					DayOfWeek: "",
					Interval:  60,
					Time:      "",
					Until:     "2023-02-11",
				},
				Tags:           []string{},
				UpdatedAt:      dateparse.MustParse("2023-02-10T01:23:45.000Z"),
				User:           redash.User{},
				Version:        1,
				Visualizations: nil,
			},
		},
	}, res)
}

func Test_ListFavoriteQueries_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/favorites", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.ListFavoriteQueries(context.Background(), &redash.ListFavoriteQueriesInput{
		Page:     1,
		PageSize: 25,
		Q:        "my-query",
	})
	assert.ErrorContains(err, "GET api/queries/favorites failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_ListFavoriteQueries_IOErr(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/favorites", func(req *http.Request) (*http.Response, error) {
		return testIOErrResp, nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.ListFavoriteQueries(context.Background(), &redash.ListFavoriteQueriesInput{
		Page:     1,
		PageSize: 25,
		Q:        "my-query",
	})
	assert.ErrorContains(err, "read response body failed: IO error")
}

func Test_FormatQuery_OK(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/format", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		require.NotNil(req.Body)
		body, _ := io.ReadAll(req.Body)
		assert.Equal(`{"query":"select 1 from dual"}`, string(body))
		return httpmock.NewStringResponse(http.StatusOK, `
			{
				"query": "SELECT 1\nFROM dual"
			}
		`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	res, err := client.FormatQuery(context.Background(), "select 1 from dual")
	assert.NoError(err)
	assert.Equal(&redash.FormatQueryOutput{
		Query: "SELECT 1\nFROM dual",
	}, res)
}

func Test_FormatQuery_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/format", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.FormatQuery(context.Background(), "select 1 from dual")
	assert.ErrorContains(err, "POST api/queries/format failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_FormatQuery_IOErr(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodPost, "https://redash.example.com/api/queries/format", func(req *http.Request) (*http.Response, error) {
		return testIOErrResp, nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.FormatQuery(context.Background(), "select 1 from dual")
	assert.ErrorContains(err, "read response body failed: IO error")
}

func Test_ListRecentQueries_OK(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/recent", func(req *http.Request) (*http.Response, error) {
		assert.Equal(
			http.Header(
				http.Header{
					"Authorization": []string{"Key " + testRedashAPIKey},
					"Content-Type":  []string{"application/json"},
					"User-Agent":    []string{"redash-go"},
				},
			),
			req.Header,
		)
		return httpmock.NewStringResponse(http.StatusOK, `
			[
				{
					"api_key": "api_key",
					"created_at": "2023-02-10T01:23:45.000Z",
					"data_source_id": 1,
					"description": "description",
					"id": 1,
					"is_archived": false,
					"is_draft": false,
					"is_favorite": false,
					"is_safe": true,
					"last_modified_by_id": 1,
					"latest_query_data_id": 1,
					"name": "my-query",
					"options": {
						"parameters": []
					},
					"query": "select 1",
					"query_hash": "query_hash",
					"retrieved_at": "2023-02-10T01:23:45.000Z",
					"runtime": 0.1,
					"schedule": {
						"day_of_week": null,
						"interval": 60,
						"time": null,
						"until": "2023-02-11"
					},
					"tags": [],
					"updated_at": "2023-02-10T01:23:45.000Z",
					"user": {},
					"version": 1
				}
			]
		`), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	res, err := client.ListRecentQueries(context.Background())
	assert.NoError(err)
	assert.Equal([]redash.Query{
		{
			APIKey:            "api_key",
			CanEdit:           false,
			CreatedAt:         dateparse.MustParse("2023-02-10T01:23:45.000Z"),
			DataSourceID:      1,
			Description:       "description",
			ID:                1,
			IsArchived:        false,
			IsDraft:           false,
			IsFavorite:        false,
			IsSafe:            true,
			LastModifiedBy:    nil,
			LastModifiedByID:  1,
			LatestQueryDataID: 1,
			Name:              "my-query",
			Options:           redash.QueryOptions{Parameters: []redash.QueryOptionsParameter{}},
			Query:             "select 1",
			QueryHash:         "query_hash",
			RetrievedAt:       dateparse.MustParse("2023-02-10T01:23:45.000Z"),
			Runtime:           0.1,
			Schedule: &redash.QueueSchedule{
				DayOfWeek: "",
				Interval:  60,
				Time:      "",
				Until:     "2023-02-11",
			},
			Tags:           []string{},
			UpdatedAt:      dateparse.MustParse("2023-02-10T01:23:45.000Z"),
			User:           redash.User{},
			Version:        1,
			Visualizations: nil,
		},
	}, res)
}

func Test_ListRecentQueries_Err_5xx(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/recent", func(req *http.Request) (*http.Response, error) {
		return httpmock.NewStringResponse(http.StatusServiceUnavailable, "error"), nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.ListRecentQueries(context.Background())
	assert.ErrorContains(err, "GET api/queries/recent failed: HTTP status code not OK: 503 Service Unavailable\nerror")
}

func Test_ListRecentQueries_IOErr(t *testing.T) {
	assert := assert.New(t)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(http.MethodGet, "https://redash.example.com/api/queries/recent", func(req *http.Request) (*http.Response, error) {
		return testIOErrResp, nil
	})

	client, _ := redash.NewClient("https://redash.example.com", testRedashAPIKey)
	_, err := client.ListRecentQueries(context.Background())
	assert.ErrorContains(err, "read response body failed: IO error")
}

func Test_Query_Acc(t *testing.T) {
	if !testAcc {
		t.Skip()
	}

	assert := assert.New(t)
	require := require.New(t)
	client, _ := redash.NewClient(testRedashEndpoint, testRedashAPIKey)
	ds, err := client.CreateDataSource(context.Background(), &redash.CreateDataSourceInput{
		Name: "test-postgres-1",
		Type: "pg",
		Options: map[string]any{
			"dbname": "postgres",
			"host":   "postgres",
			"port":   5432,
			"user":   "postgres",
		},
	})
	require.NoError(err)

	defer func() {
		client.DeleteDataSource(context.Background(), ds.ID) //nolint:errcheck
	}()

	_, err = client.ListQueries(context.Background(), nil)
	require.NoError(err)

	query, err := client.CreateQuery(context.Background(), &redash.CreateQueryInput{
		DataSourceID: ds.ID,
		Name:         "test-query-1",
		Query:        "select 1",
		Tags:         []string{"my-tag-1"},
	})
	require.NoError(err)
	assert.Equal("test-query-1", query.Name)
	assert.Equal([]string{"my-tag-1"}, query.Tags)
	assert.True(query.IsDraft)

	isDraft := false
	query, err = client.UpdateQuery(context.Background(), query.ID, &redash.UpdateQueryInput{
		Schedule: &redash.UpdateQueryInputSchedule{
			Interval: 600,
		},
		Tags:    &[]string{"my-tag-2"},
		IsDraft: &isDraft,
	})
	require.NoError(err)
	assert.Equal(&redash.QueueSchedule{Interval: 600}, query.Schedule)
	assert.Equal([]string{"my-tag-2"}, query.Tags)
	assert.False(query.IsDraft)

	query, err = client.UpdateQuery(context.Background(), query.ID, &redash.UpdateQueryInput{
		Schedule: &redash.UpdateQueryInputSchedule{
			Interval: 600,
		},
	})
	require.NoError(err)
	assert.Equal(&redash.QueueSchedule{Interval: 600}, query.Schedule)
	assert.Equal([]string{"my-tag-2"}, query.Tags)

	tags, err := client.GetQueryTags(context.Background())
	require.NoError(err)
	assert.GreaterOrEqual(len(tags.Tags), 1)

	query, err = client.UpdateQuery(context.Background(), query.ID, &redash.UpdateQueryInput{
		Tags: &[]string{},
	})
	require.NoError(err)
	assert.Equal("test-query-1", query.Name)
	assert.Equal(&redash.QueueSchedule{Interval: 600}, query.Schedule)
	assert.Equal([]string{}, query.Tags)

	tags, err = client.GetQueryTags(context.Background())
	require.NoError(err)
	assert.GreaterOrEqual(len(tags.Tags), 0)

	query, err = client.GetQuery(context.Background(), query.ID)
	require.NoError(err)
	assert.Equal("test-query-1", query.Name)

	page, err := client.SearchQueries(context.Background(), &redash.SearchQueriesInput{
		Q: "test-query-1",
	})
	require.NoError(err)
	assert.GreaterOrEqual(len(page.Results), 1)

	page, err = client.ListQueries(context.Background(), &redash.ListQueriesInput{
		Q: "test-query-1",
	})
	require.NoError(err)
	assert.GreaterOrEqual(len(page.Results), 1)

	page, err = client.ListMyQueries(context.Background(), &redash.ListMyQueriesInput{
		Q: "test-query-1",
	})
	require.NoError(err)
	assert.GreaterOrEqual(len(page.Results), 1)

	page, err = client.ListFavoriteQueries(context.Background(), &redash.ListFavoriteQueriesInput{
		Q: "test-query-1",
	})
	require.NoError(err)
	assert.Zero(len(page.Results))

	err = client.CreateFavoriteQuery(context.Background(), query.ID)
	require.NoError(err)

	page, err = client.ListFavoriteQueries(context.Background(), &redash.ListFavoriteQueriesInput{
		Q: "test-query-1",
	})
	require.NoError(err)
	assert.GreaterOrEqual(len(page.Results), 1)

	var buf bytes.Buffer
	job, err := client.ExecQueryJSON(context.Background(), query.ID, &redash.ExecQueryJSONInput{}, &buf)
	require.NoError(err)

	if job != nil && job.Job.ID != "" {
		for {
			job, err := client.GetJob(context.Background(), job.Job.ID)
			require.NoError(err)

			if job.Job.Status != redash.JobStatusPending && job.Job.Status != redash.JobStatusStarted {
				assert.Equal(redash.JobStatusSuccess, job.Job.Status)
				buf = bytes.Buffer{}
				err = client.GetQueryResultsJSON(context.Background(), query.ID, &buf)
				require.NoError(err)
				break
			}

			time.Sleep(1 * time.Second)
		}
	}

	assert.True(strings.HasPrefix(buf.String(), `{"query_result"`))

	{
		var rs map[string]map[string]any
		err := json.Unmarshal(buf.Bytes(), &rs)
		require.NoError(err)
		qeuryResultID := rs["query_result"]["id"].(float64)
		var buf bytes.Buffer
		err = client.GetQueryResultByID(context.Background(), int(qeuryResultID), "csv", &buf)
		require.NoError(err)
		assert.Equal("?column?\r\n1\r\n", buf.String())
	}

	_, err = client.ExecQueryJSON(context.Background(), query.ID, nil, nil)
	require.NoError(err)

	buf = bytes.Buffer{}
	err = client.GetQueryResultsCSV(context.Background(), query.ID, &buf)
	require.NoError(err)
	assert.Equal("?column?\r\n1\r\n", buf.String())

	job, err = client.RefreshQuery(context.Background(), query.ID, nil)
	require.NoError(err)

	if job != nil && job.Job.ID != "" {
		for {
			job, err := client.GetJob(context.Background(), job.Job.ID)
			require.NoError(err)

			if job.Job.Status != redash.JobStatusPending && job.Job.Status != redash.JobStatusStarted {
				assert.Equal(redash.JobStatusSuccess, job.Job.Status)
				buf = bytes.Buffer{}
				_, err := client.ExecQueryJSON(context.Background(), query.ID, nil, &buf)
				require.NoError(err)
				break
			}

			time.Sleep(1 * time.Second)
		}
	}

	assert.True(strings.HasPrefix(buf.String(), `{"query_result"`))

	job, err = client.RefreshQuery(context.Background(), query.ID, &redash.RefreshQueryInput{
		ApplyAutoLimit: true,
	})
	require.NoError(err)

	if job != nil && job.Job.ID != "" {
		for {
			job, err := client.GetJob(context.Background(), job.Job.ID)
			require.NoError(err)

			if job.Job.Status != redash.JobStatusPending && job.Job.Status != redash.JobStatusStarted {
				assert.Equal(redash.JobStatusSuccess, job.Job.Status)
				buf = bytes.Buffer{}
				_, err := client.ExecQueryJSON(context.Background(), query.ID, nil, &buf)
				require.NoError(err)
				break
			}

			time.Sleep(1 * time.Second)
		}
	}

	assert.True(strings.HasPrefix(buf.String(), `{"query_result"`))

	queries, err := client.ListRecentQueries(context.Background())
	require.NoError(err)
	assert.GreaterOrEqual(len(queries), 1)

	err = client.UnpublishQuery(context.Background(), query.ID)
	require.NoError(err)

	query, err = client.GetQuery(context.Background(), query.ID)
	require.NoError(err)
	assert.Equal("test-query-1", query.Name)
	assert.True(query.IsDraft)

	err = client.PublishQuery(context.Background(), query.ID)
	require.NoError(err)

	query, err = client.GetQuery(context.Background(), query.ID)
	require.NoError(err)
	assert.Equal("test-query-1", query.Name)
	assert.False(query.IsDraft)

	err = client.ArchiveQuery(context.Background(), query.ID)
	require.NoError(err)

	query, err = client.GetQuery(context.Background(), query.ID)
	require.NoError(err)
	assert.Equal("test-query-1", query.Name)
	assert.True(query.IsArchived)
	assert.True(query.IsFavorite)

	formatted, err := client.FormatQuery(context.Background(), "select 1 from dual")
	require.NoError(err)
	assert.Equal("SELECT 1\nFROM dual", formatted.Query)
}

func Test_Query_IgnoreCache_Acc(t *testing.T) {
	if !testAcc {
		t.Skip()
	}

	assert := assert.New(t)
	require := require.New(t)
	client, _ := redash.NewClient(testRedashEndpoint, testRedashAPIKey)
	ds, err := client.CreateDataSource(context.Background(), &redash.CreateDataSourceInput{
		Name: "test-postgres-1",
		Type: "pg",
		Options: map[string]any{
			"dbname": "postgres",
			"host":   "postgres",
			"port":   5432,
			"user":   "postgres",
		},
	})
	require.NoError(err)

	defer func() {
		client.DeleteDataSource(context.Background(), ds.ID) //nolint:errcheck
	}()

	_, err = client.ListQueries(context.Background(), nil)
	require.NoError(err)

	query, err := client.CreateQuery(context.Background(), &redash.CreateQueryInput{
		DataSourceID: ds.ID,
		Name:         "test-query-1",
		Query:        "select now()",
	})
	require.NoError(err)
	assert.Equal("test-query-1", query.Name)

	query, err = client.GetQuery(context.Background(), query.ID)
	require.NoError(err)
	assert.Equal("test-query-1", query.Name)
	assert.Equal("select now()", query.Query)
	assert.Equal(redash.QueryOptions{}, query.Options)
	rNow := regexp.MustCompile(`"now": "([^"]+)"`)
	var cachedNow string

	// Cache 1
	{
		var buf bytes.Buffer
		input := &redash.ExecQueryJSONInput{
			MaxAge: 1800,
		}
		job, err := client.ExecQueryJSON(context.Background(), query.ID, input, &buf)
		require.NoError(err)

		if job != nil && job.Job.ID != "" {
			for {
				job, err := client.GetJob(context.Background(), job.Job.ID)
				require.NoError(err)

				if job.Job.Status != redash.JobStatusPending && job.Job.Status != redash.JobStatusStarted {
					assert.Equal(redash.JobStatusSuccess, job.Job.Status)
					_, err := client.ExecQueryJSON(context.Background(), query.ID, input, &buf)
					require.NoError(err)
					break
				}

				time.Sleep(1 * time.Second)
			}
		}

		require.Contains(buf.String(), `"rows": [{"now": "`)
		m := rNow.FindStringSubmatch(buf.String())
		cachedNow = m[1]
	}

	{
		out, err := client.GetQueryResultsStruct(context.Background(), query.ID)
		require.NoError(err)
		require.Len(out.QueryResult.Data.Rows, 1)
		now, ok := out.QueryResult.Data.Rows[0]["now"].(string)
		require.True(ok)
		assert.Equal(cachedNow, now)
	}

	{
		out, err := client.GetQueryResultsStruct(context.Background(), query.ID)
		require.NoError(err)
		require.Len(out.QueryResult.Data.Rows, 1)
		now, ok := out.QueryResult.Data.Rows[0]["now"].(string)
		require.True(ok)
		assert.Equal(cachedNow, now)
	}

	// Cache 2
	{
		var buf bytes.Buffer
		job, err := client.ExecQueryJSON(context.Background(), query.ID, nil, &buf)
		require.NoError(err)
		require.Nil(job) // Get results from cache
		require.Contains(buf.String(), `"rows": [{"now": "`)
		m := rNow.FindStringSubmatch(buf.String())
		assert.Equal(cachedNow, m[1])
	}

	{
		out, err := client.GetQueryResultsStruct(context.Background(), query.ID)
		require.NoError(err)
		require.Len(out.QueryResult.Data.Rows, 1)
		now, ok := out.QueryResult.Data.Rows[0]["now"].(string)
		require.True(ok)
		assert.Equal(cachedNow, now)
	}

	// Ignore cache
	{
		var buf bytes.Buffer
		input := &redash.ExecQueryJSONInput{
			WithoutOmittingMaxAge: true,
		}
		job, err := client.ExecQueryJSON(context.Background(), query.ID, input, &buf)
		require.NoError(err)

		if job != nil && job.Job.ID != "" {
			for {
				job, err := client.GetJob(context.Background(), job.Job.ID)
				require.NoError(err)

				if job.Job.Status != redash.JobStatusPending && job.Job.Status != redash.JobStatusStarted {
					assert.Equal(redash.JobStatusSuccess, job.Job.Status)
					_, err := client.ExecQueryJSON(context.Background(), query.ID, input, &buf)
					require.NoError(err)
					break
				}

				time.Sleep(1 * time.Second)
			}
		}

		// NOTE: No result is returned if `max_age=0`.
		//       I don't know if this is the spec.
		assert.Empty(buf.String())
	}

	{
		out, err := client.GetQueryResultsStruct(context.Background(), query.ID)
		require.NoError(err)
		require.Len(out.QueryResult.Data.Rows, 1)
		now, ok := out.QueryResult.Data.Rows[0]["now"].(string)
		require.True(ok)
		assert.NotEqual(cachedNow, now)
	}
}

func Test_WaitQueryJSON_Acc(t *testing.T) {
	if !testAcc {
		t.Skip()
	}

	assert := assert.New(t)
	require := require.New(t)
	client, _ := redash.NewClient(testRedashEndpoint, testRedashAPIKey)
	ds, err := client.CreateDataSource(context.Background(), &redash.CreateDataSourceInput{
		Name: "test-postgres-1",
		Type: "pg",
		Options: map[string]any{
			"dbname": "postgres",
			"host":   "postgres",
			"port":   5432,
			"user":   "postgres",
		},
	})
	require.NoError(err)

	defer func() {
		client.DeleteDataSource(context.Background(), ds.ID) //nolint:errcheck
	}()

	_, err = client.ListQueries(context.Background(), nil)
	require.NoError(err)

	query, err := client.CreateQuery(context.Background(), &redash.CreateQueryInput{
		DataSourceID: ds.ID,
		Name:         "test-query-1",
		Query:        "select 1",
	})
	require.NoError(err)
	assert.Equal("test-query-1", query.Name)

	var buf bytes.Buffer
	job, err := client.ExecQueryJSON(context.Background(), query.ID, nil, &buf)
	require.NoError(err)
	err = client.WaitQueryJSON(context.Background(), query.ID, job, nil, &buf)
	require.NoError(err)
	assert.True(strings.HasPrefix(buf.String(), `{"query_result"`))

	buf.Reset()
	job, err = client.ExecQueryJSON(context.Background(), query.ID, nil, &buf)
	require.NoError(err)
	err = client.WaitQueryJSON(context.Background(), query.ID, job, &redash.WaitQueryJSONOption{
		WaitStatuses: []int{redash.JobStatusPending, redash.JobStatusStarted},
		Interval:     500 * time.Microsecond,
	}, &buf)
	require.NoError(err)
	assert.True(strings.HasPrefix(buf.String(), `{"query_result"`))
}

func Test_WaitQueryStruct_Acc(t *testing.T) {
	if !testAcc {
		t.Skip()
	}

	assert := assert.New(t)
	require := require.New(t)
	client, _ := redash.NewClient(testRedashEndpoint, testRedashAPIKey)
	ds, err := client.CreateDataSource(context.Background(), &redash.CreateDataSourceInput{
		Name: "test-postgres-1",
		Type: "pg",
		Options: map[string]any{
			"dbname": "postgres",
			"host":   "postgres",
			"port":   5432,
			"user":   "postgres",
		},
	})
	require.NoError(err)

	defer func() {
		client.DeleteDataSource(context.Background(), ds.ID) //nolint:errcheck
	}()

	_, err = client.ListQueries(context.Background(), nil)
	require.NoError(err)

	query, err := client.CreateQuery(context.Background(), &redash.CreateQueryInput{
		DataSourceID: ds.ID,
		Name:         "test-query-1",
		Query:        "select 1",
	})
	require.NoError(err)
	assert.Equal("test-query-1", query.Name)

	var buf bytes.Buffer
	job, err := client.ExecQueryJSON(context.Background(), query.ID, nil, &buf)
	require.NoError(err)
	out, err := client.WaitQueryStruct(context.Background(), query.ID, job, &redash.WaitQueryJSONOption{
		WaitStatuses: []int{redash.JobStatusPending, redash.JobStatusStarted},
		Interval:     500 * time.Microsecond,
	}, &buf)
	require.NoError(err)
	assert.Equal("select 1", out.QueryResult.Query)
}