miniflux/client/client_test.go at 2.3.1 · somaz94/miniflux

Repository navigation

// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package client
	"encoding/json"
	"net/http"
type roundTripperFunc func(req *http.Request) (*http.Response, error)
func (fn roundTripperFunc) RoundTrip(req *http.Request) (*http.Response, error) {
	return fn(req)
func newFakeHTTPClient(
	t *testing.T,
	fn func(t *testing.T, req *http.Request) *http.Response,
) *http.Client {
	return &http.Client{
		Transport: roundTripperFunc(
			func(req *http.Request) (*http.Response, error) {
				return fn(t, req), nil
func jsonResponseFrom(
	t *testing.T,
	status int,
	headers http.Header,
) *http.Response {
	data, err := json.Marshal(body)
	if err != nil {
		t.Fatalf("Unable to marshal body: %v", err)
	return &http.Response{
		StatusCode: status,
		Body:       io.NopCloser(bytes.NewBuffer(data)),
		Header:     headers,
func asJSON(data any) string {
	json, err := json.MarshalIndent(data, "", "  ")
	if err != nil {
		panic(err)
	return string(json)
func expectRequest(
	t *testing.T,
	method string,
	url string,
	checkBody func(r io.Reader),
	req *http.Request,
	if req.Method != method {
		t.Fatalf("Expected method to be %s, got %s", method, req.Method)
	if req.URL.String() != url {
		t.Fatalf("Expected URL path to be %s, got %s", url, req.URL)
	if checkBody != nil {
		checkBody(req.Body)
func expectFromJSON[T any](
	t *testing.T,
	r io.Reader,
	expected *T,
	if err := json.NewDecoder(r).Decode(&got); err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(&got, expected) {
		t.Fatalf("Expected %s, got %s", asJSON(expected), asJSON(got))
func TestHealthcheck(t *testing.T) {
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodGet, "http://mf/healthcheck", nil, req)
				return &http.Response{
					StatusCode: http.StatusOK,
					Body:       io.NopCloser(bytes.NewBufferString("OK")),
	if err := client.HealthcheckContext(t.Context()); err != nil {
		t.Fatalf("Expected no error, got %v", err)
func TestVersion(t *testing.T) {
	expected := &VersionResponse{
		Version:   "1.0.0",
		Commit:    "1234567890",
		BuildDate: "2021-01-01T00:00:00Z",
		GoVersion: "go1.20",
		Compiler:  "gc",
		Arch:      "amd64",
		OS:        "linux",
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodGet, "http://mf/v1/version", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.VersionContext(t.Context())
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %+v, got %+v", expected, res)
func TestMe(t *testing.T) {
	expected := &User{
		Username:                  "test",
		Password:                  "password",
		IsAdmin:                   false,
		Theme:                     "light",
		Language:                  "en",
		Timezone:                  "UTC",
		EntryDirection:            "asc",
		EntryOrder:                "created_at",
		Stylesheet:                "default",
		CustomJS:                  "custom.js",
		GoogleID:                  "google-id",
		OpenIDConnectID:           "openid-connect-id",
		EntriesPerPage:            10,
		KeyboardShortcuts:         true,
		ShowReadingTime:           true,
		EntrySwipe:                true,
		GestureNav:                "horizontal",
		DisplayMode:               "read",
		DefaultReadingSpeed:       1,
		CJKReadingSpeed:           1,
		DefaultHomePage:           "home",
		CategoriesSortingOrder:    "asc",
		MarkReadOnView:            true,
		MediaPlaybackRate:         1.0,
		BlockFilterEntryRules:     "block",
		KeepFilterEntryRules:      "keep",
		ExternalFontHosts:         "https://fonts.googleapis.com",
		AlwaysOpenExternalLinks:   true,
		OpenExternalLinksInNewTab: true,
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodGet, "http://mf/v1/me", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.MeContext(t.Context())
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %+v, got %+v", expected, res)
func TestUsers(t *testing.T) {
	expected := Users{
			ID:       1,
			Username: "test1",
			ID:       2,
			Username: "test2",
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodGet, "http://mf/v1/users", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.UsersContext(t.Context())
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %+v, got %+v", expected, res)
func TestUserByID(t *testing.T) {
	expected := &User{
		ID:       1,
		Username: "test",
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodGet, "http://mf/v1/users/1", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.UserByIDContext(t.Context(), 1)
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %+v, got %+v", expected, res)
func TestUserByUsername(t *testing.T) {
	expected := &User{
		ID:       1,
		Username: "test",
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodGet, "http://mf/v1/users/test", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.UserByUsernameContext(t.Context(), "test")
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %+v, got %+v", expected, res)
func TestCreateUser(t *testing.T) {
	expected := &User{
		ID:       1,
		Username: "test",
		Password: "password",
		IsAdmin:  true,
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				exp := UserCreationRequest{
					Username: "test",
					Password: "password",
					IsAdmin:  true,
				expectRequest(
					http.MethodPost,
					"http://mf/v1/users",
					func(r io.Reader) {
						expectFromJSON(t, r, &exp)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.CreateUserContext(t.Context(), "test", "password", true)
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %+v, got %+v", expected, res)
func TestUpdateUser(t *testing.T) {
	expected := &User{
		ID:       1,
		Username: "test",
		Password: "password",
		IsAdmin:  true,
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodPut, "http://mf/v1/users/1", func(r io.Reader) {
					expectFromJSON(t, r, &UserModificationRequest{
						Username: &expected.Username,
						Password: &expected.Password,
				}, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.UpdateUserContext(t.Context(), 1, &UserModificationRequest{
		Username: &expected.Username,
		Password: &expected.Password,
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %+v, got %+v", expected, res)
func TestDeleteUser(t *testing.T) {
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodDelete, "http://mf/v1/users/1", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, nil)
	if err := client.DeleteUserContext(t.Context(), 1); err != nil {
		t.Fatalf("Expected no error, got %v", err)
func TestAPIKeys(t *testing.T) {
	expected := APIKeys{
			ID:          1,
			Token:       "token",
			Description: "test",
			ID:          2,
			Token:       "token2",
			Description: "test2",
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodGet, "http://mf/v1/api-keys", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.APIKeysContext(t.Context())
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %+v, got %+v", expected, res)
func TestCreateAPIKey(t *testing.T) {
	expected := &APIKey{
		ID:          42,
		Token:       "some-token",
		Description: "desc",
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodPost, "http://mf/v1/api-keys", func(r io.Reader) {
					expectFromJSON(t, r, &APIKeyCreationRequest{
						Description: "desc",
				}, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.CreateAPIKeyContext(t.Context(), "desc")
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %+v, got %+v", expected, res)
func TestDeleteAPIKey(t *testing.T) {
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodDelete, "http://mf/v1/api-keys/1", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, nil)
	if err := client.DeleteAPIKeyContext(t.Context(), 1); err != nil {
		t.Fatalf("Expected no error, got %v", err)
func TestMarkAllAsRead(t *testing.T) {
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodPut, "http://mf/v1/users/1/mark-all-as-read", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, nil)
	if err := client.MarkAllAsReadContext(t.Context(), 1); err != nil {
		t.Fatalf("Expected no error, got %v", err)
func TestIntegrationsStatus(t *testing.T) {
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodGet, "http://mf/v1/integrations/status", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, struct {
					HasIntegrations bool `json:"has_integrations"`
					HasIntegrations: true,
	status, err := client.IntegrationsStatusContext(t.Context())
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !status {
		t.Fatalf("Expected integrations status to be true, got false")
func TestDiscover(t *testing.T) {
	expected := Subscriptions{
			URL:   "http://example.com",
			Title: "Example",
			Type:  "rss",
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodPost, "http://mf/v1/discover", func(r io.Reader) {
					expectFromJSON(t, r, &map[string]string{"url": "http://example.com"})
				}, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.DiscoverContext(t.Context(), "http://example.com")
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %+v, got %+v", expected, res)
func TestCategories(t *testing.T) {
	expected := Categories{
			ID:    1,
			Title: "Example",
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodGet, "http://mf/v1/categories", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.CategoriesContext(t.Context())
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %+v, got %+v", expected, res)
func TestCategoriesWithCounters(t *testing.T) {
	feedCount := 1
	totalUnread := 2
	expected := Categories{
			ID:          1,
			Title:       "Example",
			FeedCount:   &feedCount,
			TotalUnread: &totalUnread,
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodGet, "http://mf/v1/categories?counts=true", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.CategoriesWithCountersContext(t.Context())
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %+v, got %+v", expected, res)
func TestCreateCategory(t *testing.T) {
	expected := &Category{
		ID:    1,
		Title: "Example",
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodPost, "http://mf/v1/categories", func(r io.Reader) {
					expectFromJSON(t, r, &CategoryCreationRequest{
						Title: "Example",
				}, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.CreateCategoryContext(t.Context(), "Example")
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %+v, got %+v", expected, res)
func TestCreateCategoryWithOptions(t *testing.T) {
	expected := &Category{
		ID:           1,
		Title:        "Example",
		HideGlobally: true,
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodPost, "http://mf/v1/categories", func(r io.Reader) {
					expectFromJSON(t, r, &CategoryCreationRequest{
						Title:        "Example",
						HideGlobally: true,
				}, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.CreateCategoryWithOptionsContext(t.Context(), &CategoryCreationRequest{
		Title:        "Example",
		HideGlobally: true,
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %+v, got %+v", expected, res)
func TestUpdateCategory(t *testing.T) {
	expected := &Category{
		ID:    1,
		Title: "Example",
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodPut, "http://mf/v1/categories/1", func(r io.Reader) {
					expectFromJSON(t, r, &CategoryModificationRequest{
						Title: &expected.Title,
				}, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.UpdateCategoryContext(t.Context(), 1, "Example")
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %+v, got %+v", expected, res)
func TestUpdateCategoryWithOptions(t *testing.T) {
	expected := &Category{
		ID:           1,
		Title:        "Example",
		HideGlobally: true,
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodPut, "http://mf/v1/categories/1", func(r io.Reader) {
					expectFromJSON(t, r, &CategoryModificationRequest{
						Title:        &expected.Title,
						HideGlobally: &expected.HideGlobally,
				}, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.UpdateCategoryWithOptionsContext(t.Context(), 1, &CategoryModificationRequest{
		Title:        &expected.Title,
		HideGlobally: &expected.HideGlobally,
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %+v, got %+v", expected, res)
func TestMarkCategoryAsRead(t *testing.T) {
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodPut, "http://mf/v1/categories/1/mark-all-as-read", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, nil)
	if err := client.MarkCategoryAsReadContext(t.Context(), 1); err != nil {
		t.Fatalf("Expected no error, got %v", err)
func TestCategoryFeeds(t *testing.T) {
	expected := Feeds{
			ID:    1,
			Title: "Example",
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodGet, "http://mf/v1/categories/1/feeds", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.CategoryFeedsContext(t.Context(), 1)
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %+v, got %+v", expected, res)
func TestDeleteCategory(t *testing.T) {
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodDelete, "http://mf/v1/categories/1", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, nil)
	if err := client.DeleteCategoryContext(t.Context(), 1); err != nil {
		t.Fatalf("Expected no error, got %v", err)
func TestRefreshCategory(t *testing.T) {
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodPut, "http://mf/v1/categories/1/refresh", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, nil)
	if err := client.RefreshCategoryContext(t.Context(), 1); err != nil {
		t.Fatalf("Expected no error, got %v", err)
func TestFeeds(t *testing.T) {
	expected := Feeds{
			Title:                       "Example",
			FeedURL:                     "http://example.com",
			SiteURL:                     "http://example.com",
			CheckedAt:                   time.Date(1970, 1, 1, 0, 7, 0, 0, time.UTC),
			Disabled:                    false,
			IgnoreHTTPCache:             false,
			AllowSelfSignedCertificates: false,
			FetchViaProxy:               false,
			ScraperRules:                "",
			RewriteRules:                "",
			UrlRewriteRules:             "",
			BlocklistRules:              "",
			KeeplistRules:               "",
			BlockFilterEntryRules:       "",
			KeepFilterEntryRules:        "",
			Crawler:                     false,
			UserAgent:                   "",
			Cookie:                      "",
			Username:                    "",
			Password:                    "",
			Category: &Category{
				ID:    1,
				Title: "Example",
			HideGlobally: false,
			DisableHTTP2: false,
			ProxyURL:     "",
			ID:    2,
			Title: "Example 2",
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodGet, "http://mf/v1/feeds", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.FeedsContext(t.Context())
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %s, got %s", asJSON(expected), asJSON(res))
func TestExport(t *testing.T) {
	expected := []byte("hello")
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodGet, "http://mf/v1/export", nil, req)
				return &http.Response{
					StatusCode: http.StatusOK,
					Body:       io.NopCloser(bytes.NewBufferString(string(expected))),
					Header:     http.Header{},
	res, err := client.ExportContext(t.Context())
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %+v, got %+v", expected, res)
func TestImport(t *testing.T) {
	expected := []byte("hello")
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(
					http.MethodPost,
					"http://mf/v1/import",
					func(r io.Reader) {
						b, err := io.ReadAll(r)
						if err != nil {
							t.Fatalf("Expected no error, got %v", err)
						if !bytes.Equal(b, expected) {
							t.Fatalf("expected %+v, got %+v", expected, b)
				return &http.Response{
					StatusCode: http.StatusOK,
					Header:     http.Header{},
	if err := client.ImportContext(t.Context(), io.NopCloser(bytes.NewBufferString(string(expected)))); err != nil {
		t.Fatalf("Expected no error, got %v", err)
func TestFeed(t *testing.T) {
	expected := &Feed{
		ID:    1,
		Title: "Example",
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodGet, "http://mf/v1/feeds/1", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.FeedContext(t.Context(), 1)
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %s, got %s", asJSON(expected), asJSON(res))
func TestCreateFeed(t *testing.T) {
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodPost, "http://mf/v1/feeds", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, struct {
					FeedID int64 `json:"feed_id"`
					FeedID: 1,
	id, err := client.CreateFeedContext(t.Context(), &FeedCreationRequest{
		FeedURL: "http://example.com",
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if id != 1 {
		t.Fatalf("Expected feed ID to be 1, got %d", id)
func TestUpdateFeed(t *testing.T) {
	expected := &Feed{
		ID:      1,
		FeedURL: "http://example.com/",
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodPut, "http://mf/v1/feeds/1", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.UpdateFeedContext(t.Context(), 1, &FeedModificationRequest{
		FeedURL: &expected.FeedURL,
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %s, got %s", asJSON(expected), asJSON(res))
func TestMarkFeedAsRead(t *testing.T) {
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodPut, "http://mf/v1/feeds/1/mark-all-as-read", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, nil)
	if err := client.MarkFeedAsReadContext(t.Context(), 1); err != nil {
		t.Fatalf("Expected no error, got %v", err)
func TestRefreshAllFeeds(t *testing.T) {
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodPut, "http://mf/v1/feeds/refresh", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, nil)
	if err := client.RefreshAllFeedsContext(t.Context()); err != nil {

9AA8
		t.Fatalf("Expected no error, got %v", err)
func TestRefreshFeed(t *testing.T) {
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodPut, "http://mf/v1/feeds/1/refresh", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, nil)
	if err := client.RefreshFeedContext(t.Context(), 1); err != nil {
		t.Fatalf("Expected no error, got %v", err)
func TestDeleteFeed(t *testing.T) {
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodDelete, "http://mf/v1/feeds/1", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, nil)
	if err := client.DeleteFeedContext(t.Context(), 1); err != nil {
		t.Fatalf("Expected no error, got %v", err)
func TestFeedIcon(t *testing.T) {
	expected := &FeedIcon{
		ID:       1,
		MimeType: "text/plain",
		Data:     "data",
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodGet, "http://mf/v1/feeds/1/icon", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.FeedIconContext(t.Context(), 1)
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %s, got %s", asJSON(expected), asJSON(res))
func TestFeedEntry(t *testing.T) {
	expected := &Entry{
		ID:    1,
		Title: "Example",
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodGet, "http://mf/v1/feeds/1/entries/1", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.FeedEntryContext(t.Context(), 1, 1)
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %s, got %s", asJSON(expected), asJSON(res))
func TestCategoryEntry(t *testing.T) {
	expected := &Entry{
		ID:    1,
		Title: "Example",
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodGet, "http://mf/v1/categories/1/entries/1", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.CategoryEntryContext(t.Context(), 1, 1)
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	if !reflect.DeepEqual(res, expected) {
		t.Fatalf("Expected %s, got %s", asJSON(expected), asJSON(res))
func TestEntry(t *testing.T) {
	expected := &Entry{
		ID:    1,
		Title: "Example",
	client := NewClientWithOptions(
		"http://mf",
		WithHTTPClient(
			newFakeHTTPClient(t, func(t *testing.T, req *http.Request) *http.Response {
				expectRequest(t, http.MethodGet, "http://mf/v1/entries/1", nil, req)
				return jsonResponseFrom(t, http.StatusOK, http.Header{}, expected)
	res, err := client.EntryContext(t.Context(), 1)
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
View remainder of file in raw view
FilesExpand file tree

client_test.go

Latest commit

History

client_test.go

File metadata and controls
