github.com/haalcala/mattermost-server-change-repo/v5@v5.33.2/app/group_test.go (about)

     1  // Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
     2  // See LICENSE.txt for license information.
     3  
     4  package app
     5  
     6  import (
     7  	"testing"
     8  
     9  	"github.com/stretchr/testify/assert"
    10  	"github.com/stretchr/testify/require"
    11  
    12  	"github.com/mattermost/mattermost-server/v5/model"
    13  )
    14  
    15  func TestGetGroup(t *testing.T) {
    16  	th := Setup(t)
    17  	defer th.TearDown()
    18  	group := th.CreateGroup()
    19  
    20  	group, err := th.App.GetGroup(group.Id)
    21  	require.Nil(t, err)
    22  	require.NotNil(t, group)
    23  
    24  	group, err = th.App.GetGroup(model.NewId())
    25  	require.NotNil(t, err)
    26  	require.Nil(t, group)
    27  }
    28  
    29  func TestGetGroupByRemoteID(t *testing.T) {
    30  	th := Setup(t)
    31  	defer th.TearDown()
    32  	group := th.CreateGroup()
    33  
    34  	g, err := th.App.GetGroupByRemoteID(group.RemoteId, model.GroupSourceLdap)
    35  	require.Nil(t, err)
    36  	require.NotNil(t, g)
    37  
    38  	g, err = th.App.GetGroupByRemoteID(model.NewId(), model.GroupSourceLdap)
    39  	require.NotNil(t, err)
    40  	require.Nil(t, g)
    41  }
    42  
    43  func TestGetGroupsByType(t *testing.T) {
    44  	th := Setup(t)
    45  	defer th.TearDown()
    46  	th.CreateGroup()
    47  	th.CreateGroup()
    48  	th.CreateGroup()
    49  
    50  	groups, err := th.App.GetGroupsBySource(model.GroupSourceLdap)
    51  	require.Nil(t, err)
    52  	require.NotEmpty(t, groups)
    53  
    54  	groups, err = th.App.GetGroupsBySource(model.GroupSource("blah"))
    55  	require.Nil(t, err)
    56  	require.Empty(t, groups)
    57  }
    58  
    59  func TestCreateGroup(t *testing.T) {
    60  	th := Setup(t)
    61  	defer th.TearDown()
    62  
    63  	id := model.NewId()
    64  	group := &model.Group{
    65  		DisplayName: "dn_" + id,
    66  		Name:        model.NewString("name" + id),
    67  		Source:      model.GroupSourceLdap,
    68  		RemoteId:    model.NewId(),
    69  	}
    70  
    71  	g, err := th.App.CreateGroup(group)
    72  	require.Nil(t, err)
    73  	require.NotNil(t, g)
    74  
    75  	g, err = th.App.CreateGroup(group)
    76  	require.NotNil(t, err)
    77  	require.Nil(t, g)
    78  }
    79  
    80  func TestUpdateGroup(t *testing.T) {
    81  	th := Setup(t)
    82  	defer th.TearDown()
    83  	group := th.CreateGroup()
    84  	group.DisplayName = model.NewId()
    85  
    86  	g, err := th.App.UpdateGroup(group)
    87  	require.Nil(t, err)
    88  	require.NotNil(t, g)
    89  }
    90  
    91  func TestDeleteGroup(t *testing.T) {
    92  	th := Setup(t)
    93  	defer th.TearDown()
    94  	group := th.CreateGroup()
    95  
    96  	g, err := th.App.DeleteGroup(group.Id)
    97  	require.Nil(t, err)
    98  	require.NotNil(t, g)
    99  
   100  	g, err = th.App.DeleteGroup(group.Id)
   101  	require.NotNil(t, err)
   102  	require.Nil(t, g)
   103  }
   104  
   105  func TestCreateOrRestoreGroupMember(t *testing.T) {
   106  	th := Setup(t).InitBasic()
   107  	defer th.TearDown()
   108  	group := th.CreateGroup()
   109  
   110  	g, err := th.App.UpsertGroupMember(group.Id, th.BasicUser.Id)
   111  	require.Nil(t, err)
   112  	require.NotNil(t, g)
   113  
   114  	g, err = th.App.UpsertGroupMember(group.Id, th.BasicUser.Id)
   115  	require.Nil(t, err)
   116  	require.NotNil(t, g)
   117  }
   118  
   119  func TestDeleteGroupMember(t *testing.T) {
   120  	th := Setup(t).InitBasic()
   121  	defer th.TearDown()
   122  	group := th.CreateGroup()
   123  	groupMember, err := th.App.UpsertGroupMember(group.Id, th.BasicUser.Id)
   124  	require.Nil(t, err)
   125  	require.NotNil(t, groupMember)
   126  
   127  	groupMember, err = th.App.DeleteGroupMember(groupMember.GroupId, groupMember.UserId)
   128  	require.Nil(t, err)
   129  	require.NotNil(t, groupMember)
   130  
   131  	groupMember, err = th.App.DeleteGroupMember(groupMember.GroupId, groupMember.UserId)
   132  	require.NotNil(t, err)
   133  	require.Nil(t, groupMember)
   134  }
   135  
   136  func TestUpsertGroupSyncable(t *testing.T) {
   137  	th := Setup(t).InitBasic()
   138  	defer th.TearDown()
   139  	group := th.CreateGroup()
   140  	groupSyncable := model.NewGroupTeam(group.Id, th.BasicTeam.Id, false)
   141  
   142  	gs, err := th.App.UpsertGroupSyncable(groupSyncable)
   143  	require.Nil(t, err)
   144  	require.NotNil(t, gs)
   145  
   146  	// can update again without error
   147  	gs, err = th.App.UpsertGroupSyncable(groupSyncable)
   148  	require.Nil(t, err)
   149  	require.NotNil(t, gs)
   150  
   151  	gs, err = th.App.DeleteGroupSyncable(gs.GroupId, gs.SyncableId, gs.Type)
   152  	require.Nil(t, err)
   153  	require.NotEqual(t, int64(0), gs.DeleteAt)
   154  
   155  	// Un-deleting works
   156  	gs.DeleteAt = 0
   157  	gs, err = th.App.UpsertGroupSyncable(gs)
   158  	require.Nil(t, err)
   159  	require.Equal(t, int64(0), gs.DeleteAt)
   160  }
   161  
   162  func TestUpsertGroupSyncableTeamGroupConstrained(t *testing.T) {
   163  	th := Setup(t).InitBasic()
   164  	defer th.TearDown()
   165  
   166  	group1 := th.CreateGroup()
   167  	group2 := th.CreateGroup()
   168  
   169  	team := th.CreateTeam()
   170  	team.GroupConstrained = model.NewBool(true)
   171  	team, err := th.App.UpdateTeam(team)
   172  	require.Nil(t, err)
   173  	_, err = th.App.UpsertGroupSyncable(model.NewGroupTeam(group1.Id, team.Id, false))
   174  
   175  	channel := th.CreateChannel(team)
   176  
   177  	_, err = th.App.UpsertGroupSyncable(model.NewGroupChannel(group2.Id, channel.Id, false))
   178  	require.NotNil(t, err)
   179  	require.Equal(t, err.Id, "group_not_associated_to_synced_team")
   180  
   181  	gs, err := th.App.GetGroupSyncable(group2.Id, channel.Id, model.GroupSyncableTypeChannel)
   182  	require.Nil(t, gs)
   183  	require.NotNil(t, err)
   184  
   185  	_, err = th.App.UpsertGroupSyncable(model.NewGroupChannel(group1.Id, channel.Id, false))
   186  	require.Nil(t, err)
   187  }
   188  
   189  func TestGetGroupSyncable(t *testing.T) {
   190  	th := Setup(t).InitBasic()
   191  	defer th.TearDown()
   192  	group := th.CreateGroup()
   193  	groupSyncable := model.NewGroupTeam(group.Id, th.BasicTeam.Id, false)
   194  
   195  	gs, err := th.App.UpsertGroupSyncable(groupSyncable)
   196  	require.Nil(t, err)
   197  	require.NotNil(t, gs)
   198  
   199  	gs, err = th.App.GetGroupSyncable(group.Id, th.BasicTeam.Id, model.GroupSyncableTypeTeam)
   200  	require.Nil(t, err)
   201  	require.NotNil(t, gs)
   202  }
   203  
   204  func TestGetGroupSyncables(t *testing.T) {
   205  	th := Setup(t).InitBasic()
   206  	defer th.TearDown()
   207  	group := th.CreateGroup()
   208  
   209  	// Create a group team
   210  	groupSyncable := model.NewGroupTeam(group.Id, th.BasicTeam.Id, false)
   211  
   212  	gs, err := th.App.UpsertGroupSyncable(groupSyncable)
   213  	require.Nil(t, err)
   214  	require.NotNil(t, gs)
   215  
   216  	groupTeams, err := th.App.GetGroupSyncables(group.Id, model.GroupSyncableTypeTeam)
   217  	require.Nil(t, err)
   218  
   219  	require.NotEmpty(t, groupTeams)
   220  }
   221  
   222  func TestDeleteGroupSyncable(t *testing.T) {
   223  	th := Setup(t).InitBasic()
   224  	defer th.TearDown()
   225  	group := th.CreateGroup()
   226  	groupChannel := model.NewGroupChannel(group.Id, th.BasicChannel.Id, false)
   227  
   228  	gs, err := th.App.UpsertGroupSyncable(groupChannel)
   229  	require.Nil(t, err)
   230  	require.NotNil(t, gs)
   231  
   232  	gs, err = th.App.DeleteGroupSyncable(group.Id, th.BasicChannel.Id, model.GroupSyncableTypeChannel)
   233  	require.Nil(t, err)
   234  	require.NotNil(t, gs)
   235  
   236  	gs, err = th.App.DeleteGroupSyncable(group.Id, th.BasicChannel.Id, model.GroupSyncableTypeChannel)
   237  	require.NotNil(t, err)
   238  	require.Nil(t, gs)
   239  }
   240  
   241  func TestGetGroupsByChannel(t *testing.T) {
   242  	th := Setup(t).InitBasic()
   243  	defer th.TearDown()
   244  	group := th.CreateGroup()
   245  
   246  	// Create a group channel
   247  	groupSyncable := &model.GroupSyncable{
   248  		GroupId:    group.Id,
   249  		AutoAdd:    false,
   250  		SyncableId: th.BasicChannel.Id,
   251  		Type:       model.GroupSyncableTypeChannel,
   252  	}
   253  
   254  	gs, err := th.App.UpsertGroupSyncable(groupSyncable)
   255  	require.Nil(t, err)
   256  	require.NotNil(t, gs)
   257  
   258  	opts := model.GroupSearchOpts{
   259  		PageOpts: &model.PageOpts{
   260  			Page:    0,
   261  			PerPage: 60,
   262  		},
   263  	}
   264  
   265  	groups, _, err := th.App.GetGroupsByChannel(th.BasicChannel.Id, opts)
   266  	require.Nil(t, err)
   267  	require.ElementsMatch(t, []*model.GroupWithSchemeAdmin{{Group: *group, SchemeAdmin: model.NewBool(false)}}, groups)
   268  	require.NotNil(t, groups[0].SchemeAdmin)
   269  
   270  	groups, _, err = th.App.GetGroupsByChannel(model.NewId(), opts)
   271  	require.Nil(t, err)
   272  	require.Empty(t, groups)
   273  }
   274  
   275  func TestGetGroupsAssociatedToChannelsByTeam(t *testing.T) {
   276  	th := Setup(t).InitBasic()
   277  	defer th.TearDown()
   278  	group := th.CreateGroup()
   279  
   280  	// Create a group channel
   281  	groupSyncable := &model.GroupSyncable{
   282  		GroupId:    group.Id,
   283  		AutoAdd:    false,
   284  		SyncableId: th.BasicChannel.Id,
   285  		Type:       model.GroupSyncableTypeChannel,
   286  	}
   287  
   288  	gs, err := th.App.UpsertGroupSyncable(groupSyncable)
   289  	require.Nil(t, err)
   290  	require.NotNil(t, gs)
   291  
   292  	opts := model.GroupSearchOpts{
   293  		PageOpts: &model.PageOpts{
   294  			Page:    0,
   295  			PerPage: 60,
   296  		},
   297  	}
   298  
   299  	groups, err := th.App.GetGroupsAssociatedToChannelsByTeam(th.BasicTeam.Id, opts)
   300  	require.Nil(t, err)
   301  
   302  	assert.Equal(t, map[string][]*model.GroupWithSchemeAdmin{
   303  		th.BasicChannel.Id: {
   304  			{Group: *group, SchemeAdmin: model.NewBool(false)},
   305  		},
   306  	}, groups)
   307  	require.NotNil(t, groups[th.BasicChannel.Id][0].SchemeAdmin)
   308  
   309  	groups, err = th.App.GetGroupsAssociatedToChannelsByTeam(model.NewId(), opts)
   310  	require.Nil(t, err)
   311  	require.Empty(t, groups)
   312  }
   313  
   314  func TestGetGroupsByTeam(t *testing.T) {
   315  	th := Setup(t).InitBasic()
   316  	defer th.TearDown()
   317  	group := th.CreateGroup()
   318  
   319  	// Create a group team
   320  	groupSyncable := &model.GroupSyncable{
   321  		GroupId:    group.Id,
   322  		AutoAdd:    false,
   323  		SyncableId: th.BasicTeam.Id,
   324  		Type:       model.GroupSyncableTypeTeam,
   325  	}
   326  
   327  	gs, err := th.App.UpsertGroupSyncable(groupSyncable)
   328  	require.Nil(t, err)
   329  	require.NotNil(t, gs)
   330  
   331  	groups, _, err := th.App.GetGroupsByTeam(th.BasicTeam.Id, model.GroupSearchOpts{})
   332  	require.Nil(t, err)
   333  	require.ElementsMatch(t, []*model.GroupWithSchemeAdmin{{Group: *group, SchemeAdmin: model.NewBool(false)}}, groups)
   334  	require.NotNil(t, groups[0].SchemeAdmin)
   335  
   336  	groups, _, err = th.App.GetGroupsByTeam(model.NewId(), model.GroupSearchOpts{})
   337  	require.Nil(t, err)
   338  	require.Empty(t, groups)
   339  }
   340  
   341  func TestGetGroups(t *testing.T) {
   342  	th := Setup(t)
   343  	defer th.TearDown()
   344  	group := th.CreateGroup()
   345  
   346  	groups, err := th.App.GetGroups(0, 60, model.GroupSearchOpts{})
   347  	require.Nil(t, err)
   348  	require.ElementsMatch(t, []*model.Group{group}, groups)
   349  }
   350  
   351  func TestUserIsInAdminRoleGroup(t *testing.T) {
   352  	th := Setup(t).InitBasic()
   353  	defer th.TearDown()
   354  	group1 := th.CreateGroup()
   355  	group2 := th.CreateGroup()
   356  
   357  	g, err := th.App.UpsertGroupMember(group1.Id, th.BasicUser.Id)
   358  	require.Nil(t, err)
   359  	require.NotNil(t, g)
   360  
   361  	g, err = th.App.UpsertGroupMember(group2.Id, th.BasicUser.Id)
   362  	require.Nil(t, err)
   363  	require.NotNil(t, g)
   364  
   365  	_, err = th.App.UpsertGroupSyncable(&model.GroupSyncable{
   366  		GroupId:    group1.Id,
   367  		AutoAdd:    false,
   368  		SyncableId: th.BasicTeam.Id,
   369  		Type:       model.GroupSyncableTypeTeam,
   370  	})
   371  	require.Nil(t, err)
   372  
   373  	groupSyncable2, err := th.App.UpsertGroupSyncable(&model.GroupSyncable{
   374  		GroupId:    group2.Id,
   375  		AutoAdd:    false,
   376  		SyncableId: th.BasicTeam.Id,
   377  		Type:       model.GroupSyncableTypeTeam,
   378  	})
   379  	require.Nil(t, err)
   380  
   381  	// no syncables are set to scheme admin true, so this returns false
   382  	actual, err := th.App.UserIsInAdminRoleGroup(th.BasicUser.Id, th.BasicTeam.Id, model.GroupSyncableTypeTeam)
   383  	require.Nil(t, err)
   384  	require.False(t, actual)
   385  
   386  	// set a syncable to be scheme admins
   387  	groupSyncable2.SchemeAdmin = true
   388  	_, err = th.App.UpdateGroupSyncable(groupSyncable2)
   389  	require.Nil(t, err)
   390  
   391  	// a syncable is set to scheme admin true, so this returns true
   392  	actual, err = th.App.UserIsInAdminRoleGroup(th.BasicUser.Id, th.BasicTeam.Id, model.GroupSyncableTypeTeam)
   393  	require.Nil(t, err)
   394  	require.True(t, actual)
   395  
   396  	// delete the syncable, should be false again
   397  	th.App.DeleteGroupSyncable(group2.Id, th.BasicTeam.Id, model.GroupSyncableTypeTeam)
   398  	actual, err = th.App.UserIsInAdminRoleGroup(th.BasicUser.Id, th.BasicTeam.Id, model.GroupSyncableTypeTeam)
   399  	require.Nil(t, err)
   400  	require.False(t, actual)
   401  }