github.com/xzl8028/xenia-server@v0.0.0-20190809101854-18450a97da63/store/storetest/role_store.go (about)

     1  // Copyright (c) 2018-present Xenia, Inc. All Rights Reserved.
     2  // See License.txt for license information.
     3  
     4  package storetest
     5  
     6  import (
     7  	"testing"
     8  
     9  	"github.com/stretchr/testify/assert"
    10  	"github.com/stretchr/testify/require"
    11  
    12  	"github.com/xzl8028/xenia-server/model"
    13  	"github.com/xzl8028/xenia-server/store"
    14  )
    15  
    16  func TestRoleStore(t *testing.T, ss store.Store) {
    17  	t.Run("Save", func(t *testing.T) { testRoleStoreSave(t, ss) })
    18  	t.Run("Get", func(t *testing.T) { testRoleStoreGet(t, ss) })
    19  	t.Run("GetAll", func(t *testing.T) { testRoleStoreGetAll(t, ss) })
    20  	t.Run("GetByName", func(t *testing.T) { testRoleStoreGetByName(t, ss) })
    21  	t.Run("GetNames", func(t *testing.T) { testRoleStoreGetByNames(t, ss) })
    22  	t.Run("Delete", func(t *testing.T) { testRoleStoreDelete(t, ss) })
    23  	t.Run("PermanentDeleteAll", func(t *testing.T) { testRoleStorePermanentDeleteAll(t, ss) })
    24  }
    25  
    26  func testRoleStoreSave(t *testing.T, ss store.Store) {
    27  	// Save a new role.
    28  	r1 := &model.Role{
    29  		Name:        model.NewId(),
    30  		DisplayName: model.NewId(),
    31  		Description: model.NewId(),
    32  		Permissions: []string{
    33  			"invite_user",
    34  			"create_public_channel",
    35  			"add_user_to_team",
    36  		},
    37  		SchemeManaged: false,
    38  	}
    39  
    40  	d1, err := ss.Role().Save(r1)
    41  	assert.Nil(t, err)
    42  	assert.Len(t, d1.Id, 26)
    43  	assert.Equal(t, r1.Name, d1.Name)
    44  	assert.Equal(t, r1.DisplayName, d1.DisplayName)
    45  	assert.Equal(t, r1.Description, d1.Description)
    46  	assert.Equal(t, r1.Permissions, d1.Permissions)
    47  	assert.Equal(t, r1.SchemeManaged, d1.SchemeManaged)
    48  
    49  	// Change the role permissions and update.
    50  	d1.Permissions = []string{
    51  		"invite_user",
    52  		"add_user_to_team",
    53  		"delete_public_channel",
    54  	}
    55  
    56  	d2, err := ss.Role().Save(d1)
    57  	assert.Nil(t, err)
    58  	assert.Len(t, d2.Id, 26)
    59  	assert.Equal(t, r1.Name, d2.Name)
    60  	assert.Equal(t, r1.DisplayName, d2.DisplayName)
    61  	assert.Equal(t, r1.Description, d2.Description)
    62  	assert.Equal(t, d1.Permissions, d2.Permissions)
    63  	assert.Equal(t, r1.SchemeManaged, d2.SchemeManaged)
    64  
    65  	// Try saving one with an invalid ID set.
    66  	r3 := &model.Role{
    67  		Id:          model.NewId(),
    68  		Name:        model.NewId(),
    69  		DisplayName: model.NewId(),
    70  		Description: model.NewId(),
    71  		Permissions: []string{
    72  			"invite_user",
    73  			"create_public_channel",
    74  			"add_user_to_team",
    75  		},
    76  		SchemeManaged: false,
    77  	}
    78  
    79  	_, err = ss.Role().Save(r3)
    80  	assert.NotNil(t, err)
    81  
    82  	// Try saving one with a duplicate "name" field.
    83  	r4 := &model.Role{
    84  		Name:        r1.Name,
    85  		DisplayName: model.NewId(),
    86  		Description: model.NewId(),
    87  		Permissions: []string{
    88  			"invite_user",
    89  			"create_public_channel",
    90  			"add_user_to_team",
    91  		},
    92  		SchemeManaged: false,
    93  	}
    94  
    95  	_, err = ss.Role().Save(r4)
    96  	assert.NotNil(t, err)
    97  }
    98  
    99  func testRoleStoreGetAll(t *testing.T, ss store.Store) {
   100  	prev, err := ss.Role().GetAll()
   101  	require.Nil(t, err)
   102  	prevCount := len(prev)
   103  
   104  	// Save a role to test with.
   105  	r1 := &model.Role{
   106  		Name:        model.NewId(),
   107  		DisplayName: model.NewId(),
   108  		Description: model.NewId(),
   109  		Permissions: []string{
   110  			"invite_user",
   111  			"create_public_channel",
   112  			"add_user_to_team",
   113  		},
   114  		SchemeManaged: false,
   115  	}
   116  
   117  	_, err = ss.Role().Save(r1)
   118  	require.Nil(t, err)
   119  
   120  	r2 := &model.Role{
   121  		Name:        model.NewId(),
   122  		DisplayName: model.NewId(),
   123  		Description: model.NewId(),
   124  		Permissions: []string{
   125  			"invite_user",
   126  			"create_public_channel",
   127  			"add_user_to_team",
   128  		},
   129  		SchemeManaged: false,
   130  	}
   131  	_, err = ss.Role().Save(r2)
   132  	require.Nil(t, err)
   133  
   134  	data, err := ss.Role().GetAll()
   135  	require.Nil(t, err)
   136  	assert.Len(t, data, prevCount+2)
   137  }
   138  
   139  func testRoleStoreGet(t *testing.T, ss store.Store) {
   140  	// Save a role to test with.
   141  	r1 := &model.Role{
   142  		Name:        model.NewId(),
   143  		DisplayName: model.NewId(),
   144  		Description: model.NewId(),
   145  		Permissions: []string{
   146  			"invite_user",
   147  			"create_public_channel",
   148  			"add_user_to_team",
   149  		},
   150  		SchemeManaged: false,
   151  	}
   152  
   153  	d1, err := ss.Role().Save(r1)
   154  	assert.Nil(t, err)
   155  	assert.Len(t, d1.Id, 26)
   156  
   157  	// Get a valid role
   158  	d2, err := ss.Role().Get(d1.Id)
   159  	assert.Nil(t, err)
   160  	assert.Equal(t, d1.Id, d2.Id)
   161  	assert.Equal(t, r1.Name, d2.Name)
   162  	assert.Equal(t, r1.DisplayName, d2.DisplayName)
   163  	assert.Equal(t, r1.Description, d2.Description)
   164  	assert.Equal(t, r1.Permissions, d2.Permissions)
   165  	assert.Equal(t, r1.SchemeManaged, d2.SchemeManaged)
   166  
   167  	// Get an invalid role
   168  	_, err = ss.Role().Get(model.NewId())
   169  	assert.NotNil(t, err)
   170  }
   171  
   172  func testRoleStoreGetByName(t *testing.T, ss store.Store) {
   173  	// Save a role to test with.
   174  	r1 := &model.Role{
   175  		Name:        model.NewId(),
   176  		DisplayName: model.NewId(),
   177  		Description: model.NewId(),
   178  		Permissions: []string{
   179  			"invite_user",
   180  			"create_public_channel",
   181  			"add_user_to_team",
   182  		},
   183  		SchemeManaged: false,
   184  	}
   185  
   186  	d1, err := ss.Role().Save(r1)
   187  	assert.Nil(t, err)
   188  	assert.Len(t, d1.Id, 26)
   189  
   190  	// Get a valid role
   191  	d2, err := ss.Role().GetByName(d1.Name)
   192  	assert.Nil(t, err)
   193  	assert.Equal(t, d1.Id, d2.Id)
   194  	assert.Equal(t, r1.Name, d2.Name)
   195  	assert.Equal(t, r1.DisplayName, d2.DisplayName)
   196  	assert.Equal(t, r1.Description, d2.Description)
   197  	assert.Equal(t, r1.Permissions, d2.Permissions)
   198  	assert.Equal(t, r1.SchemeManaged, d2.SchemeManaged)
   199  
   200  	// Get an invalid role
   201  	_, err = ss.Role().GetByName(model.NewId())
   202  	assert.NotNil(t, err)
   203  }
   204  
   205  func testRoleStoreGetByNames(t *testing.T, ss store.Store) {
   206  	// Save some roles to test with.
   207  	r1 := &model.Role{
   208  		Name:        model.NewId(),
   209  		DisplayName: model.NewId(),
   210  		Description: model.NewId(),
   211  		Permissions: []string{
   212  			"invite_user",
   213  			"create_public_channel",
   214  			"add_user_to_team",
   215  		},
   216  		SchemeManaged: false,
   217  	}
   218  	r2 := &model.Role{
   219  		Name:        model.NewId(),
   220  		DisplayName: model.NewId(),
   221  		Description: model.NewId(),
   222  		Permissions: []string{
   223  			"read_channel",
   224  			"create_public_channel",
   225  			"add_user_to_team",
   226  		},
   227  		SchemeManaged: false,
   228  	}
   229  	r3 := &model.Role{
   230  		Name:        model.NewId(),
   231  		DisplayName: model.NewId(),
   232  		Description: model.NewId(),
   233  		Permissions: []string{
   234  			"invite_user",
   235  			"delete_private_channel",
   236  			"add_user_to_team",
   237  		},
   238  		SchemeManaged: false,
   239  	}
   240  
   241  	d1, err := ss.Role().Save(r1)
   242  	assert.Nil(t, err)
   243  	assert.Len(t, d1.Id, 26)
   244  
   245  	d2, err := ss.Role().Save(r2)
   246  	assert.Nil(t, err)
   247  	assert.Len(t, d2.Id, 26)
   248  
   249  	d3, err := ss.Role().Save(r3)
   250  	assert.Nil(t, err)
   251  	assert.Len(t, d3.Id, 26)
   252  
   253  	// Get two valid roles.
   254  	n4 := []string{r1.Name, r2.Name}
   255  	roles4, err := ss.Role().GetByNames(n4)
   256  	assert.Nil(t, err)
   257  	assert.Len(t, roles4, 2)
   258  	assert.Contains(t, roles4, d1)
   259  	assert.Contains(t, roles4, d2)
   260  	assert.NotContains(t, roles4, d3)
   261  
   262  	// Get two invalid roles.
   263  	n5 := []string{model.NewId(), model.NewId()}
   264  	roles5, err := ss.Role().GetByNames(n5)
   265  	assert.Nil(t, err)
   266  	assert.Len(t, roles5, 0)
   267  
   268  	// Get one valid one and one invalid one.
   269  	n6 := []string{r1.Name, model.NewId()}
   270  	roles6, err := ss.Role().GetByNames(n6)
   271  	assert.Nil(t, err)
   272  	assert.Len(t, roles6, 1)
   273  	assert.Contains(t, roles6, d1)
   274  	assert.NotContains(t, roles6, d2)
   275  	assert.NotContains(t, roles6, d3)
   276  }
   277  
   278  func testRoleStoreDelete(t *testing.T, ss store.Store) {
   279  	// Save a role to test with.
   280  	r1 := &model.Role{
   281  		Name:        model.NewId(),
   282  		DisplayName: model.NewId(),
   283  		Description: model.NewId(),
   284  		Permissions: []string{
   285  			"invite_user",
   286  			"create_public_channel",
   287  			"add_user_to_team",
   288  		},
   289  		SchemeManaged: false,
   290  	}
   291  
   292  	d1, err := ss.Role().Save(r1)
   293  	assert.Nil(t, err)
   294  	assert.Len(t, d1.Id, 26)
   295  
   296  	// Check the role is there.
   297  	_, err = ss.Role().Get(d1.Id)
   298  	assert.Nil(t, err)
   299  
   300  	// Delete the role.
   301  	_, err = ss.Role().Delete(d1.Id)
   302  	assert.Nil(t, err)
   303  
   304  	// Check the role is deleted there.
   305  	d2, err := ss.Role().Get(d1.Id)
   306  	assert.Nil(t, err)
   307  	assert.NotZero(t, d2.DeleteAt)
   308  
   309  	d3, err := ss.Role().GetByName(d1.Name)
   310  	assert.Nil(t, err)
   311  	assert.NotZero(t, d3.DeleteAt)
   312  
   313  	// Try and delete a role that does not exist.
   314  	_, err = ss.Role().Delete(model.NewId())
   315  	assert.NotNil(t, err)
   316  }
   317  
   318  func testRoleStorePermanentDeleteAll(t *testing.T, ss store.Store) {
   319  	r1 := &model.Role{
   320  		Name:        model.NewId(),
   321  		DisplayName: model.NewId(),
   322  		Description: model.NewId(),
   323  		Permissions: []string{
   324  			"invite_user",
   325  			"create_public_channel",
   326  			"add_user_to_team",
   327  		},
   328  		SchemeManaged: false,
   329  	}
   330  
   331  	r2 := &model.Role{
   332  		Name:        model.NewId(),
   333  		DisplayName: model.NewId(),
   334  		Description: model.NewId(),
   335  		Permissions: []string{
   336  			"read_channel",
   337  			"create_public_channel",
   338  			"add_user_to_team",
   339  		},
   340  		SchemeManaged: false,
   341  	}
   342  
   343  	_, err := ss.Role().Save(r1)
   344  	require.Nil(t, err)
   345  	_, err = ss.Role().Save(r2)
   346  	require.Nil(t, err)
   347  
   348  	roles, err := ss.Role().GetByNames([]string{r1.Name, r2.Name})
   349  	assert.Nil(t, err)
   350  	assert.Len(t, roles, 2)
   351  
   352  	err = ss.Role().PermanentDeleteAll()
   353  	assert.Nil(t, err)
   354  
   355  	roles, err = ss.Role().GetByNames([]string{r1.Name, r2.Name})
   356  	assert.Nil(t, err)
   357  	assert.Len(t, roles, 0)
   358  }