code.gitea.io/gitea@v1.22.3/tests/integration/privateactivity_test.go (about)

     1  // Copyright 2020 The Gitea Authors. All rights reserved.
     2  // SPDX-License-Identifier: MIT
     3  
     4  package integration
     5  
     6  import (
     7  	"fmt"
     8  	"net/http"
     9  	"testing"
    10  
    11  	activities_model "code.gitea.io/gitea/models/activities"
    12  	auth_model "code.gitea.io/gitea/models/auth"
    13  	repo_model "code.gitea.io/gitea/models/repo"
    14  	"code.gitea.io/gitea/models/unittest"
    15  	user_model "code.gitea.io/gitea/models/user"
    16  	api "code.gitea.io/gitea/modules/structs"
    17  	"code.gitea.io/gitea/tests"
    18  
    19  	"github.com/stretchr/testify/assert"
    20  )
    21  
    22  const (
    23  	privateActivityTestAdmin = "user1"
    24  	privateActivityTestUser  = "user2"
    25  )
    26  
    27  // org3 is an organization so it is not usable here
    28  const privateActivityTestOtherUser = "user4"
    29  
    30  // activity helpers
    31  
    32  func testPrivateActivityDoSomethingForActionEntries(t *testing.T) {
    33  	repoBefore := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
    34  	owner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repoBefore.OwnerID})
    35  
    36  	session := loginUser(t, privateActivityTestUser)
    37  	token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteIssue)
    38  	urlStr := fmt.Sprintf("/api/v1/repos/%s/%s/issues?state=all", owner.Name, repoBefore.Name)
    39  	req := NewRequestWithJSON(t, "POST", urlStr, &api.CreateIssueOption{
    40  		Body:  "test",
    41  		Title: "test",
    42  	}).AddTokenAuth(token)
    43  	session.MakeRequest(t, req, http.StatusCreated)
    44  }
    45  
    46  // private activity helpers
    47  
    48  func testPrivateActivityHelperEnablePrivateActivity(t *testing.T) {
    49  	session := loginUser(t, privateActivityTestUser)
    50  	req := NewRequestWithValues(t, "POST", "/user/settings", map[string]string{
    51  		"_csrf":                 GetCSRF(t, session, "/user/settings"),
    52  		"name":                  privateActivityTestUser,
    53  		"email":                 privateActivityTestUser + "@example.com",
    54  		"language":              "en-US",
    55  		"keep_activity_private": "1",
    56  	})
    57  	session.MakeRequest(t, req, http.StatusSeeOther)
    58  }
    59  
    60  func testPrivateActivityHelperHasVisibleActivitiesInHTMLDoc(htmlDoc *HTMLDoc) bool {
    61  	return htmlDoc.doc.Find("#activity-feed").Find(".flex-item").Length() > 0
    62  }
    63  
    64  func testPrivateActivityHelperHasVisibleActivitiesFromSession(t *testing.T, session *TestSession) bool {
    65  	req := NewRequestf(t, "GET", "/%s?tab=activity", privateActivityTestUser)
    66  	resp := session.MakeRequest(t, req, http.StatusOK)
    67  
    68  	htmlDoc := NewHTMLParser(t, resp.Body)
    69  
    70  	return testPrivateActivityHelperHasVisibleActivitiesInHTMLDoc(htmlDoc)
    71  }
    72  
    73  func testPrivateActivityHelperHasVisibleActivitiesFromPublic(t *testing.T) bool {
    74  	req := NewRequestf(t, "GET", "/%s?tab=activity", privateActivityTestUser)
    75  	resp := MakeRequest(t, req, http.StatusOK)
    76  
    77  	htmlDoc := NewHTMLParser(t, resp.Body)
    78  
    79  	return testPrivateActivityHelperHasVisibleActivitiesInHTMLDoc(htmlDoc)
    80  }
    81  
    82  // heatmap UI helpers
    83  
    84  func testPrivateActivityHelperHasVisibleHeatmapInHTMLDoc(htmlDoc *HTMLDoc) bool {
    85  	return htmlDoc.doc.Find("#user-heatmap").Length() > 0
    86  }
    87  
    88  func testPrivateActivityHelperHasVisibleProfileHeatmapFromSession(t *testing.T, session *TestSession) bool {
    89  	req := NewRequestf(t, "GET", "/%s?tab=activity", privateActivityTestUser)
    90  	resp := session.MakeRequest(t, req, http.StatusOK)
    91  
    92  	htmlDoc := NewHTMLParser(t, resp.Body)
    93  
    94  	return testPrivateActivityHelperHasVisibleHeatmapInHTMLDoc(htmlDoc)
    95  }
    96  
    97  func testPrivateActivityHelperHasVisibleDashboardHeatmapFromSession(t *testing.T, session *TestSession) bool {
    98  	req := NewRequest(t, "GET", "/")
    99  	resp := session.MakeRequest(t, req, http.StatusOK)
   100  
   101  	htmlDoc := NewHTMLParser(t, resp.Body)
   102  
   103  	return testPrivateActivityHelperHasVisibleHeatmapInHTMLDoc(htmlDoc)
   104  }
   105  
   106  func testPrivateActivityHelperHasVisibleHeatmapFromPublic(t *testing.T) bool {
   107  	req := NewRequestf(t, "GET", "/%s?tab=activity", privateActivityTestUser)
   108  	resp := MakeRequest(t, req, http.StatusOK)
   109  
   110  	htmlDoc := NewHTMLParser(t, resp.Body)
   111  
   112  	return testPrivateActivityHelperHasVisibleHeatmapInHTMLDoc(htmlDoc)
   113  }
   114  
   115  // heatmap API helpers
   116  
   117  func testPrivateActivityHelperHasHeatmapContentFromPublic(t *testing.T) bool {
   118  	req := NewRequestf(t, "GET", "/api/v1/users/%s/heatmap", privateActivityTestUser)
   119  	resp := MakeRequest(t, req, http.StatusOK)
   120  
   121  	var items []*activities_model.UserHeatmapData
   122  	DecodeJSON(t, resp, &items)
   123  
   124  	return len(items) != 0
   125  }
   126  
   127  func testPrivateActivityHelperHasHeatmapContentFromSession(t *testing.T, session *TestSession) bool {
   128  	token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeReadUser)
   129  
   130  	req := NewRequestf(t, "GET", "/api/v1/users/%s/heatmap", privateActivityTestUser).
   131  		AddTokenAuth(token)
   132  	resp := session.MakeRequest(t, req, http.StatusOK)
   133  
   134  	var items []*activities_model.UserHeatmapData
   135  	DecodeJSON(t, resp, &items)
   136  
   137  	return len(items) != 0
   138  }
   139  
   140  // check activity visibility if the visibility is enabled
   141  
   142  func TestPrivateActivityNoVisibleForPublic(t *testing.T) {
   143  	defer tests.PrepareTestEnv(t)()
   144  	testPrivateActivityDoSomethingForActionEntries(t)
   145  
   146  	visible := testPrivateActivityHelperHasVisibleActivitiesFromPublic(t)
   147  
   148  	assert.True(t, visible, "user should have visible activities")
   149  }
   150  
   151  func TestPrivateActivityNoVisibleForUserItself(t *testing.T) {
   152  	defer tests.PrepareTestEnv(t)()
   153  	testPrivateActivityDoSomethingForActionEntries(t)
   154  
   155  	session := loginUser(t, privateActivityTestUser)
   156  	visible := testPrivateActivityHelperHasVisibleActivitiesFromSession(t, session)
   157  
   158  	assert.True(t, visible, "user should have visible activities")
   159  }
   160  
   161  func TestPrivateActivityNoVisibleForOtherUser(t *testing.T) {
   162  	defer tests.PrepareTestEnv(t)()
   163  	testPrivateActivityDoSomethingForActionEntries(t)
   164  
   165  	session := loginUser(t, privateActivityTestOtherUser)
   166  	visible := testPrivateActivityHelperHasVisibleActivitiesFromSession(t, session)
   167  
   168  	assert.True(t, visible, "user should have visible activities")
   169  }
   170  
   171  func TestPrivateActivityNoVisibleForAdmin(t *testing.T) {
   172  	defer tests.PrepareTestEnv(t)()
   173  	testPrivateActivityDoSomethingForActionEntries(t)
   174  
   175  	session := loginUser(t, privateActivityTestAdmin)
   176  	visible := testPrivateActivityHelperHasVisibleActivitiesFromSession(t, session)
   177  
   178  	assert.True(t, visible, "user should have visible activities")
   179  }
   180  
   181  // check activity visibility if the visibility is disabled
   182  
   183  func TestPrivateActivityYesInvisibleForPublic(t *testing.T) {
   184  	defer tests.PrepareTestEnv(t)()
   185  	testPrivateActivityDoSomethingForActionEntries(t)
   186  	testPrivateActivityHelperEnablePrivateActivity(t)
   187  
   188  	visible := testPrivateActivityHelperHasVisibleActivitiesFromPublic(t)
   189  
   190  	assert.False(t, visible, "user should have no visible activities")
   191  }
   192  
   193  func TestPrivateActivityYesVisibleForUserItself(t *testing.T) {
   194  	defer tests.PrepareTestEnv(t)()
   195  	testPrivateActivityDoSomethingForActionEntries(t)
   196  	testPrivateActivityHelperEnablePrivateActivity(t)
   197  
   198  	session := loginUser(t, privateActivityTestUser)
   199  	visible := testPrivateActivityHelperHasVisibleActivitiesFromSession(t, session)
   200  
   201  	assert.True(t, visible, "user should have visible activities")
   202  }
   203  
   204  func TestPrivateActivityYesInvisibleForOtherUser(t *testing.T) {
   205  	defer tests.PrepareTestEnv(t)()
   206  	testPrivateActivityDoSomethingForActionEntries(t)
   207  	testPrivateActivityHelperEnablePrivateActivity(t)
   208  
   209  	session := loginUser(t, privateActivityTestOtherUser)
   210  	visible := testPrivateActivityHelperHasVisibleActivitiesFromSession(t, session)
   211  
   212  	assert.False(t, visible, "user should have no visible activities")
   213  }
   214  
   215  func TestPrivateActivityYesVisibleForAdmin(t *testing.T) {
   216  	defer tests.PrepareTestEnv(t)()
   217  	testPrivateActivityDoSomethingForActionEntries(t)
   218  	testPrivateActivityHelperEnablePrivateActivity(t)
   219  
   220  	session := loginUser(t, privateActivityTestAdmin)
   221  	visible := testPrivateActivityHelperHasVisibleActivitiesFromSession(t, session)
   222  
   223  	assert.True(t, visible, "user should have visible activities")
   224  }
   225  
   226  // check heatmap visibility if the visibility is enabled
   227  
   228  func TestPrivateActivityNoHeatmapVisibleForPublic(t *testing.T) {
   229  	defer tests.PrepareTestEnv(t)()
   230  	testPrivateActivityDoSomethingForActionEntries(t)
   231  
   232  	visible := testPrivateActivityHelperHasVisibleHeatmapFromPublic(t)
   233  
   234  	assert.True(t, visible, "user should have visible heatmap")
   235  }
   236  
   237  func TestPrivateActivityNoHeatmapVisibleForUserItselfAtProfile(t *testing.T) {
   238  	defer tests.PrepareTestEnv(t)()
   239  	testPrivateActivityDoSomethingForActionEntries(t)
   240  
   241  	session := loginUser(t, privateActivityTestUser)
   242  	visible := testPrivateActivityHelperHasVisibleProfileHeatmapFromSession(t, session)
   243  
   244  	assert.True(t, visible, "user should have visible heatmap")
   245  }
   246  
   247  func TestPrivateActivityNoHeatmapVisibleForUserItselfAtDashboard(t *testing.T) {
   248  	defer tests.PrepareTestEnv(t)()
   249  	testPrivateActivityDoSomethingForActionEntries(t)
   250  
   251  	session := loginUser(t, privateActivityTestUser)
   252  	visible := testPrivateActivityHelperHasVisibleDashboardHeatmapFromSession(t, session)
   253  
   254  	assert.True(t, visible, "user should have visible heatmap")
   255  }
   256  
   257  func TestPrivateActivityNoHeatmapVisibleForOtherUser(t *testing.T) {
   258  	defer tests.PrepareTestEnv(t)()
   259  	testPrivateActivityDoSomethingForActionEntries(t)
   260  
   261  	session := loginUser(t, privateActivityTestOtherUser)
   262  	visible := testPrivateActivityHelperHasVisibleProfileHeatmapFromSession(t, session)
   263  
   264  	assert.True(t, visible, "user should have visible heatmap")
   265  }
   266  
   267  func TestPrivateActivityNoHeatmapVisibleForAdmin(t *testing.T) {
   268  	defer tests.PrepareTestEnv(t)()
   269  	testPrivateActivityDoSomethingForActionEntries(t)
   270  
   271  	session := loginUser(t, privateActivityTestAdmin)
   272  	visible := testPrivateActivityHelperHasVisibleProfileHeatmapFromSession(t, session)
   273  
   274  	assert.True(t, visible, "user should have visible heatmap")
   275  }
   276  
   277  // check heatmap visibility if the visibility is disabled
   278  
   279  func TestPrivateActivityYesHeatmapInvisibleForPublic(t *testing.T) {
   280  	defer tests.PrepareTestEnv(t)()
   281  	testPrivateActivityDoSomethingForActionEntries(t)
   282  	testPrivateActivityHelperEnablePrivateActivity(t)
   283  
   284  	visible := testPrivateActivityHelperHasVisibleHeatmapFromPublic(t)
   285  
   286  	assert.False(t, visible, "user should have no visible heatmap")
   287  }
   288  
   289  func TestPrivateActivityYesHeatmapVisibleForUserItselfAtProfile(t *testing.T) {
   290  	defer tests.PrepareTestEnv(t)()
   291  	testPrivateActivityDoSomethingForActionEntries(t)
   292  	testPrivateActivityHelperEnablePrivateActivity(t)
   293  
   294  	session := loginUser(t, privateActivityTestUser)
   295  	visible := testPrivateActivityHelperHasVisibleProfileHeatmapFromSession(t, session)
   296  
   297  	assert.True(t, visible, "user should have visible heatmap")
   298  }
   299  
   300  func TestPrivateActivityYesHeatmapVisibleForUserItselfAtDashboard(t *testing.T) {
   301  	defer tests.PrepareTestEnv(t)()
   302  	testPrivateActivityDoSomethingForActionEntries(t)
   303  	testPrivateActivityHelperEnablePrivateActivity(t)
   304  
   305  	session := loginUser(t, privateActivityTestUser)
   306  	visible := testPrivateActivityHelperHasVisibleDashboardHeatmapFromSession(t, session)
   307  
   308  	assert.True(t, visible, "user should have visible heatmap")
   309  }
   310  
   311  func TestPrivateActivityYesHeatmapInvisibleForOtherUser(t *testing.T) {
   312  	defer tests.PrepareTestEnv(t)()
   313  	testPrivateActivityDoSomethingForActionEntries(t)
   314  	testPrivateActivityHelperEnablePrivateActivity(t)
   315  
   316  	session := loginUser(t, privateActivityTestOtherUser)
   317  	visible := testPrivateActivityHelperHasVisibleProfileHeatmapFromSession(t, session)
   318  
   319  	assert.False(t, visible, "user should have no visible heatmap")
   320  }
   321  
   322  func TestPrivateActivityYesHeatmapVisibleForAdmin(t *testing.T) {
   323  	defer tests.PrepareTestEnv(t)()
   324  	testPrivateActivityDoSomethingForActionEntries(t)
   325  	testPrivateActivityHelperEnablePrivateActivity(t)
   326  
   327  	session := loginUser(t, privateActivityTestAdmin)
   328  	visible := testPrivateActivityHelperHasVisibleProfileHeatmapFromSession(t, session)
   329  
   330  	assert.True(t, visible, "user should have visible heatmap")
   331  }
   332  
   333  // check heatmap api provides content if the visibility is enabled
   334  
   335  func TestPrivateActivityNoHeatmapHasContentForPublic(t *testing.T) {
   336  	defer tests.PrepareTestEnv(t)()
   337  	testPrivateActivityDoSomethingForActionEntries(t)
   338  
   339  	hasContent := testPrivateActivityHelperHasHeatmapContentFromPublic(t)
   340  
   341  	assert.True(t, hasContent, "user should have heatmap content")
   342  }
   343  
   344  func TestPrivateActivityNoHeatmapHasContentForUserItself(t *testing.T) {
   345  	defer tests.PrepareTestEnv(t)()
   346  	testPrivateActivityDoSomethingForActionEntries(t)
   347  
   348  	session := loginUser(t, privateActivityTestUser)
   349  	hasContent := testPrivateActivityHelperHasHeatmapContentFromSession(t, session)
   350  
   351  	assert.True(t, hasContent, "user should have heatmap content")
   352  }
   353  
   354  func TestPrivateActivityNoHeatmapHasContentForOtherUser(t *testing.T) {
   355  	defer tests.PrepareTestEnv(t)()
   356  	testPrivateActivityDoSomethingForActionEntries(t)
   357  
   358  	session := loginUser(t, privateActivityTestOtherUser)
   359  	hasContent := testPrivateActivityHelperHasHeatmapContentFromSession(t, session)
   360  
   361  	assert.True(t, hasContent, "user should have heatmap content")
   362  }
   363  
   364  func TestPrivateActivityNoHeatmapHasContentForAdmin(t *testing.T) {
   365  	defer tests.PrepareTestEnv(t)()
   366  	testPrivateActivityDoSomethingForActionEntries(t)
   367  
   368  	session := loginUser(t, privateActivityTestAdmin)
   369  	hasContent := testPrivateActivityHelperHasHeatmapContentFromSession(t, session)
   370  
   371  	assert.True(t, hasContent, "user should have heatmap content")
   372  }
   373  
   374  // check heatmap api provides no content if the visibility is disabled
   375  // this should be equal to the hidden heatmap at the UI
   376  
   377  func TestPrivateActivityYesHeatmapHasNoContentForPublic(t *testing.T) {
   378  	defer tests.PrepareTestEnv(t)()
   379  	testPrivateActivityDoSomethingForActionEntries(t)
   380  	testPrivateActivityHelperEnablePrivateActivity(t)
   381  
   382  	hasContent := testPrivateActivityHelperHasHeatmapContentFromPublic(t)
   383  
   384  	assert.False(t, hasContent, "user should have no heatmap content")
   385  }
   386  
   387  func TestPrivateActivityYesHeatmapHasNoContentForUserItself(t *testing.T) {
   388  	defer tests.PrepareTestEnv(t)()
   389  	testPrivateActivityDoSomethingForActionEntries(t)
   390  	testPrivateActivityHelperEnablePrivateActivity(t)
   391  
   392  	session := loginUser(t, privateActivityTestUser)
   393  	hasContent := testPrivateActivityHelperHasHeatmapContentFromSession(t, session)
   394  
   395  	assert.True(t, hasContent, "user should see their own heatmap content")
   396  }
   397  
   398  func TestPrivateActivityYesHeatmapHasNoContentForOtherUser(t *testing.T) {
   399  	defer tests.PrepareTestEnv(t)()
   400  	testPrivateActivityDoSomethingForActionEntries(t)
   401  	testPrivateActivityHelperEnablePrivateActivity(t)
   402  
   403  	session := loginUser(t, privateActivityTestOtherUser)
   404  	hasContent := testPrivateActivityHelperHasHeatmapContentFromSession(t, session)
   405  
   406  	assert.False(t, hasContent, "other user should not see heatmap content")
   407  }
   408  
   409  func TestPrivateActivityYesHeatmapHasNoContentForAdmin(t *testing.T) {
   410  	defer tests.PrepareTestEnv(t)()
   411  	testPrivateActivityDoSomethingForActionEntries(t)
   412  	testPrivateActivityHelperEnablePrivateActivity(t)
   413  
   414  	session := loginUser(t, privateActivityTestAdmin)
   415  	hasContent := testPrivateActivityHelperHasHeatmapContentFromSession(t, session)
   416  
   417  	assert.True(t, hasContent, "heatmap should show content for admin")
   418  }