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