// Copyright 2022 The go-github AUTHORS. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package github

import (
	"fmt"
	"net/http"
	"testing"

	"github.com/google/go-cmp/cmp"
)

func TestActionsService_ListCaches(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/repos/o/r/actions/caches", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		testFormValues(t, r, values{"page": "2"})
		fmt.Fprint(w,
			`{
				"total_count":1,
				"actions_caches":[{"id":1}]
			}`,
		)
	})

	opts := &ActionsCacheListOptions{ListOptions: ListOptions{Page: 2}}
	ctx := t.Context()
	cacheList, _, err := client.Actions.ListCaches(ctx, "o", "r", opts)
	if err != nil {
		t.Errorf("Actions.ListCaches returned error: %v", err)
	}

	want := &ActionsCacheList{TotalCount: 1, ActionsCaches: []*ActionsCache{{ID: new(int64(1))}}}
	if !cmp.Equal(cacheList, want) {
		t.Errorf("Actions.ListCaches returned %+v, want %+v", cacheList, want)
	}

	const methodName = "ListCaches"
	testBadOptions(t, methodName, func() (err error) {
		_, _, err = client.Actions.ListCaches(ctx, "\n", "\n", opts)
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		got, resp, err := client.Actions.ListCaches(ctx, "o", "r", opts)
		if got != nil {
			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
		}
		return resp, err
	})
}

func TestActionsService_ListCaches_invalidOwner(t *testing.T) {
	t.Parallel()
	client, _, _ := setup(t)

	ctx := t.Context()
	_, _, err := client.Actions.ListCaches(ctx, "%", "r", nil)
	testURLParseError(t, err)
}

func TestActionsService_ListCaches_invalidRepo(t *testing.T) {
	t.Parallel()
	client, _, _ := setup(t)

	ctx := t.Context()
	_, _, err := client.Actions.ListCaches(ctx, "o", "%", nil)
	testURLParseError(t, err)
}

func TestActionsService_ListCaches_notFound(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/repos/o/r/actions/caches", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		w.WriteHeader(http.StatusNotFound)
	})

	ctx := t.Context()
	caches, resp, err := client.Actions.ListCaches(ctx, "o", "r", nil)
	if err == nil {
		t.Error("Expected HTTP 404 response")
	}
	if got, want := resp.Response.StatusCode, http.StatusNotFound; got != want {
		t.Errorf("Actions.ListCaches return status %v, want %v", got, want)
	}
	if caches != nil {
		t.Errorf("Actions.ListCaches return %+v, want nil", caches)
	}
}

func TestActionsService_DeleteCachesByKey(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/repos/o/r/actions/caches", func(_ http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "DELETE")
		testFormValues(t, r, values{"key": "1", "ref": "main"})
	})

	ctx := t.Context()
	_, err := client.Actions.DeleteCachesByKey(ctx, "o", "r", "1", new("main"))
	if err != nil {
		t.Errorf("Actions.DeleteCachesByKey return error: %v", err)
	}

	const methodName = "DeleteCachesByKey"
	testBadOptions(t, methodName, func() (err error) {
		_, err = client.Actions.DeleteCachesByKey(ctx, "\n", "\n", "\n", new("\n"))
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		return client.Actions.DeleteCachesByKey(ctx, "o", "r", "1", new("main"))
	})
}

func TestActionsService_DeleteCachesByKey_invalidOwner(t *testing.T) {
	t.Parallel()
	client, _, _ := setup(t)

	ctx := t.Context()
	_, err := client.Actions.DeleteCachesByKey(ctx, "%", "r", "1", new("main"))
	testURLParseError(t, err)
}

func TestActionsService_DeleteCachesByKey_invalidRepo(t *testing.T) {
	t.Parallel()
	client, _, _ := setup(t)

	ctx := t.Context()
	_, err := client.Actions.DeleteCachesByKey(ctx, "o", "%", "1", new("main"))
	testURLParseError(t, err)
}

func TestActionsService_DeleteCachesByKey_notFound(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/repos/o/r/actions/artifacts/1", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "DELETE")
		w.WriteHeader(http.StatusNotFound)
	})

	ctx := t.Context()
	resp, err := client.Actions.DeleteCachesByKey(ctx, "o", "r", "1", new("main"))
	if err == nil {
		t.Error("Expected HTTP 404 response")
	}
	if got, want := resp.Response.StatusCode, http.StatusNotFound; got != want {
		t.Errorf("Actions.DeleteCachesByKey return status %v, want %v", got, want)
	}
}

func TestActionsService_DeleteCachesByID(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/repos/o/r/actions/caches/1", func(_ http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "DELETE")
	})

	ctx := t.Context()
	_, err := client.Actions.DeleteCachesByID(ctx, "o", "r", 1)
	if err != nil {
		t.Errorf("Actions.DeleteCachesByID return error: %v", err)
	}

	const methodName = "DeleteCachesByID"
	testBadOptions(t, methodName, func() (err error) {
		_, err = client.Actions.DeleteCachesByID(ctx, "\n", "\n", 0)
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		return client.Actions.DeleteCachesByID(ctx, "o", "r", 1)
	})
}

func TestActionsService_DeleteCachesByID_invalidOwner(t *testing.T) {
	t.Parallel()
	client, _, _ := setup(t)

	ctx := t.Context()
	_, err := client.Actions.DeleteCachesByID(ctx, "%", "r", 1)
	testURLParseError(t, err)
}

func TestActionsService_DeleteCachesByID_invalidRepo(t *testing.T) {
	t.Parallel()
	client, _, _ := setup(t)

	ctx := t.Context()
	_, err := client.Actions.DeleteCachesByID(ctx, "o", "%", 1)
	testURLParseError(t, err)
}

func TestActionsService_DeleteCachesByID_notFound(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("repos/o/r/actions/caches/1", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "DELETE")
		w.WriteHeader(http.StatusNotFound)
	})

	ctx := t.Context()
	resp, err := client.Actions.DeleteCachesByID(ctx, "o", "r", 1)
	if err == nil {
		t.Error("Expected HTTP 404 response")
	}
	if got, want := resp.Response.StatusCode, http.StatusNotFound; got != want {
		t.Errorf("Actions.DeleteCachesByID return status %v, want %v", got, want)
	}
}

func TestActionsService_GetCacheUsageForRepo(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/repos/o/r/actions/cache/usage", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		fmt.Fprint(w,
			`{
				"full_name":"test-cache",
				"active_caches_size_in_bytes":1000,
				"active_caches_count":1
			}`,
		)
	})

	ctx := t.Context()
	cacheUse, _, err := client.Actions.GetCacheUsageForRepo(ctx, "o", "r")
	if err != nil {
		t.Errorf("Actions.GetCacheUsageForRepo returned error: %v", err)
	}

	want := &ActionsCacheUsage{FullName: "test-cache", ActiveCachesSizeInBytes: 1000, ActiveCachesCount: 1}
	if !cmp.Equal(cacheUse, want) {
		t.Errorf("Actions.GetCacheUsageForRepo returned %+v, want %+v", cacheUse, want)
	}

	const methodName = "GetCacheUsageForRepo"
	testBadOptions(t, methodName, func() (err error) {
		_, _, err = client.Actions.GetCacheUsageForRepo(ctx, "\n", "\n")
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		got, resp, err := client.Actions.GetCacheUsageForRepo(ctx, "o", "r")
		if got != nil {
			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
		}
		return resp, err
	})
}

func TestActionsService_GetCacheUsageForRepo_invalidOwner(t *testing.T) {
	t.Parallel()
	client, _, _ := setup(t)

	ctx := t.Context()
	_, _, err := client.Actions.GetCacheUsageForRepo(ctx, "%", "r")
	testURLParseError(t, err)
}

func TestActionsService_GetCacheUsageForRepo_invalidRepo(t *testing.T) {
	t.Parallel()
	client, _, _ := setup(t)

	ctx := t.Context()
	_, _, err := client.Actions.GetCacheUsageForRepo(ctx, "o", "%")
	testURLParseError(t, err)
}

func TestActionsService_GetCacheUsageForRepo_notFound(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/repos/o/r/actions/cache/usage", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		w.WriteHeader(http.StatusNotFound)
	})

	ctx := t.Context()
	caches, resp, err := client.Actions.GetCacheUsageForRepo(ctx, "o", "r")
	if err == nil {
		t.Error("Expected HTTP 404 response")
	}
	if got, want := resp.Response.StatusCode, http.StatusNotFound; got != want {
		t.Errorf("Actions.GetCacheUsageForRepo return status %v, want %v", got, want)
	}
	if caches != nil {
		t.Errorf("Actions.GetCacheUsageForRepo return %+v, want nil", caches)
	}
}

func TestActionsService_ListCacheUsageByRepoForOrg(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/orgs/o/actions/cache/usage-by-repository", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		testFormValues(t, r, values{"page": "2", "per_page": "1"})
		fmt.Fprint(w,
			`{
				"total_count":1,
				"repository_cache_usages":[{"full_name":"test-cache","active_caches_size_in_bytes":1000,"active_caches_count":1}]
			}`,
		)
	})

	opts := &ListOptions{PerPage: 1, Page: 2}
	ctx := t.Context()
	cacheList, _, err := client.Actions.ListCacheUsageByRepoForOrg(ctx, "o", opts)
	if err != nil {
		t.Errorf("Actions.ListCacheUsageByRepoForOrg returned error: %v", err)
	}

	want := &ActionsCacheUsageList{TotalCount: 1, RepoCacheUsage: []*ActionsCacheUsage{{FullName: "test-cache", ActiveCachesSizeInBytes: 1000, ActiveCachesCount: 1}}}
	if !cmp.Equal(cacheList, want) {
		t.Errorf("Actions.ListCacheUsageByRepoForOrg returned %+v, want %+v", cacheList, want)
	}

	const methodName = "ListCacheUsageByRepoForOrg"
	testBadOptions(t, methodName, func() (err error) {
		_, _, err = client.Actions.ListCacheUsageByRepoForOrg(ctx, "\n", opts)
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		got, resp, err := client.Actions.ListCacheUsageByRepoForOrg(ctx, "o", opts)
		if got != nil {
			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
		}
		return resp, err
	})
}

func TestActionsService_ListCacheUsageByRepoForOrg_invalidOrganization(t *testing.T) {
	t.Parallel()
	client, _, _ := setup(t)

	ctx := t.Context()
	_, _, err := client.Actions.ListCacheUsageByRepoForOrg(ctx, "%", nil)
	testURLParseError(t, err)
}

func TestActionsService_ListCacheUsageByRepoForOrg_notFound(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/orgs/o/actions/cache/usage-by-repository", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		w.WriteHeader(http.StatusNotFound)
	})

	ctx := t.Context()
	caches, resp, err := client.Actions.ListCacheUsageByRepoForOrg(ctx, "o", nil)
	if err == nil {
		t.Error("Expected HTTP 404 response")
	}
	if got, want := resp.Response.StatusCode, http.StatusNotFound; got != want {
		t.Errorf("Actions.ListCacheUsageByRepoForOrg return status %v, want %v", got, want)
	}
	if caches != nil {
		t.Errorf("Actions.ListCacheUsageByRepoForOrg return %+v, want nil", caches)
	}
}

func TestActionsService_GetCacheUsageForOrg(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/orgs/o/actions/cache/usage", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		fmt.Fprint(w,
			`{
				"total_active_caches_size_in_bytes":1000,
				"total_active_caches_count":1
			}`,
		)
	})

	ctx := t.Context()
	cache, _, err := client.Actions.GetTotalCacheUsageForOrg(ctx, "o")
	if err != nil {
		t.Errorf("Actions.GetTotalCacheUsageForOrg returned error: %v", err)
	}

	want := &TotalCacheUsage{TotalActiveCachesUsageSizeInBytes: 1000, TotalActiveCachesCount: 1}
	if !cmp.Equal(cache, want) {
		t.Errorf("Actions.GetTotalCacheUsageForOrg returned %+v, want %+v", cache, want)
	}

	const methodName = "GetTotalCacheUsageForOrg"
	testBadOptions(t, methodName, func() (err error) {
		_, _, err = client.Actions.GetTotalCacheUsageForOrg(ctx, "\n")
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		got, resp, err := client.Actions.GetTotalCacheUsageForOrg(ctx, "o")
		if got != nil {
			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
		}
		return resp, err
	})
}

func TestActionsService_GetCacheUsageForOrg_invalidOrganization(t *testing.T) {
	t.Parallel()
	client, _, _ := setup(t)

	ctx := t.Context()
	_, _, err := client.Actions.GetTotalCacheUsageForOrg(ctx, "%")
	testURLParseError(t, err)
}

func TestActionsService_GetCacheUsageForOrg_notFound(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/orgs/o/actions/cache/usage", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		w.WriteHeader(http.StatusNotFound)
	})

	ctx := t.Context()
	caches, resp, err := client.Actions.GetTotalCacheUsageForOrg(ctx, "o")
	if err == nil {
		t.Error("Expected HTTP 404 response")
	}
	if got, want := resp.Response.StatusCode, http.StatusNotFound; got != want {
		t.Errorf("Actions.GetTotalCacheUsageForOrg return status %v, want %v", got, want)
	}
	if caches != nil {
		t.Errorf("Actions.GetTotalCacheUsageForOrg return %+v, want nil", caches)
	}
}

func TestActionsService_GetCacheUsageForEnterprise(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/enterprises/e/actions/cache/usage", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		fmt.Fprint(w,
			`{
				"total_active_caches_size_in_bytes":1000,
				"total_active_caches_count":1
			}`,
		)
	})

	ctx := t.Context()
	cache, _, err := client.Actions.GetTotalCacheUsageForEnterprise(ctx, "e")
	if err != nil {
		t.Errorf("Actions.GetTotalCacheUsageForEnterprise returned error: %v", err)
	}

	want := &TotalCacheUsage{TotalActiveCachesUsageSizeInBytes: 1000, TotalActiveCachesCount: 1}
	if !cmp.Equal(cache, want) {
		t.Errorf("Actions.GetTotalCacheUsageForEnterprise returned %+v, want %+v", cache, want)
	}

	const methodName = "GetTotalCacheUsageForEnterprise"
	testBadOptions(t, methodName, func() (err error) {
		_, _, err = client.Actions.GetTotalCacheUsageForEnterprise(ctx, "\n")
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		got, resp, err := client.Actions.GetTotalCacheUsageForEnterprise(ctx, "e")
		if got != nil {
			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
		}
		return resp, err
	})
}

func TestActionsService_GetCacheUsageForEnterprise_invalidEnterprise(t *testing.T) {
	t.Parallel()
	client, _, _ := setup(t)

	ctx := t.Context()
	_, _, err := client.Actions.GetTotalCacheUsageForEnterprise(ctx, "%")
	testURLParseError(t, err)
}

func TestActionsService_GetCacheUsageForEnterprise_notFound(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/enterprises/e/actions/cache/usage", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		w.WriteHeader(http.StatusNotFound)
	})

	ctx := t.Context()
	caches, resp, err := client.Actions.GetTotalCacheUsageForEnterprise(ctx, "o")
	if err == nil {
		t.Error("Expected HTTP 404 response")
	}
	if got, want := resp.Response.StatusCode, http.StatusNotFound; got != want {
		t.Errorf("Actions.GetTotalCacheUsageForEnterprise return status %v, want %v", got, want)
	}
	if caches != nil {
		t.Errorf("Actions.GetTotalCacheUsageForEnterprise return %+v, want nil", caches)
	}
}

func TestActionsService_GetCacheRetentionLimitForOrg(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/organizations/o/actions/cache/retention-limit", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		fmt.Fprint(w, `{"max_cache_retention_days":14}`)
	})

	ctx := t.Context()
	limit, _, err := client.Actions.GetCacheRetentionLimitForOrg(ctx, "o")
	if err != nil {
		t.Errorf("Actions.GetCacheRetentionLimitForOrg returned error: %v", err)
	}

	want := &ActionsCacheRetentionLimit{MaxCacheRetentionDays: new(14)}
	if !cmp.Equal(limit, want) {
		t.Errorf("Actions.GetCacheRetentionLimitForOrg returned %+v, want %+v", limit, want)
	}

	const methodName = "GetCacheRetentionLimitForOrg"
	testBadOptions(t, methodName, func() (err error) {
		_, _, err = client.Actions.GetCacheRetentionLimitForOrg(ctx, "\n")
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		got, resp, err := client.Actions.GetCacheRetentionLimitForOrg(ctx, "o")
		if got != nil {
			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
		}
		return resp, err
	})
}

func TestActionsService_GetCacheRetentionLimitForOrg_invalidOrganization(t *testing.T) {
	t.Parallel()
	client, _, _ := setup(t)

	ctx := t.Context()
	_, _, err := client.Actions.GetCacheRetentionLimitForOrg(ctx, "%")
	testURLParseError(t, err)
}

func TestActionsService_GetCacheRetentionLimitForOrg_notFound(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/organizations/o/actions/cache/retention-limit", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		w.WriteHeader(http.StatusNotFound)
	})

	ctx := t.Context()
	limit, resp, err := client.Actions.GetCacheRetentionLimitForOrg(ctx, "o")
	if err == nil {
		t.Error("Expected HTTP 404 response")
	}
	if got, want := resp.Response.StatusCode, http.StatusNotFound; got != want {
		t.Errorf("Actions.GetCacheRetentionLimitForOrg return status %v, want %v", got, want)
	}
	if limit != nil {
		t.Errorf("Actions.GetCacheRetentionLimitForOrg return %+v, want nil", limit)
	}
}

func TestActionsService_SetCacheRetentionLimitForOrg(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	input := ActionsCacheRetentionLimit{MaxCacheRetentionDays: new(14)}

	mux.HandleFunc("/organizations/o/actions/cache/retention-limit", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "PUT")
		testJSONBody(t, r, input)
		w.WriteHeader(http.StatusNoContent)
	})

	ctx := t.Context()
	resp, err := client.Actions.SetCacheRetentionLimitForOrg(ctx, "o", input)
	if err != nil {
		t.Errorf("Actions.SetCacheRetentionLimitForOrg returned error: %v", err)
	}
	if got, want := resp.StatusCode, http.StatusNoContent; got != want {
		t.Errorf("Actions.SetCacheRetentionLimitForOrg return status %v, want %v", got, want)
	}

	const methodName = "SetCacheRetentionLimitForOrg"
	testBadOptions(t, methodName, func() (err error) {
		_, err = client.Actions.SetCacheRetentionLimitForOrg(ctx, "\n", input)
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		return client.Actions.SetCacheRetentionLimitForOrg(ctx, "o", input)
	})
}

func TestActionsService_SetCacheRetentionLimitForOrg_invalidOrganization(t *testing.T) {
	t.Parallel()
	client, _, _ := setup(t)

	ctx := t.Context()
	_, err := client.Actions.SetCacheRetentionLimitForOrg(ctx, "%", ActionsCacheRetentionLimit{})
	testURLParseError(t, err)
}

func TestActionsService_GetCacheStorageLimitForOrg(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/organizations/o/actions/cache/storage-limit", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		fmt.Fprint(w, `{"max_cache_size_gb":10}`)
	})

	ctx := t.Context()
	limit, _, err := client.Actions.GetCacheStorageLimitForOrg(ctx, "o")
	if err != nil {
		t.Errorf("Actions.GetCacheStorageLimitForOrg returned error: %v", err)
	}

	want := &ActionsCacheStorageLimit{MaxCacheSizeGB: new(10)}
	if !cmp.Equal(limit, want) {
		t.Errorf("Actions.GetCacheStorageLimitForOrg returned %+v, want %+v", limit, want)
	}

	const methodName = "GetCacheStorageLimitForOrg"
	testBadOptions(t, methodName, func() (err error) {
		_, _, err = client.Actions.GetCacheStorageLimitForOrg(ctx, "\n")
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		got, resp, err := client.Actions.GetCacheStorageLimitForOrg(ctx, "o")
		if got != nil {
			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
		}
		return resp, err
	})
}

func TestActionsService_GetCacheStorageLimitForOrg_invalidOrganization(t *testing.T) {
	t.Parallel()
	client, _, _ := setup(t)

	ctx := t.Context()
	_, _, err := client.Actions.GetCacheStorageLimitForOrg(ctx, "%")
	testURLParseError(t, err)
}

func TestActionsService_GetCacheStorageLimitForOrg_notFound(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/organizations/o/actions/cache/storage-limit", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		w.WriteHeader(http.StatusNotFound)
	})

	ctx := t.Context()
	limit, resp, err := client.Actions.GetCacheStorageLimitForOrg(ctx, "o")
	if err == nil {
		t.Error("Expected HTTP 404 response")
	}
	if got, want := resp.Response.StatusCode, http.StatusNotFound; got != want {
		t.Errorf("Actions.GetCacheStorageLimitForOrg return status %v, want %v", got, want)
	}
	if limit != nil {
		t.Errorf("Actions.GetCacheStorageLimitForOrg return %+v, want nil", limit)
	}
}

func TestActionsService_SetCacheStorageLimitForOrg(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	input := ActionsCacheStorageLimit{MaxCacheSizeGB: new(10)}

	mux.HandleFunc("/organizations/o/actions/cache/storage-limit", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "PUT")
		testJSONBody(t, r, input)
		w.WriteHeader(http.StatusNoContent)
	})

	ctx := t.Context()
	resp, err := client.Actions.SetCacheStorageLimitForOrg(ctx, "o", input)
	if err != nil {
		t.Errorf("Actions.SetCacheStorageLimitForOrg returned error: %v", err)
	}
	if got, want := resp.StatusCode, http.StatusNoContent; got != want {
		t.Errorf("Actions.SetCacheStorageLimitForOrg return status %v, want %v", got, want)
	}

	const methodName = "SetCacheStorageLimitForOrg"
	testBadOptions(t, methodName, func() (err error) {
		_, err = client.Actions.SetCacheStorageLimitForOrg(ctx, "\n", input)
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		return client.Actions.SetCacheStorageLimitForOrg(ctx, "o", input)
	})
}

func TestActionsService_SetCacheStorageLimitForOrg_invalidOrganization(t *testing.T) {
	t.Parallel()
	client, _, _ := setup(t)

	ctx := t.Context()
	_, err := client.Actions.SetCacheStorageLimitForOrg(ctx, "%", ActionsCacheStorageLimit{})
	testURLParseError(t, err)
}

func TestActionsService_GetCacheRetentionLimitForRepo(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/repos/o/r/actions/cache/retention-limit", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		fmt.Fprint(w, `{"max_cache_retention_days":14}`)
	})

	ctx := t.Context()
	limit, _, err := client.Actions.GetCacheRetentionLimitForRepo(ctx, "o", "r")
	if err != nil {
		t.Errorf("Actions.GetCacheRetentionLimitForRepo returned error: %v", err)
	}

	want := &ActionsCacheRetentionLimit{MaxCacheRetentionDays: new(14)}
	if !cmp.Equal(limit, want) {
		t.Errorf("Actions.GetCacheRetentionLimitForRepo returned %+v, want %+v", limit, want)
	}

	const methodName = "GetCacheRetentionLimitForRepo"
	testBadOptions(t, methodName, func() (err error) {
		_, _, err = client.Actions.GetCacheRetentionLimitForRepo(ctx, "\n", "\n")
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		got, resp, err := client.Actions.GetCacheRetentionLimitForRepo(ctx, "o", "r")
		if got != nil {
			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
		}
		return resp, err
	})
}

func TestActionsService_SetCacheRetentionLimitForRepo(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	input := ActionsCacheRetentionLimit{MaxCacheRetentionDays: new(14)}

	mux.HandleFunc("/repos/o/r/actions/cache/retention-limit", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "PUT")
		testJSONBody(t, r, input)
		w.WriteHeader(http.StatusNoContent)
	})

	ctx := t.Context()
	resp, err := client.Actions.SetCacheRetentionLimitForRepo(ctx, "o", "r", input)
	if err != nil {
		t.Errorf("Actions.SetCacheRetentionLimitForRepo returned error: %v", err)
	}
	if got, want := resp.StatusCode, http.StatusNoContent; got != want {
		t.Errorf("Actions.SetCacheRetentionLimitForRepo return status %v, want %v", got, want)
	}

	const methodName = "SetCacheRetentionLimitForRepo"
	testBadOptions(t, methodName, func() (err error) {
		_, err = client.Actions.SetCacheRetentionLimitForRepo(ctx, "\n", "\n", input)
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		return client.Actions.SetCacheRetentionLimitForRepo(ctx, "o", "r", input)
	})
}

func TestActionsService_GetCacheStorageLimitForRepo(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/repos/o/r/actions/cache/storage-limit", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		fmt.Fprint(w, `{"max_cache_size_gb":10}`)
	})

	ctx := t.Context()
	limit, _, err := client.Actions.GetCacheStorageLimitForRepo(ctx, "o", "r")
	if err != nil {
		t.Errorf("Actions.GetCacheStorageLimitForRepo returned error: %v", err)
	}

	want := &ActionsCacheStorageLimit{MaxCacheSizeGB: new(10)}
	if !cmp.Equal(limit, want) {
		t.Errorf("Actions.GetCacheStorageLimitForRepo returned %+v, want %+v", limit, want)
	}

	const methodName = "GetCacheStorageLimitForRepo"
	testBadOptions(t, methodName, func() (err error) {
		_, _, err = client.Actions.GetCacheStorageLimitForRepo(ctx, "\n", "\n")
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		got, resp, err := client.Actions.GetCacheStorageLimitForRepo(ctx, "o", "r")
		if got != nil {
			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
		}
		return resp, err
	})
}

func TestActionsService_SetCacheStorageLimitForRepo(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	input := ActionsCacheStorageLimit{MaxCacheSizeGB: new(10)}

	mux.HandleFunc("/repos/o/r/actions/cache/storage-limit", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "PUT")
		testJSONBody(t, r, input)
		w.WriteHeader(http.StatusNoContent)
	})

	ctx := t.Context()
	resp, err := client.Actions.SetCacheStorageLimitForRepo(ctx, "o", "r", input)
	if err != nil {
		t.Errorf("Actions.SetCacheStorageLimitForRepo returned error: %v", err)
	}
	if got, want := resp.StatusCode, http.StatusNoContent; got != want {
		t.Errorf("Actions.SetCacheStorageLimitForRepo return status %v, want %v", got, want)
	}

	const methodName = "SetCacheStorageLimitForRepo"
	testBadOptions(t, methodName, func() (err error) {
		_, err = client.Actions.SetCacheStorageLimitForRepo(ctx, "\n", "\n", input)
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		return client.Actions.SetCacheStorageLimitForRepo(ctx, "o", "r", input)
	})
}

func TestActionsService_GetCacheRetentionLimitForEnterprise(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/enterprises/e/actions/cache/retention-limit", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		fmt.Fprint(w, `{"max_cache_retention_days":14}`)
	})

	ctx := t.Context()
	limit, _, err := client.Actions.GetCacheRetentionLimitForEnterprise(ctx, "e")
	if err != nil {
		t.Errorf("Actions.GetCacheRetentionLimitForEnterprise returned error: %v", err)
	}

	want := &ActionsCacheRetentionLimit{MaxCacheRetentionDays: new(14)}
	if !cmp.Equal(limit, want) {
		t.Errorf("Actions.GetCacheRetentionLimitForEnterprise returned %+v, want %+v", limit, want)
	}

	const methodName = "GetCacheRetentionLimitForEnterprise"
	testBadOptions(t, methodName, func() (err error) {
		_, _, err = client.Actions.GetCacheRetentionLimitForEnterprise(ctx, "\n")
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		got, resp, err := client.Actions.GetCacheRetentionLimitForEnterprise(ctx, "e")
		if got != nil {
			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
		}
		return resp, err
	})
}

func TestActionsService_SetCacheRetentionLimitForEnterprise(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	input := ActionsCacheRetentionLimit{MaxCacheRetentionDays: new(14)}

	mux.HandleFunc("/enterprises/e/actions/cache/retention-limit", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "PUT")
		testJSONBody(t, r, input)
		w.WriteHeader(http.StatusNoContent)
	})

	ctx := t.Context()
	resp, err := client.Actions.SetCacheRetentionLimitForEnterprise(ctx, "e", input)
	if err != nil {
		t.Errorf("Actions.SetCacheRetentionLimitForEnterprise returned error: %v", err)
	}
	if got, want := resp.StatusCode, http.StatusNoContent; got != want {
		t.Errorf("Actions.SetCacheRetentionLimitForEnterprise return status %v, want %v", got, want)
	}

	const methodName = "SetCacheRetentionLimitForEnterprise"
	testBadOptions(t, methodName, func() (err error) {
		_, err = client.Actions.SetCacheRetentionLimitForEnterprise(ctx, "\n", input)
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		return client.Actions.SetCacheRetentionLimitForEnterprise(ctx, "e", input)
	})
}

func TestActionsService_GetCacheStorageLimitForEnterprise(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	mux.HandleFunc("/enterprises/e/actions/cache/storage-limit", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		fmt.Fprint(w, `{"max_cache_size_gb":10}`)
	})

	ctx := t.Context()
	limit, _, err := client.Actions.GetCacheStorageLimitForEnterprise(ctx, "e")
	if err != nil {
		t.Errorf("Actions.GetCacheStorageLimitForEnterprise returned error: %v", err)
	}

	want := &ActionsCacheStorageLimit{MaxCacheSizeGB: new(10)}
	if !cmp.Equal(limit, want) {
		t.Errorf("Actions.GetCacheStorageLimitForEnterprise returned %+v, want %+v", limit, want)
	}

	const methodName = "GetCacheStorageLimitForEnterprise"
	testBadOptions(t, methodName, func() (err error) {
		_, _, err = client.Actions.GetCacheStorageLimitForEnterprise(ctx, "\n")
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		got, resp, err := client.Actions.GetCacheStorageLimitForEnterprise(ctx, "e")
		if got != nil {
			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
		}
		return resp, err
	})
}

func TestActionsService_SetCacheStorageLimitForEnterprise(t *testing.T) {
	t.Parallel()
	client, mux, _ := setup(t)

	input := ActionsCacheStorageLimit{MaxCacheSizeGB: new(10)}

	mux.HandleFunc("/enterprises/e/actions/cache/storage-limit", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "PUT")
		testJSONBody(t, r, input)
		w.WriteHeader(http.StatusNoContent)
	})

	ctx := t.Context()
	resp, err := client.Actions.SetCacheStorageLimitForEnterprise(ctx, "e", input)
	if err != nil {
		t.Errorf("Actions.SetCacheStorageLimitForEnterprise returned error: %v", err)
	}
	if got, want := resp.StatusCode, http.StatusNoContent; got != want {
		t.Errorf("Actions.SetCacheStorageLimitForEnterprise return status %v, want %v", got, want)
	}

	const methodName = "SetCacheStorageLimitForEnterprise"
	testBadOptions(t, methodName, func() (err error) {
		_, err = client.Actions.SetCacheStorageLimitForEnterprise(ctx, "\n", input)
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		return client.Actions.SetCacheStorageLimitForEnterprise(ctx, "e", input)
	})
}