server
/
new-api
1
0
Разклонения 0
Код Задачи 0 Заявки за сливане 0 Версии 0 Уики Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
204 Ревизии
2 Клонове
352 MiB
 
 
 
ИН на ревизия: 3a78e9c93a
Клонове Маркери
${ item.name }
Create branch ${ searchTerm }
от '3a78e9c93a'
${ noResults }
new-api/service/user_migration/service_test.go

955 lines
27 KiB
Директен файл Blame История 

  1. package user_migration

  2. 

  3. import (

  4. 	"fmt"

  5. 	"testing"

  6. 

  7. 	"github.com/QuantumNous/new-api/common"

  8. 	"github.com/QuantumNous/new-api/model"

  9. 	"github.com/glebarez/sqlite"

  10. 	"github.com/stretchr/testify/require"

  11. 	"gorm.io/gorm"

  12. )

  13. 

  14. type fakeClient struct {

  15. 	listPages     map[int][]RemoteUserSnapshot

  16. 	getUserResp   *RemoteUserSnapshot

  17. 	getUserByID   map[int]*RemoteUserSnapshot

  18. 	hasCopyResult bool

  19. 	hasCopyByID   map[int]bool

  20. 	convertCalls  []int

  21. 	convertReqs   map[int]*ConvertRemoteUserRequest

  22. }

  23. 

  24. func (f *fakeClient) ListUsers(page, pageSize int) (*ListRemoteUsersResponse, error) {

  25. 	users := f.listPages[page]

  26. 	return &ListRemoteUsersResponse{

  27. 		Success: true,

  28. 		Data:    users,

  29. 		Total:   len(users),

  30. 	}, nil

  31. }

  32. 

  33. func (f *fakeClient) GetUser(userId int) (*RemoteUserSnapshot, error) {

  34. 	if snapshot, ok := f.getUserByID[userId]; ok {

  35. 		return snapshot, nil

  36. 	}

  37. 	if f.getUserResp != nil {

  38. 		return f.getUserResp, nil

  39. 	}

  40. 	return nil, fmt.Errorf("user %d not found", userId)

  41. }

  42. 

  43. func (f *fakeClient) ConvertToSynced(userId int, req *ConvertRemoteUserRequest) error {

  44. 	f.convertCalls = append(f.convertCalls, userId)

  45. 	if f.convertReqs == nil {

  46. 		f.convertReqs = make(map[int]*ConvertRemoteUserRequest)

  47. 	}

  48. 	if req != nil {

  49. 		copyReq := *req

  50. 		f.convertReqs[userId] = &copyReq

  51. 		if snapshot, ok := f.getUserByID[userId]; ok && snapshot != nil {

  52. 			snapshot.Source = common.UserSourceSynced

  53. 			snapshot.RemoteUserId = req.RemoteUserId

  54. 			snapshot.SyncedQuota = req.SyncedQuota

  55. 		}

  56. 		if f.getUserResp != nil && f.getUserResp.Id == userId {

  57. 			f.getUserResp.Source = common.UserSourceSynced

  58. 			f.getUserResp.RemoteUserId = req.RemoteUserId

  59. 			f.getUserResp.SyncedQuota = req.SyncedQuota

  60. 		}

  61. 	}

  62. 	return nil

  63. }

  64. 

  65. func (f *fakeClient) HasSyncedCopy(cnUserId int) (bool, error) {

  66. 	if value, ok := f.hasCopyByID[cnUserId]; ok {

  67. 		return value, nil

  68. 	}

  69. 	return f.hasCopyResult, nil

  70. }

  71. 

  72. func setupMigrationServiceDB(t *testing.T) *gorm.DB {

  73. 	t.Helper()

  74. 

  75. 	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})

  76. 	require.NoError(t, err)

  77. 

  78. 	sqlDB, err := db.DB()

  79. 	require.NoError(t, err)

  80. 	sqlDB.SetMaxOpenConns(1)

  81. 

  82. 	require.NoError(t, db.AutoMigrate(

  83. 		&model.User{},

  84. 		&model.CustomOAuthProvider{},

  85. 		&model.UserOAuthBinding{},

  86. 		&model.UserMigrationBatch{},

  87. 		&model.UserMigrationItem{},

  88. 		&model.MigrationQuotaGrant{},

  89. 	))

  90. 

  91. 	return db

  92. }

  93. 

  94. func TestScanBatch_NoConflict_MarksReady(t *testing.T) {

  95. 	db := setupMigrationServiceDB(t)

  96. 	orig := model.DB

  97. 	model.DB = db

  98. 	defer func() {

  99. 		model.DB = orig

  100. 	}()

  101. 

  102. 	batch := &model.UserMigrationBatch{Name: "wave-1", SourceRegion: "ov", TargetRegion: "cn", OperatorId: 1}

  103. 	require.NoError(t, model.CreateUserMigrationBatch(batch))

  104. 

  105. 	client := &fakeClient{

  106. 		listPages: map[int][]RemoteUserSnapshot{

  107. 			0: {{

  108. 				Id:       10000001,

  109. 				Username: "ov-bob",

  110. 				Email:    "bob@example.com",

  111. 				Quota:    456,

  112. 				AffCode:  "A002",

  113. 			}},

  114. 		},

  115. 	}

  116. 	svc := &Service{client: client}

  117. 	require.NoError(t, svc.ScanBatch(batch.Id))

  118. 

  119. 	items, err := model.ListUserMigrationItemsByBatch(batch.Id)

  120. 	require.NoError(t, err)

  121. 	require.Len(t, items, 1)

  122. 	require.Equal(t, model.UserMigrationStrategyCreateNew, items[0].ResolutionStrategy)

  123. 	require.Equal(t, model.UserMigrationItemStatusReady, items[0].Status)

  124. 

  125. 	var savedBatch model.UserMigrationBatch

  126. 	require.NoError(t, db.First(&savedBatch, batch.Id).Error)

  127. 	require.Equal(t, model.UserMigrationBatchStatusReady, savedBatch.Status)

  128. }

  129. 

  130. func TestScanBatch_EmailConflict_NoCNSyncedCopy_RecommendsMerge(t *testing.T) {

  131. 	db := setupMigrationServiceDB(t)

  132. 	orig := model.DB

  133. 	model.DB = db

  134. 	defer func() {

  135. 		model.DB = orig

  136. 	}()

  137. 

  138. 	require.NoError(t, db.Create(&model.User{

  139. 		Id:       1,

  140. 		Username: "cn-alice",

  141. 		Password: "hash",

  142. 		Email:    "alice@example.com",

  143. 		AffCode:  "C001",

  144. 	}).Error)

  145. 

  146. 	batch := &model.UserMigrationBatch{Name: "wave-2", SourceRegion: "ov", TargetRegion: "cn", OperatorId: 1}

  147. 	require.NoError(t, model.CreateUserMigrationBatch(batch))

  148. 

  149. 	client := &fakeClient{

  150. 		listPages: map[int][]RemoteUserSnapshot{

  151. 			0: {{

  152. 				Id:       10000001,

  153. 				Username: "ov-alice",

  154. 				Email:    "alice@example.com",

  155. 				Quota:    123,

  156. 				AffCode:  "A001",

  157. 			}},

  158. 		},

  159. 		hasCopyResult: false,

  160. 	}

  161. 	svc := &Service{client: client}

  162. 	require.NoError(t, svc.ScanBatch(batch.Id))

  163. 

  164. 	items, err := model.ListUserMigrationItemsByBatch(batch.Id)

  165. 	require.NoError(t, err)

  166. 	require.Len(t, items, 1)

  167. 	require.Equal(t, model.UserMigrationStrategyMergeExisting, items[0].ResolutionStrategy)

  168. 	require.Equal(t, model.UserMigrationItemStatusReady, items[0].Status)

  169. 	require.Equal(t, 1, items[0].TargetUserId)

  170. }

  171. 

  172. func TestScanBatch_EmailConflict_CNHasSyncedCopy_MarksHardConflict(t *testing.T) {

  173. 	db := setupMigrationServiceDB(t)

  174. 	orig := model.DB

  175. 	model.DB = db

  176. 	defer func() {

  177. 		model.DB = orig

  178. 	}()

  179. 

  180. 	require.NoError(t, db.Create(&model.User{

  181. 		Id:       456,

  182. 		Username: "cn-user456",

  183. 		Password: "hash",

  184. 		Email:    "shared@example.com",

  185. 		AffCode:  "C456",

  186. 	}).Error)

  187. 

  188. 	batch := &model.UserMigrationBatch{Name: "wave-3", SourceRegion: "ov", TargetRegion: "cn", OperatorId: 1}

  189. 	require.NoError(t, model.CreateUserMigrationBatch(batch))

  190. 

  191. 	client := &fakeClient{

  192. 		listPages: map[int][]RemoteUserSnapshot{

  193. 			0: {{

  194. 				Id:       10000003,

  195. 				Username: "ov-x",

  196. 				Email:    "shared@example.com",

  197. 				Quota:    50,

  198. 				AffCode:  "OVX",

  199. 			}},

  200. 		},

  201. 		hasCopyResult: true,

  202. 	}

  203. 	svc := &Service{client: client}

  204. 	require.NoError(t, svc.ScanBatch(batch.Id))

  205. 

  206. 	items, err := model.ListUserMigrationItemsByBatch(batch.Id)

  207. 	require.NoError(t, err)

  208. 	require.Len(t, items, 1)

  209. 	require.Equal(t, model.UserMigrationItemStatusConflict, items[0].Status)

  210. 	require.Contains(t, items[0].ConflictFlags, "cn_already_synced_to_ov")

  211. }

  212. 

  213. func TestScanBatch_Paginated(t *testing.T) {

  214. 	db := setupMigrationServiceDB(t)

  215. 	orig := model.DB

  216. 	model.DB = db

  217. 	defer func() {

  218. 		model.DB = orig

  219. 	}()

  220. 

  221. 	batch := &model.UserMigrationBatch{Name: "wave-big", SourceRegion: "ov", TargetRegion: "cn", OperatorId: 1}

  222. 	require.NoError(t, model.CreateUserMigrationBatch(batch))

  223. 

  224. 	page0 := make([]RemoteUserSnapshot, scanPageSize)

  225. 	for i := range page0 {

  226. 		page0[i] = RemoteUserSnapshot{

  227. 			Id:       10000001 + i,

  228. 			Username: fmt.Sprintf("u%d", i),

  229. 			AffCode:  fmt.Sprintf("A%d", i),

  230. 		}

  231. 	}

  232. 	page1 := []RemoteUserSnapshot{{

  233. 		Id:       10000001 + scanPageSize,

  234. 		Username: "last",

  235. 		AffCode:  "LAST",

  236. 	}}

  237. 

  238. 	client := &fakeClient{

  239. 		listPages: map[int][]RemoteUserSnapshot{

  240. 			0: page0,

  241. 			1: page1,

  242. 		},

  243. 	}

  244. 	svc := &Service{client: client}

  245. 	require.NoError(t, svc.ScanBatch(batch.Id))

  246. 

  247. 	items, err := model.ListUserMigrationItemsByBatch(batch.Id)

  248. 	require.NoError(t, err)

  249. 	require.Len(t, items, scanPageSize+1)

  250. }

  251. 

  252. func TestScanBatch_Rescan_PreservesHumanStrategy(t *testing.T) {

  253. 	db := setupMigrationServiceDB(t)

  254. 	orig := model.DB

  255. 	model.DB = db

  256. 	defer func() {

  257. 		model.DB = orig

  258. 	}()

  259. 

  260. 	batch := &model.UserMigrationBatch{Name: "wave-rescan", SourceRegion: "ov", TargetRegion: "cn", OperatorId: 1}

  261. 	require.NoError(t, model.CreateUserMigrationBatch(batch))

  262. 

  263. 	client := &fakeClient{

  264. 		listPages: map[int][]RemoteUserSnapshot{

  265. 			0: {{

  266. 				Id:       10000001,

  267. 				Username: "ov-dave",

  268. 				Email:    "dave@example.com",

  269. 				Quota:    100,

  270. 				AffCode:  "OVD1",

  271. 			}},

  272. 		},

  273. 		hasCopyResult: false,

  274. 	}

  275. 	svc := &Service{client: client}

  276. 	require.NoError(t, svc.ScanBatch(batch.Id))

  277. 

  278. 	require.NoError(t, db.Model(&model.UserMigrationItem{}).Where("batch_id = ?", batch.Id).

  279. 		Update("resolution_strategy", model.UserMigrationStrategySkip).Error)

  280. 

  281. 	require.NoError(t, svc.ScanBatch(batch.Id))

  282. 

  283. 	items, err := model.ListUserMigrationItemsByBatch(batch.Id)

  284. 	require.NoError(t, err)

  285. 	require.Len(t, items, 1)

  286. 	require.Equal(t, model.UserMigrationStrategySkip, items[0].ResolutionStrategy)

  287. }

  288. 

  289. func TestMigrationFlow_GrayScenarios_EndToEnd(t *testing.T) {

  290. 	db := setupMigrationServiceDB(t)

  291. 	orig := model.DB

  292. 	model.DB = db

  293. 	defer func() {

  294. 		model.DB = orig

  295. 	}()

  296. 

  297. 	require.NoError(t, db.Create(&model.User{

  298. 		Id:       1,

  299. 		Username: "cn-merge",

  300. 		Password: "hash",

  301. 		Email:    "merge@example.com",

  302. 		AffCode:  "CNM1",

  303. 		Quota:    500,

  304. 	}).Error)

  305. 	require.NoError(t, db.Create(&model.User{

  306. 		Id:       2,

  307. 		Username: "taken-name",

  308. 		Password: "hash",

  309. 		Email:    "taken@example.com",

  310. 		AffCode:  "CNT2",

  311. 		Quota:    50,

  312. 	}).Error)

  313. 	require.NoError(t, db.Create(&model.User{

  314. 		Id:       3,

  315. 		Username: "cn-hard",

  316. 		Password: "hash",

  317. 		Email:    "synced@example.com",

  318. 		AffCode:  "CNH3",

  319. 		Quota:    300,

  320. 	}).Error)

  321. 	require.NoError(t, db.Create(&model.User{

  322. 		Id:       4,

  323. 		Username: "cn-soft",

  324. 		Password: "hash",

  325. 		Email:    "soft-owner@example.com",

  326. 		AffCode:  "SOFT1",

  327. 		Quota:    80,

  328. 	}).Error)

  329. 

  330. 	batch := &model.UserMigrationBatch{

  331. 		Name:         "gray-scenarios",

  332. 		SourceRegion: "ov",

  333. 		TargetRegion: "cn",

  334. 		OperatorId:   1,

  335. 	}

  336. 	require.NoError(t, model.CreateUserMigrationBatch(batch))

  337. 

  338. 	remoteUsers := []RemoteUserSnapshot{

  339. 		{

  340. 			Id:       10000001,

  341. 			Username: "ov-create",

  342. 			Email:    "create@example.com",

  343. 			Quota:    100,

  344. 			AffCode:  "OVC1",

  345. 		},

  346. 		{

  347. 			Id:       10000002,

  348. 			Username: "ov-merge",

  349. 			Email:    "merge@example.com",

  350. 			Quota:    200,

  351. 			AffCode:  "OVM2",

  352. 		},

  353. 		{

  354. 			Id:       10000003,

  355. 			Username: "ov-hard",

  356. 			Email:    "synced@example.com",

  357. 			Quota:    300,

  358. 			AffCode:  "OVH3",

  359. 		},

  360. 		{

  361. 			Id:       10000004,

  362. 			Username: "taken-name",

  363. 			Email:    "username-conflict@example.com",

  364. 			Quota:    120,

  365. 			AffCode:  "OVU4",

  366. 		},

  367. 		{

  368. 			Id:       10000005,

  369. 			Username: "ov-soft",

  370. 			Email:    "soft@example.com",

  371. 			Quota:    150,

  372. 			AffCode:  "SOFT1",

  373. 		},

  374. 	}

  375. 

  376. 	getUserByID := make(map[int]*RemoteUserSnapshot, len(remoteUsers))

  377. 	for i := range remoteUsers {

  378. 		snapshot := remoteUsers[i]

  379. 		getUserByID[snapshot.Id] = &snapshot

  380. 	}

  381. 

  382. 	client := &fakeClient{

  383. 		listPages: map[int][]RemoteUserSnapshot{

  384. 			0: remoteUsers,

  385. 		},

  386. 		getUserByID: getUserByID,

  387. 		hasCopyByID: map[int]bool{

  388. 			1: false,

  389. 			3: true,

  390. 		},

  391. 	}

  392. 	svc := &Service{client: client}

  393. 

  394. 	require.NoError(t, svc.ScanBatch(batch.Id))

  395. 

  396. 	items, err := model.ListUserMigrationItemsByBatch(batch.Id)

  397. 	require.NoError(t, err)

  398. 	require.Len(t, items, 5)

  399. 

  400. 	bySourceUserID := make(map[int]*model.UserMigrationItem, len(items))

  401. 	for _, item := range items {

  402. 		bySourceUserID[item.SourceUserId] = item

  403. 	}

  404. 

  405. 	require.Equal(t, model.UserMigrationStrategyCreateNew, bySourceUserID[10000001].ResolutionStrategy)

  406. 	require.Equal(t, model.UserMigrationItemStatusReady, bySourceUserID[10000001].Status)

  407. 

  408. 	require.Equal(t, model.UserMigrationStrategyMergeExisting, bySourceUserID[10000002].ResolutionStrategy)

  409. 	require.Equal(t, 1, bySourceUserID[10000002].TargetUserId)

  410. 	require.Equal(t, model.UserMigrationItemStatusReady, bySourceUserID[10000002].Status)

  411. 

  412. 	require.Equal(t, model.UserMigrationItemStatusConflict, bySourceUserID[10000003].Status)

  413. 	require.Contains(t, bySourceUserID[10000003].ConflictFlags, "cn_already_synced_to_ov")

  414. 

  415. 	require.Equal(t, model.UserMigrationItemStatusConflict, bySourceUserID[10000004].Status)

  416. 	require.Contains(t, bySourceUserID[10000004].ConflictFlags, "username")

  417. 

  418. 	require.Equal(t, model.UserMigrationStrategyCreateNew, bySourceUserID[10000005].ResolutionStrategy)

  419. 	require.Equal(t, model.UserMigrationItemStatusReady, bySourceUserID[10000005].Status)

  420. 	require.Contains(t, bySourceUserID[10000005].ConflictFlags, "aff_code")

  421. 

  422. 	require.NoError(t, db.Model(&model.UserMigrationItem{}).

  423. 		Where("id IN ?", []int{bySourceUserID[10000003].Id, bySourceUserID[10000004].Id}).

  424. 		Updates(map[string]any{

  425. 			"resolution_strategy": model.UserMigrationStrategySkip,

  426. 			"status":              model.UserMigrationItemStatusReady,

  427. 			"error_message":       "",

  428. 		}).Error)

  429. 	require.NoError(t, model.RefreshUserMigrationBatchStats(batch.Id))

  430. 

  431. 	var readyBatch model.UserMigrationBatch

  432. 	require.NoError(t, db.First(&readyBatch, batch.Id).Error)

  433. 	require.Equal(t, model.UserMigrationBatchStatusReady, readyBatch.Status)

  434. 

  435. 	locked, err := model.TryLockBatchForExecution(batch.Id)

  436. 	require.NoError(t, err)

  437. 	require.True(t, locked)

  438. 	require.NoError(t, svc.ExecuteBatch(batch.Id))

  439. 

  440. 	items, err = model.ListUserMigrationItemsByBatch(batch.Id)

  441. 	require.NoError(t, err)

  442. 	bySourceUserID = make(map[int]*model.UserMigrationItem, len(items))

  443. 	for _, item := range items {

  444. 		bySourceUserID[item.SourceUserId] = item

  445. 	}

  446. 

  447. 	require.Equal(t, model.UserMigrationItemStatusMigrated, bySourceUserID[10000001].Status)

  448. 	require.Equal(t, model.UserMigrationItemStatusMigrated, bySourceUserID[10000002].Status)

  449. 	require.Equal(t, model.UserMigrationItemStatusSkipped, bySourceUserID[10000003].Status)

  450. 	require.Equal(t, model.UserMigrationItemStatusSkipped, bySourceUserID[10000004].Status)

  451. 	require.Equal(t, model.UserMigrationItemStatusMigrated, bySourceUserID[10000005].Status)

  452. 

  453. 	var createdUser model.User

  454. 	require.NoError(t, db.Where("username = ?", "ov-create").First(&createdUser).Error)

  455. 	require.Equal(t, 100, createdUser.Quota)

  456. 

  457. 	var mergedUser model.User

  458. 	require.NoError(t, db.First(&mergedUser, 1).Error)

  459. 	require.Equal(t, 700, mergedUser.Quota)

  460. 

  461. 	var softUser model.User

  462. 	require.NoError(t, db.Where("username = ?", "ov-soft").First(&softUser).Error)

  463. 	require.Equal(t, 150, softUser.Quota)

  464. 	require.NotEqual(t, "SOFT1", softUser.AffCode)

  465. 

  466. 	require.Equal(t, common.UserSourceSynced, client.getUserByID[10000001].Source)

  467. 	require.Equal(t, createdUser.Id, client.getUserByID[10000001].RemoteUserId)

  468. 	require.Equal(t, 100, client.getUserByID[10000001].SyncedQuota)

  469. 

  470. 	require.Equal(t, common.UserSourceSynced, client.getUserByID[10000002].Source)

  471. 	require.Equal(t, 1, client.getUserByID[10000002].RemoteUserId)

  472. 	require.Equal(t, 700, client.getUserByID[10000002].SyncedQuota)

  473. 

  474. 	require.NotEqual(t, common.UserSourceSynced, client.getUserByID[10000003].Source)

  475. 	require.NotEqual(t, common.UserSourceSynced, client.getUserByID[10000004].Source)

  476. 

  477. 	require.Equal(t, common.UserSourceSynced, client.getUserByID[10000005].Source)

  478. 	require.Equal(t, softUser.Id, client.getUserByID[10000005].RemoteUserId)

  479. 	require.Equal(t, 150, client.getUserByID[10000005].SyncedQuota)

  480. 

  481. 	for _, sourceUserID := range []int{10000001, 10000002, 10000005} {

  482. 		result, verifyErr := svc.VerifyItem(bySourceUserID[sourceUserID])

  483. 		require.NoError(t, verifyErr)

  484. 		require.True(t, result.TargetUserExists)

  485. 		require.True(t, result.RemoteConverted)

  486. 		require.True(t, result.QuotaMatched)

  487. 	}

  488. 

  489. 	require.NoError(t, db.Model(&model.UserMigrationBatch{}).Where("id = ?", batch.Id).

  490. 		Update("status", model.UserMigrationBatchStatusReady).Error)

  491. 	require.NoError(t, db.Model(&model.UserMigrationItem{}).

  492. 		Where("id IN ?", []int{

  493. 			bySourceUserID[10000001].Id,

  494. 			bySourceUserID[10000002].Id,

  495. 			bySourceUserID[10000005].Id,

  496. 		}).

  497. 		Update("status", model.UserMigrationItemStatusReady).Error)

  498. 

  499. 	locked, err = model.TryLockBatchForExecution(batch.Id)

  500. 	require.NoError(t, err)

  501. 	require.True(t, locked)

  502. 	require.NoError(t, svc.ExecuteBatch(batch.Id))

  503. 

  504. 	require.Len(t, client.convertCalls, 3)

  505. 

  506. 	require.NoError(t, db.First(&mergedUser, 1).Error)

  507. 	require.Equal(t, 700, mergedUser.Quota)

  508. }

  509. 

  510. func TestExecuteBatch_CreateNew_CreatesUserAndConvertsRemote(t *testing.T) {

  511. 	db := setupMigrationServiceDB(t)

  512. 	orig := model.DB

  513. 	model.DB = db

  514. 	defer func() {

  515. 		model.DB = orig

  516. 	}()

  517. 

  518. 	batch := &model.UserMigrationBatch{

  519. 		Name:   "wave-exec",

  520. 		Status: model.UserMigrationBatchStatusReady,

  521. 	}

  522. 	batch.SourceRegion = "ov"

  523. 	batch.TargetRegion = "cn"

  524. 	batch.OperatorId = 1

  525. 	require.NoError(t, model.CreateUserMigrationBatch(batch))

  526. 

  527. 	item := &model.UserMigrationItem{

  528. 		BatchId:            batch.Id,

  529. 		SourceUserId:       10000001,

  530. 		SourceUsername:     "ov-alice",

  531. 		SourceEmail:        "alice@example.com",

  532. 		SourceQuota:        300,

  533. 		ResolutionStrategy: model.UserMigrationStrategyCreateNew,

  534. 		Status:             model.UserMigrationItemStatusReady,

  535. 		MigrationToken:     "batch-1-user-10000001",

  536. 	}

  537. 	require.NoError(t, model.UpsertUserMigrationItem(item))

  538. 

  539. 	client := &fakeClient{

  540. 		getUserResp: &RemoteUserSnapshot{

  541. 			Id:          10000001,

  542. 			Username:    "ov-alice",

  543. 			Password:    "hashed-password",

  544. 			Email:       "alice@example.com",

  545. 			DisplayName: "Alice",

  546. 			Status:      1,

  547. 			Role:        1,

  548. 			Group:       "default",

  549. 			Quota:       300,

  550. 			AffCode:     "OVA1",

  551. 		},

  552. 	}

  553. 	svc := &Service{client: client}

  554. 

  555. 	locked, err := model.TryLockBatchForExecution(batch.Id)

  556. 	require.NoError(t, err)

  557. 	require.True(t, locked)

  558. 	require.NoError(t, svc.ExecuteBatch(batch.Id))

  559. 

  560. 	var cnUser model.User

  561. 	require.NoError(t, db.Where("username = ?", "ov-alice").First(&cnUser).Error)

  562. 	require.Equal(t, 300, cnUser.Quota)

  563. 	require.Less(t, cnUser.Id, 10000000)

  564. 

  565. 	require.Len(t, client.convertCalls, 1)

  566. 	require.Equal(t, 10000001, client.convertCalls[0])

  567. }

  568. 

  569. func TestExecuteBatch_CreateNew_IdempotentOnRetry(t *testing.T) {

  570. 	db := setupMigrationServiceDB(t)

  571. 	orig := model.DB

  572. 	model.DB = db

  573. 	defer func() {

  574. 		model.DB = orig

  575. 	}()

  576. 

  577. 	batch := &model.UserMigrationBatch{

  578. 		Name:   "wave-retry",

  579. 		Status: model.UserMigrationBatchStatusReady,

  580. 	}

  581. 	batch.SourceRegion = "ov"

  582. 	batch.TargetRegion = "cn"

  583. 	batch.OperatorId = 1

  584. 	require.NoError(t, model.CreateUserMigrationBatch(batch))

  585. 

  586. 	item := &model.UserMigrationItem{

  587. 		BatchId:            batch.Id,

  588. 		SourceUserId:       10000002,

  589. 		SourceUsername:     "ov-carol",

  590. 		SourceEmail:        "carol@example.com",

  591. 		SourceQuota:        150,

  592. 		ResolutionStrategy: model.UserMigrationStrategyCreateNew,

  593. 		Status:             model.UserMigrationItemStatusReady,

  594. 		MigrationToken:     "batch-1-user-10000002",

  595. 	}

  596. 	require.NoError(t, model.UpsertUserMigrationItem(item))

  597. 

  598. 	snapshot := &RemoteUserSnapshot{

  599. 		Id:       10000002,

  600. 		Username: "ov-carol",

  601. 		Password: "hash",

  602. 		Email:    "carol@example.com",

  603. 		Quota:    150,

  604. 		AffCode:  "OVC1",

  605. 	}

  606. 	client := &fakeClient{getUserResp: snapshot}

  607. 	svc := &Service{client: client}

  608. 

  609. 	locked, err := model.TryLockBatchForExecution(batch.Id)

  610. 	require.NoError(t, err)

  611. 	require.True(t, locked)

  612. 	require.NoError(t, svc.ExecuteBatch(batch.Id))

  613. 

  614. 	require.NoError(t, db.Model(&model.UserMigrationBatch{}).Where("id = ?", batch.Id).

  615. 		Update("status", model.UserMigrationBatchStatusFailed).Error)

  616. 	require.NoError(t, db.Model(&model.UserMigrationItem{}).Where("batch_id = ?", batch.Id).

  617. 		Update("status", model.UserMigrationItemStatusReady).Error)

  618. 

  619. 	locked, err = model.TryLockBatchForExecution(batch.Id)

  620. 	require.NoError(t, err)

  621. 	require.True(t, locked)

  622. 	require.NoError(t, svc.ExecuteBatch(batch.Id))

  623. 

  624. 	var count int64

  625. 	require.NoError(t, db.Model(&model.User{}).Where("username = ?", "ov-carol").Count(&count).Error)

  626. 	require.EqualValues(t, 1, count)

  627. 	require.Len(t, client.convertCalls, 1)

  628. }

  629. 

  630. func TestExecuteBatch_CreateNew_ExecutionTimeDriftFails(t *testing.T) {

  631. 	db := setupMigrationServiceDB(t)

  632. 	orig := model.DB

  633. 	model.DB = db

  634. 	defer func() {

  635. 		model.DB = orig

  636. 	}()

  637. 

  638. 	require.NoError(t, db.Create(&model.User{

  639. 		Id:       7,

  640. 		Username: "cn-alice",

  641. 		Password: "hash",

  642. 		Email:    "alice@example.com",

  643. 		AffCode:  "C007",

  644. 	}).Error)

  645. 

  646. 	batch := &model.UserMigrationBatch{

  647. 		Name:         "wave-create-drift",

  648. 		SourceRegion: "ov",

  649. 		TargetRegion: "cn",

  650. 		OperatorId:   1,

  651. 		Status:       model.UserMigrationBatchStatusReady,

  652. 	}

  653. 	require.NoError(t, model.CreateUserMigrationBatch(batch))

  654. 

  655. 	item := &model.UserMigrationItem{

  656. 		BatchId:            batch.Id,

  657. 		SourceUserId:       10000020,

  658. 		SourceUsername:     "ov-drift",

  659. 		SourceEmail:        "old@example.com",

  660. 		SourceQuota:        120,

  661. 		ResolutionStrategy: model.UserMigrationStrategyCreateNew,

  662. 		Status:             model.UserMigrationItemStatusReady,

  663. 		MigrationToken:     "batch-1-user-10000020",

  664. 	}

  665. 	require.NoError(t, model.UpsertUserMigrationItem(item))

  666. 

  667. 	client := &fakeClient{

  668. 		getUserResp: &RemoteUserSnapshot{

  669. 			Id:       10000020,

  670. 			Username: "ov-drift",

  671. 			Password: "hash",

  672. 			Email:    "alice@example.com",

  673. 			Quota:    120,

  674. 			AffCode:  "OV20",

  675. 		},

  676. 		hasCopyByID: map[int]bool{7: false},

  677. 	}

  678. 	svc := &Service{client: client}

  679. 

  680. 	locked, err := model.TryLockBatchForExecution(batch.Id)

  681. 	require.NoError(t, err)

  682. 	require.True(t, locked)

  683. 	require.NoError(t, svc.ExecuteBatch(batch.Id))

  684. 

  685. 	require.Len(t, client.convertCalls, 0)

  686. 

  687. 	var count int64

  688. 	require.NoError(t, db.Model(&model.User{}).Where("username = ?", "ov-drift").Count(&count).Error)

  689. 	require.EqualValues(t, 0, count)

  690. 

  691. 	items, err := model.ListUserMigrationItemsByBatch(batch.Id)

  692. 	require.NoError(t, err)

  693. 	require.Len(t, items, 1)

  694. 	require.Equal(t, model.UserMigrationItemStatusFailed, items[0].Status)

  695. 	require.Contains(t, items[0].ErrorMessage, "identity drift")

  696. }

  697. 

  698. func TestExecuteBatch_MergeExisting_IdempotentQuota(t *testing.T) {

  699. 	db := setupMigrationServiceDB(t)

  700. 	orig := model.DB

  701. 	model.DB = db

  702. 	defer func() {

  703. 		model.DB = orig

  704. 	}()

  705. 

  706. 	require.NoError(t, db.Create(&model.User{

  707. 		Id:       1,

  708. 		Username: "cn-bob",

  709. 		Password: "hash",

  710. 		Email:    "bob@example.com",

  711. 		AffCode:  "CNB1",

  712. 		Quota:    500,

  713. 	}).Error)

  714. 

  715. 	batch := &model.UserMigrationBatch{

  716. 		Name:   "wave-merge",

  717. 		Status: model.UserMigrationBatchStatusReady,

  718. 	}

  719. 	batch.SourceRegion = "ov"

  720. 	batch.TargetRegion = "cn"

  721. 	batch.OperatorId = 1

  722. 	require.NoError(t, model.CreateUserMigrationBatch(batch))

  723. 

  724. 	item := &model.UserMigrationItem{

  725. 		BatchId:            batch.Id,

  726. 		SourceUserId:       10000002,

  727. 		TargetUserId:       1,

  728. 		SourceUsername:     "ov-bob",

  729. 		SourceEmail:        "bob@example.com",

  730. 		SourceQuota:        200,

  731. 		ResolutionStrategy: model.UserMigrationStrategyMergeExisting,

  732. 		Status:             model.UserMigrationItemStatusReady,

  733. 		MigrationToken:     "batch-1-user-10000002",

  734. 	}

  735. 	require.NoError(t, model.UpsertUserMigrationItem(item))

  736. 

  737. 	client := &fakeClient{

  738. 		getUserResp: &RemoteUserSnapshot{

  739. 			Id:       10000002,

  740. 			Username: "ov-bob",

  741. 			Password: "hashed",

  742. 			Email:    "bob@example.com",

  743. 			Quota:    200,

  744. 		},

  745. 	}

  746. 	svc := &Service{client: client}

  747. 

  748. 	for i := 0; i < 2; i++ {

  749. 		require.NoError(t, db.Model(&model.UserMigrationBatch{}).Where("id = ?", batch.Id).

  750. 			Update("status", model.UserMigrationBatchStatusReady).Error)

  751. 		require.NoError(t, db.Model(&model.UserMigrationItem{}).Where("batch_id = ?", batch.Id).

  752. 			Update("status", model.UserMigrationItemStatusReady).Error)

  753. 

  754. 		locked, err := model.TryLockBatchForExecution(batch.Id)

  755. 		require.NoError(t, err)

  756. 		require.True(t, locked)

  757. 		require.NoError(t, svc.ExecuteBatch(batch.Id))

  758. 	}

  759. 

  760. 	var saved model.User

  761. 	require.NoError(t, db.First(&saved, 1).Error)

  762. 	require.Equal(t, 700, saved.Quota)

  763. 	require.Len(t, client.convertCalls, 1)

  764. }

  765. 

  766. func TestExecuteBatch_MergeExisting_ExecutionTimeDriftFails(t *testing.T) {

  767. 	db := setupMigrationServiceDB(t)

  768. 	orig := model.DB

  769. 	model.DB = db

  770. 	defer func() {

  771. 		model.DB = orig

  772. 	}()

  773. 

  774. 	require.NoError(t, db.Create(&model.User{

  775. 		Id:       1,

  776. 		Username: "cn-bob",

  777. 		Password: "hash",

  778. 		Email:    "bob@example.com",

  779. 		AffCode:  "CNB1",

  780. 		Quota:    500,

  781. 	}).Error)

  782. 

  783. 	batch := &model.UserMigrationBatch{

  784. 		Name:         "wave-merge-drift",

  785. 		SourceRegion: "ov",

  786. 		TargetRegion: "cn",

  787. 		OperatorId:   1,

  788. 		Status:       model.UserMigrationBatchStatusReady,

  789. 	}

  790. 	require.NoError(t, model.CreateUserMigrationBatch(batch))

  791. 

  792. 	item := &model.UserMigrationItem{

  793. 		BatchId:            batch.Id,

  794. 		SourceUserId:       10000021,

  795. 		TargetUserId:       1,

  796. 		SourceUsername:     "ov-bob",

  797. 		SourceEmail:        "bob@example.com",

  798. 		SourceQuota:        200,

  799. 		ResolutionStrategy: model.UserMigrationStrategyMergeExisting,

  800. 		Status:             model.UserMigrationItemStatusReady,

  801. 		MigrationToken:     "batch-1-user-10000021",

  802. 	}

  803. 	require.NoError(t, model.UpsertUserMigrationItem(item))

  804. 

  805. 	client := &fakeClient{

  806. 		getUserResp: &RemoteUserSnapshot{

  807. 			Id:       10000021,

  808. 			Username: "ov-bob",

  809. 			Password: "hash",

  810. 			Email:    "changed@example.com",

  811. 			Quota:    200,

  812. 			AffCode:  "OV21",

  813. 		},

  814. 	}

  815. 	svc := &Service{client: client}

  816. 

  817. 	locked, err := model.TryLockBatchForExecution(batch.Id)

  818. 	require.NoError(t, err)

  819. 	require.True(t, locked)

  820. 	require.NoError(t, svc.ExecuteBatch(batch.Id))

  821. 

  822. 	require.Len(t, client.convertCalls, 0)

  823. 

  824. 	var cnUser model.User

  825. 	require.NoError(t, db.First(&cnUser, 1).Error)

  826. 	require.Equal(t, 500, cnUser.Quota)

  827. 

  828. 	items, err := model.ListUserMigrationItemsByBatch(batch.Id)

  829. 	require.NoError(t, err)

  830. 	require.Len(t, items, 1)

  831. 	require.Equal(t, model.UserMigrationItemStatusFailed, items[0].Status)

  832. 	require.Contains(t, items[0].ErrorMessage, "merge target drift")

  833. }

  834. 

  835. func TestExecuteBatch_SkipItem_DoesNotConvert(t *testing.T) {

  836. 	db := setupMigrationServiceDB(t)

  837. 	orig := model.DB

  838. 	model.DB = db

  839. 	defer func() {

  840. 		model.DB = orig

  841. 	}()

  842. 

  843. 	batch := &model.UserMigrationBatch{

  844. 		Name:         "skip-test",

  845. 		SourceRegion: "ov",

  846. 		TargetRegion: "cn",

  847. 		OperatorId:   1,

  848. 		Status:       model.UserMigrationBatchStatusReady,

  849. 	}

  850. 	require.NoError(t, model.CreateUserMigrationBatch(batch))

  851. 	require.NoError(t, model.UpsertUserMigrationItem(&model.UserMigrationItem{

  852. 		BatchId:            batch.Id,

  853. 		SourceUserId:       10000099,

  854. 		SourceUsername:     "skip-user",

  855. 		SourceQuota:        50,

  856. 		ResolutionStrategy: model.UserMigrationStrategySkip,

  857. 		Status:             model.UserMigrationItemStatusReady,

  858. 		MigrationToken:     "batch-1-user-10000099",

  859. 	}))

  860. 

  861. 	client := &fakeClient{}

  862. 	svc := &Service{client: client}

  863. 

  864. 	locked, err := model.TryLockBatchForExecution(batch.Id)

  865. 	require.NoError(t, err)

  866. 	require.True(t, locked)

  867. 	require.NoError(t, svc.ExecuteBatch(batch.Id))

  868. 

  869. 	require.Len(t, client.convertCalls, 0)

  870. 	items, err := model.ListUserMigrationItemsByBatch(batch.Id)

  871. 	require.NoError(t, err)

  872. 	require.Len(t, items, 1)

  873. 	require.Equal(t, model.UserMigrationItemStatusSkipped, items[0].Status)

  874. }

  875. 

  876. func TestVerifyItem_CorrectlyChecksRemoteConverted(t *testing.T) {

  877. 	db := setupMigrationServiceDB(t)

  878. 	orig := model.DB

  879. 	model.DB = db

  880. 	defer func() {

  881. 		model.DB = orig

  882. 	}()

  883. 

  884. 	require.NoError(t, db.Create(&model.User{

  885. 		Id:       789,

  886. 		Username: "cn-migrated",

  887. 		Password: "hash",

  888. 		AffCode:  "CM1",

  889. 		Quota:    300,

  890. 	}).Error)

  891. 

  892. 	item := &model.UserMigrationItem{

  893. 		BatchId:      1,

  894. 		SourceUserId: 10000001,

  895. 		TargetUserId: 789,

  896. 		SourceQuota:  300,

  897. 		Status:       model.UserMigrationItemStatusMigrated,

  898. 	}

  899. 

  900. 	client := &fakeClient{

  901. 		getUserResp: &RemoteUserSnapshot{

  902. 			Id:           10000001,

  903. 			Source:       common.UserSourceSynced,

  904. 			RemoteUserId: 789,

  905. 			SyncedQuota:  300,

  906. 		},

  907. 	}

  908. 	svc := &Service{client: client}

  909. 	result, err := svc.VerifyItem(item)

  910. 	require.NoError(t, err)

  911. 	require.True(t, result.TargetUserExists)

  912. 	require.True(t, result.RemoteConverted)

  913. 	require.True(t, result.QuotaMatched)

  914. }

  915. 

  916. func TestVerifyItem_QuotaMismatchDetected(t *testing.T) {

  917. 	db := setupMigrationServiceDB(t)

  918. 	orig := model.DB

  919. 	model.DB = db

  920. 	defer func() {

  921. 		model.DB = orig

  922. 	}()

  923. 

  924. 	require.NoError(t, db.Create(&model.User{

  925. 		Id:       790,

  926. 		Username: "cn-mismatch",

  927. 		Password: "hash",

  928. 		AffCode:  "CM2",

  929. 		Quota:    300,

  930. 	}).Error)

  931. 

  932. 	item := &model.UserMigrationItem{

  933. 		BatchId:      1,

  934. 		SourceUserId: 10000002,

  935. 		TargetUserId: 790,

  936. 		SourceQuota:  300,

  937. 		Status:       model.UserMigrationItemStatusMigrated,

  938. 	}

  939. 

  940. 	client := &fakeClient{

  941. 		getUserResp: &RemoteUserSnapshot{

  942. 			Id:           10000002,

  943. 			Source:       common.UserSourceSynced,

  944. 			RemoteUserId: 790,

  945. 			SyncedQuota:  250,

  946. 		},

  947. 	}

  948. 	svc := &Service{client: client}

  949. 	result, err := svc.VerifyItem(item)

  950. 	require.NoError(t, err)

  951. 	require.True(t, result.TargetUserExists)

  952. 	require.True(t, result.RemoteConverted)

  953. 	require.False(t, result.QuotaMatched)

  954. }