github.com/adacta-ru/mattermost-server@v5.11.1+incompatible/app/group_test.go (about)

     1  // Copyright (c) 2016-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/model"
    10  	"github.com/stretchr/testify/require"
    11  )
    12  
    13  func TestGetGroup(t *testing.T) {
    14  	th := Setup(t).InitBasic()
    15  	defer th.TearDown()
    16  	group := th.CreateGroup()
    17  
    18  	group, err := th.App.GetGroup(group.Id)
    19  	require.Nil(t, err)
    20  	require.NotNil(t, group)
    21  
    22  	group, err = th.App.GetGroup(model.NewId())
    23  	require.NotNil(t, err)
    24  	require.Nil(t, group)
    25  }
    26  
    27  func TestGetGroupByRemoteID(t *testing.T) {
    28  	th := Setup(t).InitBasic()
    29  	defer th.TearDown()
    30  	group := th.CreateGroup()
    31  
    32  	g, err := th.App.GetGroupByRemoteID(group.RemoteId, model.GroupSourceLdap)
    33  	require.Nil(t, err)
    34  	require.NotNil(t, g)
    35  
    36  	g, err = th.App.GetGroupByRemoteID(model.NewId(), model.GroupSourceLdap)
    37  	require.NotNil(t, err)
    38  	require.Nil(t, g)
    39  }
    40  
    41  func TestGetGroupsByType(t *testing.T) {
    42  	th := Setup(t).InitBasic()
    43  	defer th.TearDown()
    44  	th.CreateGroup()
    45  	th.CreateGroup()
    46  	th.CreateGroup()
    47  
    48  	groups, err := th.App.GetGroupsBySource(model.GroupSourceLdap)
    49  	require.Nil(t, err)
    50  	require.NotEmpty(t, groups)
    51  
    52  	groups, err = th.App.GetGroupsBySource(model.GroupSource("blah"))
    53  	require.Nil(t, err)
    54  	require.Empty(t, groups)
    55  }
    56  
    57  func TestCreateGroup(t *testing.T) {
    58  	th := Setup(t).InitBasic()
    59  	defer th.TearDown()
    60  
    61  	id := model.NewId()
    62  	group := &model.Group{
    63  		DisplayName: "dn_" + id,
    64  		Name:        "name" + id,
    65  		Source:      model.GroupSourceLdap,
    66  		RemoteId:    model.NewId(),
    67  	}
    68  
    69  	g, err := th.App.CreateGroup(group)
    70  	require.Nil(t, err)
    71  	require.NotNil(t, g)
    72  
    73  	g, err = th.App.CreateGroup(group)
    74  	require.NotNil(t, err)
    75  	require.Nil(t, g)
    76  }
    77  
    78  func TestUpdateGroup(t *testing.T) {
    79  	th := Setup(t).InitBasic()
    80  	defer th.TearDown()
    81  	group := th.CreateGroup()
    82  	group.DisplayName = model.NewId()
    83  
    84  	g, err := th.App.UpdateGroup(group)
    85  	require.Nil(t, err)
    86  	require.NotNil(t, g)
    87  }
    88  
    89  func TestDeleteGroup(t *testing.T) {
    90  	th := Setup(t).InitBasic()
    91  	defer th.TearDown()
    92  	group := th.CreateGroup()
    93  
    94  	g, err := th.App.DeleteGroup(group.Id)
    95  	require.Nil(t, err)
    96  	require.NotNil(t, g)
    97  
    98  	g, err = th.App.DeleteGroup(group.Id)
    99  	require.NotNil(t, err)
   100  	require.Nil(t, g)
   101  }
   102  
   103  func TestCreateOrRestoreGroupMember(t *testing.T) {
   104  	th := Setup(t).InitBasic()
   105  	defer th.TearDown()
   106  	group := th.CreateGroup()
   107  
   108  	g, err := th.App.CreateOrRestoreGroupMember(group.Id, th.BasicUser.Id)
   109  	require.Nil(t, err)
   110  	require.NotNil(t, g)
   111  
   112  	g, err = th.App.CreateOrRestoreGroupMember(group.Id, th.BasicUser.Id)
   113  	require.NotNil(t, err)
   114  	require.Nil(t, g)
   115  }
   116  
   117  func TestDeleteGroupMember(t *testing.T) {
   118  	th := Setup(t).InitBasic()
   119  	defer th.TearDown()
   120  	group := th.CreateGroup()
   121  	groupMember, err := th.App.CreateOrRestoreGroupMember(group.Id, th.BasicUser.Id)
   122  	require.Nil(t, err)
   123  	require.NotNil(t, groupMember)
   124  
   125  	groupMember, err = th.App.DeleteGroupMember(groupMember.GroupId, groupMember.UserId)
   126  	require.Nil(t, err)
   127  	require.NotNil(t, groupMember)
   128  
   129  	groupMember, err = th.App.DeleteGroupMember(groupMember.GroupId, groupMember.UserId)
   130  	require.NotNil(t, err)
   131  	require.Nil(t, groupMember)
   132  }
   133  
   134  func TestCreateGroupSyncable(t *testing.T) {
   135  	th := Setup(t).InitBasic()
   136  	defer th.TearDown()
   137  	group := th.CreateGroup()
   138  	groupSyncable := &model.GroupSyncable{
   139  		GroupId:    group.Id,
   140  		AutoAdd:    false,
   141  		SyncableId: th.BasicTeam.Id,
   142  		Type:       model.GroupSyncableTypeTeam,
   143  	}
   144  
   145  	gs, err := th.App.CreateGroupSyncable(groupSyncable)
   146  	require.Nil(t, err)
   147  	require.NotNil(t, gs)
   148  
   149  	gs, err = th.App.CreateGroupSyncable(groupSyncable)
   150  	require.NotNil(t, err)
   151  	require.Nil(t, gs)
   152  }
   153  
   154  func TestGetGroupSyncable(t *testing.T) {
   155  	th := Setup(t).InitBasic()
   156  	defer th.TearDown()
   157  	group := th.CreateGroup()
   158  	groupSyncable := &model.GroupSyncable{
   159  		GroupId:    group.Id,
   160  		AutoAdd:    false,
   161  		SyncableId: th.BasicTeam.Id,
   162  		Type:       model.GroupSyncableTypeTeam,
   163  	}
   164  
   165  	gs, err := th.App.CreateGroupSyncable(groupSyncable)
   166  	require.Nil(t, err)
   167  	require.NotNil(t, gs)
   168  
   169  	gs, err = th.App.GetGroupSyncable(group.Id, th.BasicTeam.Id, model.GroupSyncableTypeTeam)
   170  	require.Nil(t, err)
   171  	require.NotNil(t, gs)
   172  }
   173  
   174  func TestGetGroupSyncables(t *testing.T) {
   175  	th := Setup(t).InitBasic()
   176  	defer th.TearDown()
   177  	group := th.CreateGroup()
   178  
   179  	// Create a group team
   180  	groupSyncable := &model.GroupSyncable{
   181  		GroupId:    group.Id,
   182  		AutoAdd:    false,
   183  		SyncableId: th.BasicTeam.Id,
   184  		Type:       model.GroupSyncableTypeTeam,
   185  	}
   186  
   187  	gs, err := th.App.CreateGroupSyncable(groupSyncable)
   188  	require.Nil(t, err)
   189  	require.NotNil(t, gs)
   190  
   191  	groupTeams, err := th.App.GetGroupSyncables(group.Id, model.GroupSyncableTypeTeam)
   192  	require.Nil(t, err)
   193  
   194  	require.NotEmpty(t, groupTeams)
   195  }
   196  
   197  func TestDeleteGroupSyncable(t *testing.T) {
   198  	th := Setup(t).InitBasic()
   199  	defer th.TearDown()
   200  	group := th.CreateGroup()
   201  	groupChannel := &model.GroupSyncable{
   202  		GroupId:    group.Id,
   203  		AutoAdd:    false,
   204  		SyncableId: th.BasicChannel.Id,
   205  		Type:       model.GroupSyncableTypeChannel,
   206  	}
   207  
   208  	gs, err := th.App.CreateGroupSyncable(groupChannel)
   209  	require.Nil(t, err)
   210  	require.NotNil(t, gs)
   211  
   212  	gs, err = th.App.DeleteGroupSyncable(group.Id, th.BasicChannel.Id, model.GroupSyncableTypeChannel)
   213  	require.Nil(t, err)
   214  	require.NotNil(t, gs)
   215  
   216  	gs, err = th.App.DeleteGroupSyncable(group.Id, th.BasicChannel.Id, model.GroupSyncableTypeChannel)
   217  	require.NotNil(t, err)
   218  	require.Nil(t, gs)
   219  }