github.com/xzl8028/xenia-server@v0.0.0-20190809101854-18450a97da63/store/storetest/scheme_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 TestSchemeStore(t *testing.T, ss store.Store) {
    17  	createDefaultRoles(t, ss)
    18  
    19  	t.Run("Save", func(t *testing.T) { testSchemeStoreSave(t, ss) })
    20  	t.Run("Get", func(t *testing.T) { testSchemeStoreGet(t, ss) })
    21  	t.Run("GetAllPage", func(t *testing.T) { testSchemeStoreGetAllPage(t, ss) })
    22  	t.Run("Delete", func(t *testing.T) { testSchemeStoreDelete(t, ss) })
    23  	t.Run("PermanentDeleteAll", func(t *testing.T) { testSchemeStorePermanentDeleteAll(t, ss) })
    24  	t.Run("GetByName", func(t *testing.T) { testSchemeStoreGetByName(t, ss) })
    25  }
    26  
    27  func createDefaultRoles(t *testing.T, ss store.Store) {
    28  	ss.Role().Save(&model.Role{
    29  		Name:        model.TEAM_ADMIN_ROLE_ID,
    30  		DisplayName: model.TEAM_ADMIN_ROLE_ID,
    31  		Permissions: []string{
    32  			model.PERMISSION_DELETE_OTHERS_POSTS.Id,
    33  		},
    34  	})
    35  
    36  	ss.Role().Save(&model.Role{
    37  		Name:        model.TEAM_USER_ROLE_ID,
    38  		DisplayName: model.TEAM_USER_ROLE_ID,
    39  		Permissions: []string{
    40  			model.PERMISSION_VIEW_TEAM.Id,
    41  			model.PERMISSION_ADD_USER_TO_TEAM.Id,
    42  		},
    43  	})
    44  
    45  	ss.Role().Save(&model.Role{
    46  		Name:        model.TEAM_GUEST_ROLE_ID,
    47  		DisplayName: model.TEAM_GUEST_ROLE_ID,
    48  		Permissions: []string{
    49  			model.PERMISSION_VIEW_TEAM.Id,
    50  		},
    51  	})
    52  
    53  	ss.Role().Save(&model.Role{
    54  		Name:        model.CHANNEL_ADMIN_ROLE_ID,
    55  		DisplayName: model.CHANNEL_ADMIN_ROLE_ID,
    56  		Permissions: []string{
    57  			model.PERMISSION_MANAGE_PUBLIC_CHANNEL_MEMBERS.Id,
    58  			model.PERMISSION_MANAGE_PRIVATE_CHANNEL_MEMBERS.Id,
    59  		},
    60  	})
    61  
    62  	ss.Role().Save(&model.Role{
    63  		Name:        model.CHANNEL_USER_ROLE_ID,
    64  		DisplayName: model.CHANNEL_USER_ROLE_ID,
    65  		Permissions: []string{
    66  			model.PERMISSION_READ_CHANNEL.Id,
    67  			model.PERMISSION_CREATE_POST.Id,
    68  		},
    69  	})
    70  
    71  	ss.Role().Save(&model.Role{
    72  		Name:        model.CHANNEL_GUEST_ROLE_ID,
    73  		DisplayName: model.CHANNEL_GUEST_ROLE_ID,
    74  		Permissions: []string{
    75  			model.PERMISSION_READ_CHANNEL.Id,
    76  			model.PERMISSION_CREATE_POST.Id,
    77  		},
    78  	})
    79  }
    80  
    81  func testSchemeStoreSave(t *testing.T, ss store.Store) {
    82  	// Save a new scheme.
    83  	s1 := &model.Scheme{
    84  		DisplayName: model.NewId(),
    85  		Name:        model.NewId(),
    86  		Description: model.NewId(),
    87  		Scope:       model.SCHEME_SCOPE_TEAM,
    88  	}
    89  
    90  	// Check all fields saved correctly.
    91  	res1 := <-ss.Scheme().Save(s1)
    92  	assert.Nil(t, res1.Err)
    93  	d1 := res1.Data.(*model.Scheme)
    94  	assert.Len(t, d1.Id, 26)
    95  	assert.Equal(t, s1.DisplayName, d1.DisplayName)
    96  	assert.Equal(t, s1.Name, d1.Name)
    97  	assert.Equal(t, s1.Description, d1.Description)
    98  	assert.NotZero(t, d1.CreateAt)
    99  	assert.NotZero(t, d1.UpdateAt)
   100  	assert.Zero(t, d1.DeleteAt)
   101  	assert.Equal(t, s1.Scope, d1.Scope)
   102  	assert.Len(t, d1.DefaultTeamAdminRole, 26)
   103  	assert.Len(t, d1.DefaultTeamUserRole, 26)
   104  	assert.Len(t, d1.DefaultTeamGuestRole, 26)
   105  	assert.Len(t, d1.DefaultChannelAdminRole, 26)
   106  	assert.Len(t, d1.DefaultChannelUserRole, 26)
   107  	assert.Len(t, d1.DefaultChannelGuestRole, 26)
   108  
   109  	// Check the default roles were created correctly.
   110  	role1, err := ss.Role().GetByName(d1.DefaultTeamAdminRole)
   111  	assert.Nil(t, err)
   112  	assert.Equal(t, role1.Permissions, []string{"delete_others_posts"})
   113  	assert.True(t, role1.SchemeManaged)
   114  
   115  	role2, err := ss.Role().GetByName(d1.DefaultTeamUserRole)
   116  	assert.Nil(t, err)
   117  	assert.Equal(t, role2.Permissions, []string{"view_team", "add_user_to_team"})
   118  	assert.True(t, role2.SchemeManaged)
   119  
   120  	role3, err := ss.Role().GetByName(d1.DefaultChannelAdminRole)
   121  	assert.Nil(t, err)
   122  	assert.Equal(t, role3.Permissions, []string{"manage_public_channel_members", "manage_private_channel_members"})
   123  	assert.True(t, role3.SchemeManaged)
   124  
   125  	role4, err := ss.Role().GetByName(d1.DefaultChannelUserRole)
   126  	assert.Nil(t, err)
   127  	assert.Equal(t, role4.Permissions, []string{"read_channel", "create_post"})
   128  	assert.True(t, role4.SchemeManaged)
   129  
   130  	role5, err := ss.Role().GetByName(d1.DefaultTeamGuestRole)
   131  	assert.Nil(t, err)
   132  	assert.Equal(t, role5.Permissions, []string{"view_team"})
   133  	assert.True(t, role5.SchemeManaged)
   134  
   135  	role6, err := ss.Role().GetByName(d1.DefaultChannelGuestRole)
   136  	assert.Nil(t, err)
   137  	assert.Equal(t, role6.Permissions, []string{"read_channel", "create_post"})
   138  	assert.True(t, role6.SchemeManaged)
   139  
   140  	// Change the scheme description and update.
   141  	d1.Description = model.NewId()
   142  
   143  	res2 := <-ss.Scheme().Save(d1)
   144  	assert.Nil(t, res2.Err)
   145  	d2 := res2.Data.(*model.Scheme)
   146  	assert.Equal(t, d1.Id, d2.Id)
   147  	assert.Equal(t, s1.DisplayName, d2.DisplayName)
   148  	assert.Equal(t, s1.Name, d2.Name)
   149  	assert.Equal(t, d1.Description, d2.Description)
   150  	assert.NotZero(t, d2.CreateAt)
   151  	assert.NotZero(t, d2.UpdateAt)
   152  	assert.Zero(t, d2.DeleteAt)
   153  	assert.Equal(t, s1.Scope, d2.Scope)
   154  	assert.Equal(t, d1.DefaultTeamAdminRole, d2.DefaultTeamAdminRole)
   155  	assert.Equal(t, d1.DefaultTeamUserRole, d2.DefaultTeamUserRole)
   156  	assert.Equal(t, d1.DefaultTeamGuestRole, d2.DefaultTeamGuestRole)
   157  	assert.Equal(t, d1.DefaultChannelAdminRole, d2.DefaultChannelAdminRole)
   158  	assert.Equal(t, d1.DefaultChannelUserRole, d2.DefaultChannelUserRole)
   159  	assert.Equal(t, d1.DefaultChannelGuestRole, d2.DefaultChannelGuestRole)
   160  
   161  	// Try saving one with an invalid ID set.
   162  	s3 := &model.Scheme{
   163  		Id:          model.NewId(),
   164  		DisplayName: model.NewId(),
   165  		Name:        model.NewId(),
   166  		Description: model.NewId(),
   167  		Scope:       model.SCHEME_SCOPE_TEAM,
   168  	}
   169  
   170  	res3 := <-ss.Scheme().Save(s3)
   171  	assert.NotNil(t, res3.Err)
   172  }
   173  
   174  func testSchemeStoreGet(t *testing.T, ss store.Store) {
   175  	// Save a scheme to test with.
   176  	s1 := &model.Scheme{
   177  		DisplayName: model.NewId(),
   178  		Name:        model.NewId(),
   179  		Description: model.NewId(),
   180  		Scope:       model.SCHEME_SCOPE_TEAM,
   181  	}
   182  
   183  	res1 := <-ss.Scheme().Save(s1)
   184  	assert.Nil(t, res1.Err)
   185  	d1 := res1.Data.(*model.Scheme)
   186  	assert.Len(t, d1.Id, 26)
   187  
   188  	// Get a valid scheme
   189  	res2 := <-ss.Scheme().Get(d1.Id)
   190  	assert.Nil(t, res2.Err)
   191  	d2 := res1.Data.(*model.Scheme)
   192  	assert.Equal(t, d1.Id, d2.Id)
   193  	assert.Equal(t, s1.DisplayName, d2.DisplayName)
   194  	assert.Equal(t, s1.Name, d2.Name)
   195  	assert.Equal(t, d1.Description, d2.Description)
   196  	assert.NotZero(t, d2.CreateAt)
   197  	assert.NotZero(t, d2.UpdateAt)
   198  	assert.Zero(t, d2.DeleteAt)
   199  	assert.Equal(t, s1.Scope, d2.Scope)
   200  	assert.Equal(t, d1.DefaultTeamAdminRole, d2.DefaultTeamAdminRole)
   201  	assert.Equal(t, d1.DefaultTeamUserRole, d2.DefaultTeamUserRole)
   202  	assert.Equal(t, d1.DefaultTeamGuestRole, d2.DefaultTeamGuestRole)
   203  	assert.Equal(t, d1.DefaultChannelAdminRole, d2.DefaultChannelAdminRole)
   204  	assert.Equal(t, d1.DefaultChannelUserRole, d2.DefaultChannelUserRole)
   205  	assert.Equal(t, d1.DefaultChannelGuestRole, d2.DefaultChannelGuestRole)
   206  
   207  	// Get an invalid scheme
   208  	res3 := <-ss.Scheme().Get(model.NewId())
   209  	assert.NotNil(t, res3.Err)
   210  }
   211  
   212  func testSchemeStoreGetByName(t *testing.T, ss store.Store) {
   213  	// Save a scheme to test with.
   214  	s1 := &model.Scheme{
   215  		DisplayName: model.NewId(),
   216  		Name:        model.NewId(),
   217  		Description: model.NewId(),
   218  		Scope:       model.SCHEME_SCOPE_TEAM,
   219  	}
   220  
   221  	res1 := <-ss.Scheme().Save(s1)
   222  	assert.Nil(t, res1.Err)
   223  	d1 := res1.Data.(*model.Scheme)
   224  	assert.Len(t, d1.Id, 26)
   225  
   226  	// Get a valid scheme
   227  	res2 := <-ss.Scheme().GetByName(d1.Name)
   228  	assert.Nil(t, res2.Err)
   229  	d2 := res1.Data.(*model.Scheme)
   230  	assert.Equal(t, d1.Id, d2.Id)
   231  	assert.Equal(t, s1.DisplayName, d2.DisplayName)
   232  	assert.Equal(t, s1.Name, d2.Name)
   233  	assert.Equal(t, d1.Description, d2.Description)
   234  	assert.NotZero(t, d2.CreateAt)
   235  	assert.NotZero(t, d2.UpdateAt)
   236  	assert.Zero(t, d2.DeleteAt)
   237  	assert.Equal(t, s1.Scope, d2.Scope)
   238  	assert.Equal(t, d1.DefaultTeamAdminRole, d2.DefaultTeamAdminRole)
   239  	assert.Equal(t, d1.DefaultTeamUserRole, d2.DefaultTeamUserRole)
   240  	assert.Equal(t, d1.DefaultTeamGuestRole, d2.DefaultTeamGuestRole)
   241  	assert.Equal(t, d1.DefaultChannelAdminRole, d2.DefaultChannelAdminRole)
   242  	assert.Equal(t, d1.DefaultChannelUserRole, d2.DefaultChannelUserRole)
   243  	assert.Equal(t, d1.DefaultChannelGuestRole, d2.DefaultChannelGuestRole)
   244  
   245  	// Get an invalid scheme
   246  	res3 := <-ss.Scheme().GetByName(model.NewId())
   247  	assert.NotNil(t, res3.Err)
   248  }
   249  
   250  func testSchemeStoreGetAllPage(t *testing.T, ss store.Store) {
   251  	// Save a scheme to test with.
   252  	schemes := []*model.Scheme{
   253  		{
   254  			DisplayName: model.NewId(),
   255  			Name:        model.NewId(),
   256  			Description: model.NewId(),
   257  			Scope:       model.SCHEME_SCOPE_TEAM,
   258  		},
   259  		{
   260  			DisplayName: model.NewId(),
   261  			Name:        model.NewId(),
   262  			Description: model.NewId(),
   263  			Scope:       model.SCHEME_SCOPE_CHANNEL,
   264  		},
   265  		{
   266  			DisplayName: model.NewId(),
   267  			Name:        model.NewId(),
   268  			Description: model.NewId(),
   269  			Scope:       model.SCHEME_SCOPE_TEAM,
   270  		},
   271  		{
   272  			DisplayName: model.NewId(),
   273  			Name:        model.NewId(),
   274  			Description: model.NewId(),
   275  			Scope:       model.SCHEME_SCOPE_CHANNEL,
   276  		},
   277  	}
   278  
   279  	for _, scheme := range schemes {
   280  		store.Must(ss.Scheme().Save(scheme))
   281  	}
   282  
   283  	r1 := <-ss.Scheme().GetAllPage("", 0, 2)
   284  	assert.Nil(t, r1.Err)
   285  	s1 := r1.Data.([]*model.Scheme)
   286  	assert.Len(t, s1, 2)
   287  
   288  	r2 := <-ss.Scheme().GetAllPage("", 2, 2)
   289  	assert.Nil(t, r2.Err)
   290  	s2 := r2.Data.([]*model.Scheme)
   291  	assert.Len(t, s2, 2)
   292  	assert.NotEqual(t, s1[0].DisplayName, s2[0].DisplayName)
   293  	assert.NotEqual(t, s1[0].DisplayName, s2[1].DisplayName)
   294  	assert.NotEqual(t, s1[1].DisplayName, s2[0].DisplayName)
   295  	assert.NotEqual(t, s1[1].DisplayName, s2[1].DisplayName)
   296  	assert.NotEqual(t, s1[0].Name, s2[0].Name)
   297  	assert.NotEqual(t, s1[0].Name, s2[1].Name)
   298  	assert.NotEqual(t, s1[1].Name, s2[0].Name)
   299  	assert.NotEqual(t, s1[1].Name, s2[1].Name)
   300  
   301  	r3 := <-ss.Scheme().GetAllPage("team", 0, 1000)
   302  	assert.Nil(t, r3.Err)
   303  	s3 := r3.Data.([]*model.Scheme)
   304  	assert.NotZero(t, len(s3))
   305  	for _, s := range s3 {
   306  		assert.Equal(t, "team", s.Scope)
   307  	}
   308  
   309  	r4 := <-ss.Scheme().GetAllPage("channel", 0, 1000)
   310  	assert.Nil(t, r4.Err)
   311  	s4 := r4.Data.([]*model.Scheme)
   312  	assert.NotZero(t, len(s4))
   313  	for _, s := range s4 {
   314  		assert.Equal(t, "channel", s.Scope)
   315  	}
   316  }
   317  
   318  func testSchemeStoreDelete(t *testing.T, ss store.Store) {
   319  	// Save a new scheme.
   320  	s1 := &model.Scheme{
   321  		DisplayName: model.NewId(),
   322  		Name:        model.NewId(),
   323  		Description: model.NewId(),
   324  		Scope:       model.SCHEME_SCOPE_TEAM,
   325  	}
   326  
   327  	// Check all fields saved correctly.
   328  	res1 := <-ss.Scheme().Save(s1)
   329  	assert.Nil(t, res1.Err)
   330  	d1 := res1.Data.(*model.Scheme)
   331  	assert.Len(t, d1.Id, 26)
   332  	assert.Equal(t, s1.DisplayName, d1.DisplayName)
   333  	assert.Equal(t, s1.Name, d1.Name)
   334  	assert.Equal(t, s1.Description, d1.Description)
   335  	assert.NotZero(t, d1.CreateAt)
   336  	assert.NotZero(t, d1.UpdateAt)
   337  	assert.Zero(t, d1.DeleteAt)
   338  	assert.Equal(t, s1.Scope, d1.Scope)
   339  	assert.Len(t, d1.DefaultTeamAdminRole, 26)
   340  	assert.Len(t, d1.DefaultTeamUserRole, 26)
   341  	assert.Len(t, d1.DefaultTeamGuestRole, 26)
   342  	assert.Len(t, d1.DefaultChannelAdminRole, 26)
   343  	assert.Len(t, d1.DefaultChannelUserRole, 26)
   344  	assert.Len(t, d1.DefaultChannelGuestRole, 26)
   345  
   346  	// Check the default roles were created correctly.
   347  	role1, err := ss.Role().GetByName(d1.DefaultTeamAdminRole)
   348  	assert.Nil(t, err)
   349  	assert.Equal(t, role1.Permissions, []string{"delete_others_posts"})
   350  	assert.True(t, role1.SchemeManaged)
   351  
   352  	role2, err := ss.Role().GetByName(d1.DefaultTeamUserRole)
   353  	assert.Nil(t, err)
   354  	assert.Equal(t, role2.Permissions, []string{"view_team", "add_user_to_team"})
   355  	assert.True(t, role2.SchemeManaged)
   356  
   357  	role3, err := ss.Role().GetByName(d1.DefaultChannelAdminRole)
   358  	assert.Nil(t, err)
   359  	assert.Equal(t, role3.Permissions, []string{"manage_public_channel_members", "manage_private_channel_members"})
   360  	assert.True(t, role3.SchemeManaged)
   361  
   362  	role4, err := ss.Role().GetByName(d1.DefaultChannelUserRole)
   363  	assert.Nil(t, err)
   364  	assert.Equal(t, role4.Permissions, []string{"read_channel", "create_post"})
   365  	assert.True(t, role4.SchemeManaged)
   366  
   367  	role5, err := ss.Role().GetByName(d1.DefaultTeamGuestRole)
   368  	assert.Nil(t, err)
   369  	assert.Equal(t, role5.Permissions, []string{"view_team"})
   370  	assert.True(t, role5.SchemeManaged)
   371  
   372  	role6, err := ss.Role().GetByName(d1.DefaultChannelGuestRole)
   373  	assert.Nil(t, err)
   374  	assert.Equal(t, role6.Permissions, []string{"read_channel", "create_post"})
   375  	assert.True(t, role6.SchemeManaged)
   376  
   377  	// Delete the scheme.
   378  	res2 := <-ss.Scheme().Delete(d1.Id)
   379  	if !assert.Nil(t, res2.Err) {
   380  		t.Fatal(res2.Err)
   381  	}
   382  	d2 := res2.Data.(*model.Scheme)
   383  	assert.NotZero(t, d2.DeleteAt)
   384  
   385  	// Check that the roles are deleted too.
   386  	role7, err := ss.Role().GetByName(d1.DefaultTeamAdminRole)
   387  	assert.Nil(t, err)
   388  	assert.NotZero(t, role7.DeleteAt)
   389  
   390  	role8, err := ss.Role().GetByName(d1.DefaultTeamUserRole)
   391  	assert.Nil(t, err)
   392  	assert.NotZero(t, role8.DeleteAt)
   393  
   394  	role9, err := ss.Role().GetByName(d1.DefaultChannelAdminRole)
   395  	assert.Nil(t, err)
   396  	assert.NotZero(t, role9.DeleteAt)
   397  
   398  	role10, err := ss.Role().GetByName(d1.DefaultChannelUserRole)
   399  	assert.Nil(t, err)
   400  	assert.NotZero(t, role10.DeleteAt)
   401  
   402  	role11, err := ss.Role().GetByName(d1.DefaultTeamGuestRole)
   403  	assert.Nil(t, err)
   404  	assert.NotZero(t, role11.DeleteAt)
   405  
   406  	role12, err := ss.Role().GetByName(d1.DefaultChannelGuestRole)
   407  	assert.Nil(t, err)
   408  	assert.NotZero(t, role12.DeleteAt)
   409  
   410  	// Try deleting a scheme that does not exist.
   411  	res3 := <-ss.Scheme().Delete(model.NewId())
   412  	assert.NotNil(t, res3.Err)
   413  
   414  	// Try deleting a team scheme that's in use.
   415  	s4 := &model.Scheme{
   416  		DisplayName: model.NewId(),
   417  		Name:        model.NewId(),
   418  		Description: model.NewId(),
   419  		Scope:       model.SCHEME_SCOPE_TEAM,
   420  	}
   421  	res4 := <-ss.Scheme().Save(s4)
   422  	assert.Nil(t, res4.Err)
   423  	d4 := res4.Data.(*model.Scheme)
   424  
   425  	t4 := &model.Team{
   426  		Name:        model.NewId(),
   427  		DisplayName: model.NewId(),
   428  		Email:       MakeEmail(),
   429  		Type:        model.TEAM_OPEN,
   430  		SchemeId:    &d4.Id,
   431  	}
   432  	t4, err = ss.Team().Save(t4)
   433  	require.Nil(t, err)
   434  
   435  	sres4 := <-ss.Scheme().Delete(d4.Id)
   436  	assert.Nil(t, sres4.Err)
   437  
   438  	t5, err := ss.Team().Get(t4.Id)
   439  	require.Nil(t, err)
   440  	assert.Equal(t, "", *t5.SchemeId)
   441  
   442  	// Try deleting a channel scheme that's in use.
   443  	s5 := &model.Scheme{
   444  		DisplayName: model.NewId(),
   445  		Name:        model.NewId(),
   446  		Description: model.NewId(),
   447  		Scope:       model.SCHEME_SCOPE_CHANNEL,
   448  	}
   449  	res5 := <-ss.Scheme().Save(s5)
   450  	assert.Nil(t, res5.Err)
   451  	d5 := res5.Data.(*model.Scheme)
   452  
   453  	c5 := &model.Channel{
   454  		TeamId:      model.NewId(),
   455  		DisplayName: model.NewId(),
   456  		Name:        model.NewId(),
   457  		Type:        model.CHANNEL_OPEN,
   458  		SchemeId:    &d5.Id,
   459  	}
   460  	c5, err = ss.Channel().Save(c5, -1)
   461  	assert.Nil(t, err)
   462  
   463  	sres5 := <-ss.Scheme().Delete(d5.Id)
   464  	assert.Nil(t, sres5.Err)
   465  
   466  	c6, err := ss.Channel().Get(c5.Id, true)
   467  	assert.Nil(t, err)
   468  	assert.Equal(t, "", *c6.SchemeId)
   469  }
   470  
   471  func testSchemeStorePermanentDeleteAll(t *testing.T, ss store.Store) {
   472  	s1 := &model.Scheme{
   473  		Name:        model.NewId(),
   474  		DisplayName: model.NewId(),
   475  		Description: model.NewId(),
   476  		Scope:       model.SCHEME_SCOPE_TEAM,
   477  	}
   478  
   479  	s2 := &model.Scheme{
   480  		Name:        model.NewId(),
   481  		DisplayName: model.NewId(),
   482  		Description: model.NewId(),
   483  		Scope:       model.SCHEME_SCOPE_CHANNEL,
   484  	}
   485  
   486  	s1 = (<-ss.Scheme().Save(s1)).Data.(*model.Scheme)
   487  	s2 = (<-ss.Scheme().Save(s2)).Data.(*model.Scheme)
   488  
   489  	res := <-ss.Scheme().PermanentDeleteAll()
   490  	assert.Nil(t, res.Err)
   491  
   492  	res1 := <-ss.Scheme().Get(s1.Id)
   493  	assert.NotNil(t, res1.Err)
   494  
   495  	res2 := <-ss.Scheme().Get(s2.Id)
   496  	assert.NotNil(t, res2.Err)
   497  
   498  	res3 := <-ss.Scheme().GetAllPage("", 0, 100000)
   499  	assert.Nil(t, res3.Err)
   500  	assert.Len(t, res3.Data.([]*model.Scheme), 0)
   501  }