Mirrors/nc-photos
1
0
Fork 0
mirror of https://gitlab.com/nkming2/nc-photos.git synced 2025-03-22 06:59:21 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update test cases

Browse source
This commit is contained in:
Ming Ming 2021-11-23 15:39:35 +08:00
parent ef704c64c2
commit 179ad24419
8 changed files with 430 additions and 763 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

103
test/bloc/list_album_share_outlier_test.dart
View file

@ -1,11 +1,6 @@
import 'package:bloc_test/bloc_test.dart'; import 'package:bloc_test/bloc_test.dart';
import 'package:nc_photos/bloc/list_album_share_outlier.dart'; import 'package:nc_photos/bloc/list_album_share_outlier.dart';
import 'package:nc_photos/ci_string.dart'; import 'package:nc_photos/ci_string.dart';
import 'package:nc_photos/entity/album.dart';
import 'package:nc_photos/entity/album/cover_provider.dart';
import 'package:nc_photos/entity/album/item.dart';
import 'package:nc_photos/entity/album/provider.dart';
import 'package:nc_photos/entity/album/sort_provider.dart';
import 'package:test/test.dart'; import 'package:test/test.dart';
import '../mock_type.dart'; import '../mock_type.dart';
@ -40,31 +35,11 @@ void _initialState() {
/// Expect: emit the file with extra share (admin -> user1) /// Expect: emit the file with extra share (admin -> user1)
void _testQueryUnsharedAlbumExtraFileShare() { void _testQueryUnsharedAlbumExtraFileShare() {
final account = test_util.buildAccount(); final account = test_util.buildAccount();
final albumFile = test_util.buildAlbumFile( final files = (test_util.FilesBuilder(initialFileId: 1)
path: test_util.buildAlbumFilePath("test1.json"), ..addJpeg("admin/test1.jpg"))
fileId: 0, .build();
); final album = (test_util.AlbumBuilder()..addFileItem(files[0])).build();
final file1 = test_util.buildJpegFile( final file1 = files[0];
path: "remote.php/dav/files/admin/test1.jpg",
fileId: 1,
lastModified: DateTime.utc(2020, 1, 2, 3, 4, 5),
);
final fileItem1 = AlbumFileItem(
file: file1,
addedBy: "admin".toCi(),
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 5),
);
final album = Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(
items: [fileItem1],
latestItemTime: file1.lastModified,
),
coverProvider: AlbumAutoCoverProvider(coverFile: file1),
sortProvider: const AlbumNullSortProvider(),
albumFile: albumFile,
);
final shareRepo = MockShareMemoryRepo([ final shareRepo = MockShareMemoryRepo([
test_util.buildShare(id: "0", file: file1, shareWith: "user1"), test_util.buildShare(id: "0", file: file1, shareWith: "user1"),
]); ]);
@ -94,18 +69,8 @@ void _testQueryUnsharedAlbumExtraFileShare() {
/// Expect: emit the json file with extra share (admin -> user1) /// Expect: emit the json file with extra share (admin -> user1)
void _testQueryUnsharedAlbumExtraJsonShare() { void _testQueryUnsharedAlbumExtraJsonShare() {
final account = test_util.buildAccount(); final account = test_util.buildAccount();
final albumFile = test_util.buildAlbumFile( final album = test_util.AlbumBuilder().build();
path: test_util.buildAlbumFilePath("test1.json"), final albumFile = album.albumFile!;
fileId: 0,
);
final album = Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(items: []),
coverProvider: AlbumAutoCoverProvider(),
sortProvider: const AlbumNullSortProvider(),
albumFile: albumFile,
);
final shareRepo = MockShareMemoryRepo([ final shareRepo = MockShareMemoryRepo([
test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"), test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"),
]); ]);
@ -134,32 +99,15 @@ void _testQueryUnsharedAlbumExtraJsonShare() {
/// Expect: emit the file with missing share (admin -> user1) /// Expect: emit the file with missing share (admin -> user1)
void _testQuerySharedAlbumMissingFileShare() { void _testQuerySharedAlbumMissingFileShare() {
final account = test_util.buildAccount(); final account = test_util.buildAccount();
final albumFile = test_util.buildAlbumFile( final files = (test_util.FilesBuilder(initialFileId: 1)
path: test_util.buildAlbumFilePath("test1.json"), ..addJpeg("admin/test1.jpg"))
fileId: 0, .build();
); final album = (test_util.AlbumBuilder()
final file1 = test_util.buildJpegFile( ..addFileItem(files[0])
path: "remote.php/dav/files/admin/test1.jpg", ..addShare("user1"))
fileId: 1, .build();
lastModified: DateTime.utc(2020, 1, 2, 3, 4, 5), final file1 = files[0];
); final albumFile = album.albumFile!;
final fileItem1 = AlbumFileItem(
file: file1,
addedBy: "admin".toCi(),
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 5),
);
final album = Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(
items: [fileItem1],
latestItemTime: file1.lastModified,
),
coverProvider: AlbumAutoCoverProvider(coverFile: file1),
sortProvider: const AlbumNullSortProvider(),
shares: [AlbumShare(userId: "user1".toCi())],
albumFile: albumFile,
);
final shareRepo = MockShareMemoryRepo([ final shareRepo = MockShareMemoryRepo([
test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"), test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"),
]); ]);
@ -175,7 +123,7 @@ void _testQuerySharedAlbumMissingFileShare() {
ListAlbumShareOutlierBlocLoading(account, []), ListAlbumShareOutlierBlocLoading(account, []),
ListAlbumShareOutlierBlocSuccess(account, [ ListAlbumShareOutlierBlocSuccess(account, [
ListAlbumShareOutlierItem(file1, [ ListAlbumShareOutlierItem(file1, [
ListAlbumShareOutlierMissingShareItem("user1".toCi(), null), ListAlbumShareOutlierMissingShareItem("user1".toCi(), "user1"),
]), ]),
]), ]),
], ],
@ -187,19 +135,8 @@ void _testQuerySharedAlbumMissingFileShare() {
/// Expect: emit the file with missing share (admin -> user1) /// Expect: emit the file with missing share (admin -> user1)
void _testQuerySharedAlbumMissingJsonShare() { void _testQuerySharedAlbumMissingJsonShare() {
final account = test_util.buildAccount(); final account = test_util.buildAccount();
final albumFile = test_util.buildAlbumFile( final album = (test_util.AlbumBuilder()..addShare("user1")).build();
path: test_util.buildAlbumFilePath("test1.json"), final albumFile = album.albumFile!;
fileId: 0,
);
final album = Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(items: []),
coverProvider: AlbumAutoCoverProvider(),
sortProvider: const AlbumNullSortProvider(),
shares: [AlbumShare(userId: "user1".toCi())],
albumFile: albumFile,
);
final shareRepo = MockShareMemoryRepo(); final shareRepo = MockShareMemoryRepo();
final shareeRepo = MockShareeMemoryRepo([ final shareeRepo = MockShareeMemoryRepo([
test_util.buildSharee(shareWith: "user1".toCi()), test_util.buildSharee(shareWith: "user1".toCi()),
@ -213,7 +150,7 @@ void _testQuerySharedAlbumMissingJsonShare() {
ListAlbumShareOutlierBlocLoading(account, []), ListAlbumShareOutlierBlocLoading(account, []),
ListAlbumShareOutlierBlocSuccess(account, [ ListAlbumShareOutlierBlocSuccess(account, [
ListAlbumShareOutlierItem(albumFile, [ ListAlbumShareOutlierItem(albumFile, [
ListAlbumShareOutlierMissingShareItem("user1".toCi(), null), ListAlbumShareOutlierMissingShareItem("user1".toCi(), "user1"),
]), ]),
]), ]),
], ],

13
test/entity/album_test.dart
View file

@ -1671,7 +1671,10 @@ void _fromJsonShares() {
"content": <String, dynamic>{}, "content": <String, dynamic>{},
}, },
"shares": <JsonObj>[ "shares": <JsonObj>[
{"userId": "admin"}, {
"userId": "admin",
"displayName": "admin",
},
], ],
}; };
expect( expect(
@ -1687,7 +1690,7 @@ void _fromJsonShares() {
), ),
coverProvider: AlbumAutoCoverProvider(), coverProvider: AlbumAutoCoverProvider(),
sortProvider: const AlbumNullSortProvider(), sortProvider: const AlbumNullSortProvider(),
shares: [AlbumShare(userId: "admin".toCi())], shares: [test_util.buildAlbumShare(userId: "admin")],
)); ));
} }
@ -1700,7 +1703,7 @@ void _toRemoteJsonShares() {
), ),
coverProvider: AlbumAutoCoverProvider(), coverProvider: AlbumAutoCoverProvider(),
sortProvider: const AlbumNullSortProvider(), sortProvider: const AlbumNullSortProvider(),
shares: [AlbumShare(userId: "admin".toCi())], shares: [test_util.buildAlbumShare(userId: "admin")],
); );
expect(album.toRemoteJson(), <String, dynamic>{ expect(album.toRemoteJson(), <String, dynamic>{
"version": Album.version, "version": Album.version,
@ -1723,6 +1726,7 @@ void _toRemoteJsonShares() {
"shares": [ "shares": [
<String, dynamic>{ <String, dynamic>{
"userId": "admin", "userId": "admin",
"displayName": "admin",
}, },
], ],
}); });
@ -1737,7 +1741,7 @@ void _toAppDbJsonShares() {
), ),
coverProvider: AlbumAutoCoverProvider(), coverProvider: AlbumAutoCoverProvider(),
sortProvider: const AlbumNullSortProvider(), sortProvider: const AlbumNullSortProvider(),
shares: [AlbumShare(userId: "admin".toCi())], shares: [test_util.buildAlbumShare(userId: "admin")],
); );
expect(album.toAppDbJson(), <String, dynamic>{ expect(album.toAppDbJson(), <String, dynamic>{
"version": Album.version, "version": Album.version,
@ -1760,6 +1764,7 @@ void _toAppDbJsonShares() {
"shares": [ "shares": [
<String, dynamic>{ <String, dynamic>{
"userId": "admin", "userId": "admin",
"displayName": "admin",
}, },
], ],
}); });

4
test/mock_type.dart
View file

@ -45,7 +45,7 @@ class MockAlbumRepo implements AlbumRepo {
class MockAlbumMemoryRepo extends MockAlbumRepo { class MockAlbumMemoryRepo extends MockAlbumRepo {
MockAlbumMemoryRepo([ MockAlbumMemoryRepo([
List<Album> initialData = const [], List<Album> initialData = const [],
]) : albums = List.of(initialData); ]) : albums = initialData.map((a) => a.copyWith()).toList();
@override @override
get(Account account, File albumFile) async { get(Account account, File albumFile) async {
@ -176,7 +176,7 @@ class MockFileRepo implements FileRepo {
class MockFileMemoryRepo extends MockFileRepo { class MockFileMemoryRepo extends MockFileRepo {
MockFileMemoryRepo([ MockFileMemoryRepo([
List<File> initialData = const [], List<File> initialData = const [],
]) : files = List.of(initialData) { ]) : files = initialData.map((f) => f.copyWith()).toList() {
_id = files _id = files
.where((f) => f.fileId != null) .where((f) => f.fileId != null)
.map((f) => f.fileId!) .map((f) => f.fileId!)

130
test/test_util.dart
View file

@ -2,9 +2,126 @@ import 'package:flutter/foundation.dart';
import 'package:logging/logging.dart'; import 'package:logging/logging.dart';
import 'package:nc_photos/account.dart'; import 'package:nc_photos/account.dart';
import 'package:nc_photos/ci_string.dart'; import 'package:nc_photos/ci_string.dart';
import 'package:nc_photos/entity/album.dart';
import 'package:nc_photos/entity/album/cover_provider.dart';
import 'package:nc_photos/entity/album/item.dart';
import 'package:nc_photos/entity/album/provider.dart';
import 'package:nc_photos/entity/album/sort_provider.dart';
import 'package:nc_photos/entity/file.dart'; import 'package:nc_photos/entity/file.dart';
import 'package:nc_photos/entity/share.dart'; import 'package:nc_photos/entity/share.dart';
import 'package:nc_photos/entity/sharee.dart'; import 'package:nc_photos/entity/sharee.dart';
import 'package:nc_photos/iterable_extension.dart';
class FilesBuilder {
FilesBuilder({
int initialFileId = 0,
}) : fileId = initialFileId;
List<File> build() {
return files.map((f) => f.copyWith()).toList();
}
void addJpeg(
String relativePath, {
int contentLength = 1024,
DateTime? lastModified,
bool hasPreview = true,
String ownerId = "admin",
}) {
files.add(buildJpegFile(
path: "remote.php/dav/files/$relativePath",
contentLength: contentLength,
lastModified:
lastModified ?? DateTime.utc(2020, 1, 2, 3, 4, 5 + files.length),
hasPreview: hasPreview,
fileId: fileId++,
ownerId: ownerId,
));
}
final files = <File>[];
int fileId;
}
/// Create an album for testing
class AlbumBuilder {
AlbumBuilder({
DateTime? lastUpdated,
this.name = "test",
this.albumFilename = "test1.json",
this.fileId = 0,
this.ownerId = "admin",
}) : lastUpdated = lastUpdated ?? DateTime.utc(2020, 1, 2, 3, 4, 5);
Album build() {
final latestFileItem = items
.whereType<AlbumFileItem>()
.stableSorted(
(a, b) => a.file.lastModified!.compareTo(b.file.lastModified!))
.reversed
.firstOrNull;
return Album(
lastUpdated: lastUpdated,
name: name,
provider: AlbumStaticProvider(
items: items,
latestItemTime: latestFileItem?.file.lastModified,
),
coverProvider: cover == null
? AlbumAutoCoverProvider(coverFile: latestFileItem?.file)
: AlbumManualCoverProvider(coverFile: cover!),
sortProvider: const AlbumNullSortProvider(),
shares: shares.isEmpty ? null : shares,
albumFile: buildAlbumFile(
path: buildAlbumFilePath(albumFilename, user: ownerId),
fileId: fileId,
ownerId: ownerId,
),
);
}
/// Add a file item
///
/// By default, the item will be added by admin and added at the same time as
/// the file's lastModified.
///
/// If [isCover] is true, the coverProvider of the album will become
/// [AlbumManualCoverProvider]
void addFileItem(
File file, {
String addedBy = "admin",
DateTime? addedAt,
bool isCover = false,
}) {
final fileItem = AlbumFileItem(
file: file,
addedBy: addedBy.toCi(),
addedAt: addedAt ?? file.lastModified!,
);
items.add(fileItem);
if (isCover) {
cover = file;
}
}
/// Add an album share
void addShare(String userId) {
shares.add(buildAlbumShare(userId: userId));
}
static fileItemsOf(Album album) =>
AlbumStaticProvider.of(album).items.whereType<AlbumFileItem>().toList();
final DateTime lastUpdated;
final String name;
final String albumFilename;
final int fileId;
final String ownerId;
final items = <AlbumItem>[];
File? cover;
final shares = <AlbumShare>[];
}
void initLog() { void initLog() {
Logger.root.level = Level.ALL; Logger.root.level = Level.ALL;
@ -50,6 +167,15 @@ String buildAlbumFilePath(
}) => }) =>
"remote.php/dav/files/$user/.com.nkming.nc_photos/albums/$filename"; "remote.php/dav/files/$user/.com.nkming.nc_photos/albums/$filename";
AlbumShare buildAlbumShare({
required String userId,
String? displayName,
}) =>
AlbumShare(
userId: userId.toCi(),
displayName: displayName ?? userId,
);
/// Build a mock [File] pointing to a JPEG image file /// Build a mock [File] pointing to a JPEG image file
/// ///
/// Warning: not all fields are filled, but the most essential ones are /// Warning: not all fields are filled, but the most essential ones are
@ -96,14 +222,14 @@ Share buildShare({
Sharee buildSharee({ Sharee buildSharee({
ShareeType type = ShareeType.user, ShareeType type = ShareeType.user,
String label = "admin", String? label,
int shareType = 0, int shareType = 0,
required CiString shareWith, required CiString shareWith,
String? shareWithDisplayNameUnique, String? shareWithDisplayNameUnique,
}) => }) =>
Sharee( Sharee(
type: type, type: type,
label: label, label: label ?? shareWith.toString(),
shareType: shareType, shareType: shareType,
shareWith: shareWith, shareWith: shareWith,
); );

109
test/use_case/add_to_album_test.dart
View file

@ -38,14 +38,11 @@ void main() {
Future<void> _addFile() async { Future<void> _addFile() async {
final account = test_util.buildAccount(); final account = test_util.buildAccount();
final pref = Pref.scoped(PrefMemoryProvider()); final pref = Pref.scoped(PrefMemoryProvider());
final albumFile = test_util.buildAlbumFile( final file = (test_util.FilesBuilder(initialFileId: 1)
path: test_util.buildAlbumFilePath("test1.json"), ..addJpeg("admin/test1.jpg"))
fileId: 0, .build()[0];
); final album = test_util.AlbumBuilder().build();
final file = test_util.buildJpegFile( final albumFile = album.albumFile!;
path: "remote.php/dav/files/admin/test1.jpg",
fileId: 1,
);
final appDb = MockAppDb(); final appDb = MockAppDb();
await appDb.use((db) async { await appDb.use((db) async {
final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite); final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite);
@ -53,16 +50,7 @@ Future<void> _addFile() async {
await store.put(AppDbFileDbEntry.fromFile(account, file).toJson(), await store.put(AppDbFileDbEntry.fromFile(account, file).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file)); AppDbFileDbEntry.toPrimaryKey(account, file));
}); });
final albumRepo = MockAlbumMemoryRepo([ final albumRepo = MockAlbumMemoryRepo([album]);
Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(items: []),
coverProvider: AlbumAutoCoverProvider(),
sortProvider: const AlbumNullSortProvider(),
albumFile: albumFile,
),
]);
final shareRepo = MockShareRepo(); final shareRepo = MockShareRepo();
await AddToAlbum(albumRepo, shareRepo, appDb, pref)( await AddToAlbum(albumRepo, shareRepo, appDb, pref)(
@ -115,15 +103,11 @@ Future<void> _addFileToSharedAlbumOwned() async {
final pref = Pref.scoped(PrefMemoryProvider({ final pref = Pref.scoped(PrefMemoryProvider({
"isLabEnableSharedAlbum": true, "isLabEnableSharedAlbum": true,
})); }));
final albumFile = test_util.buildAlbumFile( final file = (test_util.FilesBuilder(initialFileId: 1)
path: test_util.buildAlbumFilePath("test1.json"), ..addJpeg("admin/test1.jpg"))
fileId: 0, .build()[0];
ownerId: "admin", final album = (test_util.AlbumBuilder()..addShare("user1")).build();
); final albumFile = album.albumFile!;
final file = test_util.buildJpegFile(
path: "remote.php/dav/files/admin/test1.jpg",
fileId: 1,
);
final appDb = MockAppDb(); final appDb = MockAppDb();
await appDb.use((db) async { await appDb.use((db) async {
final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite); final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite);
@ -131,17 +115,7 @@ Future<void> _addFileToSharedAlbumOwned() async {
await store.put(AppDbFileDbEntry.fromFile(account, file).toJson(), await store.put(AppDbFileDbEntry.fromFile(account, file).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file)); AppDbFileDbEntry.toPrimaryKey(account, file));
}); });
final albumRepo = MockAlbumMemoryRepo([ final albumRepo = MockAlbumMemoryRepo([album]);
Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(items: []),
coverProvider: AlbumAutoCoverProvider(),
sortProvider: const AlbumNullSortProvider(),
shares: [AlbumShare(userId: "user1".toCi())],
albumFile: albumFile,
),
]);
final shareRepo = MockShareMemoryRepo([ final shareRepo = MockShareMemoryRepo([
test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"), test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"),
]); ]);
@ -175,16 +149,11 @@ Future<void> _addFileOwnedByUserToSharedAlbumOwned() async {
final pref = Pref.scoped(PrefMemoryProvider({ final pref = Pref.scoped(PrefMemoryProvider({
"isLabEnableSharedAlbum": true, "isLabEnableSharedAlbum": true,
})); }));
final albumFile = test_util.buildAlbumFile( final file = (test_util.FilesBuilder(initialFileId: 1)
path: test_util.buildAlbumFilePath("test1.json"), ..addJpeg("admin/test1.jpg", ownerId: "user1"))
fileId: 0, .build()[0];
ownerId: "admin", final album = (test_util.AlbumBuilder()..addShare("user1")).build();
); final albumFile = album.albumFile!;
final file = test_util.buildJpegFile(
path: "remote.php/dav/files/admin/test1.jpg",
fileId: 1,
ownerId: "user1",
);
final appDb = MockAppDb(); final appDb = MockAppDb();
await appDb.use((db) async { await appDb.use((db) async {
final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite); final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite);
@ -192,17 +161,7 @@ Future<void> _addFileOwnedByUserToSharedAlbumOwned() async {
await store.put(AppDbFileDbEntry.fromFile(account, file).toJson(), await store.put(AppDbFileDbEntry.fromFile(account, file).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file)); AppDbFileDbEntry.toPrimaryKey(account, file));
}); });
final albumRepo = MockAlbumMemoryRepo([ final albumRepo = MockAlbumMemoryRepo([album]);
Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(items: []),
coverProvider: AlbumAutoCoverProvider(),
sortProvider: const AlbumNullSortProvider(),
shares: [AlbumShare(userId: "user1".toCi())],
albumFile: albumFile,
),
]);
final shareRepo = MockShareMemoryRepo([ final shareRepo = MockShareMemoryRepo([
test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"), test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"),
]); ]);
@ -236,15 +195,14 @@ Future<void> _addFileToMultiuserSharedAlbumNotOwned() async {
final pref = Pref.scoped(PrefMemoryProvider({ final pref = Pref.scoped(PrefMemoryProvider({
"isLabEnableSharedAlbum": true, "isLabEnableSharedAlbum": true,
})); }));
final albumFile = test_util.buildAlbumFile( final file = (test_util.FilesBuilder(initialFileId: 1)
path: test_util.buildAlbumFilePath("test1.json"), ..addJpeg("admin/test1.jpg"))
fileId: 0, .build()[0];
ownerId: "user1", final album = (test_util.AlbumBuilder(ownerId: "user1")
); ..addShare("admin")
final file = test_util.buildJpegFile( ..addShare("user2"))
path: "remote.php/dav/files/admin/test1.jpg", .build();
fileId: 1, final albumFile = album.albumFile!;
);
final appDb = MockAppDb(); final appDb = MockAppDb();
await appDb.use((db) async { await appDb.use((db) async {
final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite); final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite);
@ -252,20 +210,7 @@ Future<void> _addFileToMultiuserSharedAlbumNotOwned() async {
await store.put(AppDbFileDbEntry.fromFile(account, file).toJson(), await store.put(AppDbFileDbEntry.fromFile(account, file).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file)); AppDbFileDbEntry.toPrimaryKey(account, file));
}); });
final albumRepo = MockAlbumMemoryRepo([ final albumRepo = MockAlbumMemoryRepo([album]);
Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(items: []),
coverProvider: AlbumAutoCoverProvider(),
sortProvider: const AlbumNullSortProvider(),
shares: [
AlbumShare(userId: "admin".toCi()),
AlbumShare(userId: "user2".toCi()),
],
albumFile: albumFile,
),
]);
final shareRepo = MockShareMemoryRepo([ final shareRepo = MockShareMemoryRepo([
test_util.buildShare( test_util.buildShare(
id: "0", uidOwner: "user1", file: albumFile, shareWith: "admin"), id: "0", uidOwner: "user1", file: albumFile, shareWith: "admin"),

569
test/use_case/remove_from_album_test.dart
View file

@ -2,10 +2,8 @@ import 'package:event_bus/event_bus.dart';
import 'package:idb_shim/idb.dart'; import 'package:idb_shim/idb.dart';
import 'package:kiwi/kiwi.dart'; import 'package:kiwi/kiwi.dart';
import 'package:nc_photos/app_db.dart'; import 'package:nc_photos/app_db.dart';
import 'package:nc_photos/ci_string.dart';
import 'package:nc_photos/entity/album.dart'; import 'package:nc_photos/entity/album.dart';
import 'package:nc_photos/entity/album/cover_provider.dart'; import 'package:nc_photos/entity/album/cover_provider.dart';
import 'package:nc_photos/entity/album/item.dart';
import 'package:nc_photos/entity/album/provider.dart'; import 'package:nc_photos/entity/album/provider.dart';
import 'package:nc_photos/entity/album/sort_provider.dart'; import 'package:nc_photos/entity/album/sort_provider.dart';
import 'package:nc_photos/or_null.dart'; import 'package:nc_photos/or_null.dart';
@ -28,12 +26,12 @@ void main() {
test("file", _removeFromSharedAlbumOwned); test("file", _removeFromSharedAlbumOwned);
test("file w/ shares managed by others", test("file w/ shares managed by others",
_removeFromSharedAlbumOwnedWithOtherShare); _removeFromSharedAlbumOwnedWithOtherShare);
test("file w/ extra share", _removeFromSharedAlbumOwnedLeaveExtraShare);
}); });
group("shared album (not owned)", () { group("shared album (not owned)", () {
test("file", _removeFromSharedAlbumNotOwned); test("file", _removeFromSharedAlbumNotOwned);
test("file w/ shares managed by owner", test("file w/ shares managed by owner",
_removeFromSharedAlbumNotOwnedWithOwnerShare); _removeFromSharedAlbumNotOwnedWithOwnerShare);
test("file w/ extra share", _removeFromSharedAlbumLeaveExtraShare);
}); });
}); });
} }
@ -44,19 +42,13 @@ void main() {
Future<void> _removeLastFile() async { Future<void> _removeLastFile() async {
final account = test_util.buildAccount(); final account = test_util.buildAccount();
final pref = Pref.scoped(PrefMemoryProvider()); final pref = Pref.scoped(PrefMemoryProvider());
final albumFile = test_util.buildAlbumFile( final files = (test_util.FilesBuilder(initialFileId: 1)
path: test_util.buildAlbumFilePath("test1.json"), ..addJpeg("admin/test1.jpg"))
fileId: 0, .build();
); final album = (test_util.AlbumBuilder()..addFileItem(files[0])).build();
final file1 = test_util.buildJpegFile( final file1 = files[0];
path: "remote.php/dav/files/admin/test1.jpg", final fileItem1 = test_util.AlbumBuilder.fileItemsOf(album)[0];
fileId: 1, final albumFile = album.albumFile!;
);
final fileItem1 = AlbumFileItem(
file: file1,
addedBy: "admin".toCi(),
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 5),
);
final appDb = MockAppDb(); final appDb = MockAppDb();
await appDb.use((db) async { await appDb.use((db) async {
final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite); final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite);
@ -64,19 +56,7 @@ Future<void> _removeLastFile() async {
await store.put(AppDbFileDbEntry.fromFile(account, file1).toJson(), await store.put(AppDbFileDbEntry.fromFile(account, file1).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file1)); AppDbFileDbEntry.toPrimaryKey(account, file1));
}); });
final albumRepo = MockAlbumMemoryRepo([ final albumRepo = MockAlbumMemoryRepo([album]);
Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(
items: [fileItem1],
latestItemTime: file1.lastModified,
),
coverProvider: AlbumAutoCoverProvider(coverFile: file1),
sortProvider: const AlbumNullSortProvider(),
albumFile: albumFile,
),
]);
final shareRepo = MockShareRepo(); final shareRepo = MockShareRepo();
final fileRepo = MockFileMemoryRepo([albumFile, file1]); final fileRepo = MockFileMemoryRepo([albumFile, file1]);
@ -108,69 +88,36 @@ Future<void> _removeLastFile() async {
Future<void> _remove1OfNFiles() async { Future<void> _remove1OfNFiles() async {
final account = test_util.buildAccount(); final account = test_util.buildAccount();
final pref = Pref.scoped(PrefMemoryProvider()); final pref = Pref.scoped(PrefMemoryProvider());
final albumFile = test_util.buildAlbumFile( final files = (test_util.FilesBuilder(initialFileId: 1)
path: test_util.buildAlbumFilePath("test1.json"), ..addJpeg("admin/test1.jpg")
fileId: 0, ..addJpeg("admin/test2.jpg")
); ..addJpeg("admin/test3.jpg"))
final file1 = test_util.buildJpegFile( .build();
path: "remote.php/dav/files/admin/test1.jpg", final album = (test_util.AlbumBuilder()
fileId: 1, ..addFileItem(files[0])
lastModified: DateTime.utc(2020, 1, 2, 3, 4, 5), ..addFileItem(files[1])
); ..addFileItem(files[2]))
final fileItem1 = AlbumFileItem( .build();
file: file1, final fileItems = test_util.AlbumBuilder.fileItemsOf(album);
addedBy: "admin".toCi(), final albumFile = album.albumFile!;
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 5),
);
final file2 = test_util.buildJpegFile(
path: "remote.php/dav/files/admin/test2.jpg",
fileId: 2,
lastModified: DateTime.utc(2020, 1, 2, 3, 4, 6),
);
final fileItem2 = AlbumFileItem(
file: file2,
addedBy: "admin".toCi(),
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 6),
);
final file3 = test_util.buildJpegFile(
path: "remote.php/dav/files/admin/test3.jpg",
fileId: 3,
lastModified: DateTime.utc(2020, 1, 2, 3, 4, 7),
);
final fileItem3 = AlbumFileItem(
file: file3,
addedBy: "admin".toCi(),
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 7),
);
final appDb = MockAppDb(); final appDb = MockAppDb();
await appDb.use((db) async { await appDb.use((db) async {
final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite); final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite);
final store = transaction.objectStore(AppDb.fileDbStoreName); final store = transaction.objectStore(AppDb.fileDbStoreName);
await store.put(AppDbFileDbEntry.fromFile(account, file1).toJson(), await store.put(AppDbFileDbEntry.fromFile(account, files[0]).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file1)); AppDbFileDbEntry.toPrimaryKey(account, files[0]));
await store.put(AppDbFileDbEntry.fromFile(account, file2).toJson(), await store.put(AppDbFileDbEntry.fromFile(account, files[1]).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file2)); AppDbFileDbEntry.toPrimaryKey(account, files[1]));
await store.put(AppDbFileDbEntry.fromFile(account, file3).toJson(), await store.put(AppDbFileDbEntry.fromFile(account, files[2]).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file3)); AppDbFileDbEntry.toPrimaryKey(account, files[2]));
}); });
final albumRepo = MockAlbumMemoryRepo([ final albumRepo = MockAlbumMemoryRepo([album]);
Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(
items: [fileItem1, fileItem2, fileItem3],
latestItemTime: file3.lastModified,
),
coverProvider: AlbumAutoCoverProvider(coverFile: file3),
sortProvider: const AlbumNullSortProvider(),
albumFile: albumFile,
),
]);
final shareRepo = MockShareRepo(); final shareRepo = MockShareRepo();
final fileRepo = MockFileMemoryRepo([albumFile, file1, file2, file3]); final fileRepo =
MockFileMemoryRepo([albumFile, files[0], files[1], files[2]]);
await RemoveFromAlbum(albumRepo, shareRepo, fileRepo, appDb, pref)( await RemoveFromAlbum(albumRepo, shareRepo, fileRepo, appDb, pref)(
account, albumRepo.findAlbumByPath(albumFile.path), [fileItem1]); account, albumRepo.findAlbumByPath(albumFile.path), [fileItems[0]]);
expect( expect(
albumRepo.albums albumRepo.albums
.map((e) => e.copyWith( .map((e) => e.copyWith(
@ -183,10 +130,10 @@ Future<void> _remove1OfNFiles() async {
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5), lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test", name: "test",
provider: AlbumStaticProvider( provider: AlbumStaticProvider(
items: [fileItem2, fileItem3], items: [fileItems[1], fileItems[2]],
latestItemTime: file3.lastModified, latestItemTime: files[2].lastModified,
), ),
coverProvider: AlbumAutoCoverProvider(coverFile: file3), coverProvider: AlbumAutoCoverProvider(coverFile: files[2]),
sortProvider: const AlbumNullSortProvider(), sortProvider: const AlbumNullSortProvider(),
albumFile: albumFile, albumFile: albumFile,
), ),
@ -200,69 +147,39 @@ Future<void> _remove1OfNFiles() async {
Future<void> _removeLatestOfNFiles() async { Future<void> _removeLatestOfNFiles() async {
final account = test_util.buildAccount(); final account = test_util.buildAccount();
final pref = Pref.scoped(PrefMemoryProvider()); final pref = Pref.scoped(PrefMemoryProvider());
final albumFile = test_util.buildAlbumFile( final files = (test_util.FilesBuilder(initialFileId: 1)
path: test_util.buildAlbumFilePath("test1.json"), ..addJpeg("admin/test1.jpg",
fileId: 0, lastModified: DateTime.utc(2020, 1, 2, 3, 4, 8))
); ..addJpeg("admin/test2.jpg",
final file1 = test_util.buildJpegFile( lastModified: DateTime.utc(2020, 1, 2, 3, 4, 7))
path: "remote.php/dav/files/admin/test1.jpg", ..addJpeg("admin/test3.jpg",
fileId: 1, lastModified: DateTime.utc(2020, 1, 2, 3, 4, 6)))
lastModified: DateTime.utc(2020, 1, 2, 3, 4, 8), .build();
); final album = (test_util.AlbumBuilder()
final fileItem1 = AlbumFileItem( ..addFileItem(files[0])
file: file1, ..addFileItem(files[1])
addedBy: "admin".toCi(), ..addFileItem(files[2]))
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 8), .build();
); final fileItems = test_util.AlbumBuilder.fileItemsOf(album);
final file2 = test_util.buildJpegFile( final albumFile = album.albumFile!;
path: "remote.php/dav/files/admin/test2.jpg",
fileId: 2,
lastModified: DateTime.utc(2020, 1, 2, 3, 4, 6),
);
final fileItem2 = AlbumFileItem(
file: file2,
addedBy: "admin".toCi(),
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 6),
);
final file3 = test_util.buildJpegFile(
path: "remote.php/dav/files/admin/test3.jpg",
fileId: 3,
lastModified: DateTime.utc(2020, 1, 2, 3, 4, 7),
);
final fileItem3 = AlbumFileItem(
file: file3,
addedBy: "admin".toCi(),
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 7),
);
final appDb = MockAppDb(); final appDb = MockAppDb();
await appDb.use((db) async { await appDb.use((db) async {
final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite); final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite);
final store = transaction.objectStore(AppDb.fileDbStoreName); final store = transaction.objectStore(AppDb.fileDbStoreName);
await store.put(AppDbFileDbEntry.fromFile(account, file1).toJson(), await store.put(AppDbFileDbEntry.fromFile(account, files[0]).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file1)); AppDbFileDbEntry.toPrimaryKey(account, files[0]));
await store.put(AppDbFileDbEntry.fromFile(account, file2).toJson(), await store.put(AppDbFileDbEntry.fromFile(account, files[1]).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file2)); AppDbFileDbEntry.toPrimaryKey(account, files[1]));
await store.put(AppDbFileDbEntry.fromFile(account, file3).toJson(), await store.put(AppDbFileDbEntry.fromFile(account, files[2]).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file3)); AppDbFileDbEntry.toPrimaryKey(account, files[2]));
}); });
final albumRepo = MockAlbumMemoryRepo([ final albumRepo = MockAlbumMemoryRepo([album]);
Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(
items: [fileItem1, fileItem2, fileItem3],
latestItemTime: file1.lastModified,
),
coverProvider: AlbumAutoCoverProvider(coverFile: file1),
sortProvider: const AlbumNullSortProvider(),
albumFile: albumFile,
),
]);
final shareRepo = MockShareRepo(); final shareRepo = MockShareRepo();
final fileRepo = MockFileMemoryRepo([albumFile, file1, file2, file3]); final fileRepo =
MockFileMemoryRepo([albumFile, files[0], files[1], files[2]]);
await RemoveFromAlbum(albumRepo, shareRepo, fileRepo, appDb, pref)( await RemoveFromAlbum(albumRepo, shareRepo, fileRepo, appDb, pref)(
account, albumRepo.findAlbumByPath(albumFile.path), [fileItem1]); account, albumRepo.findAlbumByPath(albumFile.path), [fileItems[0]]);
expect( expect(
albumRepo.albums albumRepo.albums
.map((e) => e.copyWith( .map((e) => e.copyWith(
@ -275,10 +192,10 @@ Future<void> _removeLatestOfNFiles() async {
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5), lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test", name: "test",
provider: AlbumStaticProvider( provider: AlbumStaticProvider(
items: [fileItem2, fileItem3], items: [fileItems[1], fileItems[2]],
latestItemTime: file3.lastModified, latestItemTime: files[1].lastModified,
), ),
coverProvider: AlbumAutoCoverProvider(coverFile: file3), coverProvider: AlbumAutoCoverProvider(coverFile: files[1]),
sortProvider: const AlbumNullSortProvider(), sortProvider: const AlbumNullSortProvider(),
albumFile: albumFile, albumFile: albumFile,
), ),
@ -292,69 +209,36 @@ Future<void> _removeLatestOfNFiles() async {
Future<void> _removeManualCoverFile() async { Future<void> _removeManualCoverFile() async {
final account = test_util.buildAccount(); final account = test_util.buildAccount();
final pref = Pref.scoped(PrefMemoryProvider()); final pref = Pref.scoped(PrefMemoryProvider());
final albumFile = test_util.buildAlbumFile( final files = (test_util.FilesBuilder(initialFileId: 1)
path: test_util.buildAlbumFilePath("test1.json"), ..addJpeg("admin/test1.jpg")
fileId: 0, ..addJpeg("admin/test2.jpg")
); ..addJpeg("admin/test3.jpg"))
final file1 = test_util.buildJpegFile( .build();
path: "remote.php/dav/files/admin/test1.jpg", final album = (test_util.AlbumBuilder()
fileId: 1, ..addFileItem(files[0], isCover: true)
lastModified: DateTime.utc(2020, 1, 2, 3, 4, 5), ..addFileItem(files[1])
); ..addFileItem(files[2]))
final fileItem1 = AlbumFileItem( .build();
file: file1, final fileItems = test_util.AlbumBuilder.fileItemsOf(album);
addedBy: "admin".toCi(), final albumFile = album.albumFile!;
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 5),
);
final file2 = test_util.buildJpegFile(
path: "remote.php/dav/files/admin/test2.jpg",
fileId: 2,
lastModified: DateTime.utc(2020, 1, 2, 3, 4, 6),
);
final fileItem2 = AlbumFileItem(
file: file2,
addedBy: "admin".toCi(),
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 6),
);
final file3 = test_util.buildJpegFile(
path: "remote.php/dav/files/admin/test3.jpg",
fileId: 3,
lastModified: DateTime.utc(2020, 1, 2, 3, 4, 7),
);
final fileItem3 = AlbumFileItem(
file: file3,
addedBy: "admin".toCi(),
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 7),
);
final appDb = MockAppDb(); final appDb = MockAppDb();
await appDb.use((db) async { await appDb.use((db) async {
final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite); final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite);
final store = transaction.objectStore(AppDb.fileDbStoreName); final store = transaction.objectStore(AppDb.fileDbStoreName);
await store.put(AppDbFileDbEntry.fromFile(account, file1).toJson(), await store.put(AppDbFileDbEntry.fromFile(account, files[0]).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file1)); AppDbFileDbEntry.toPrimaryKey(account, files[0]));
await store.put(AppDbFileDbEntry.fromFile(account, file2).toJson(), await store.put(AppDbFileDbEntry.fromFile(account, files[1]).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file2)); AppDbFileDbEntry.toPrimaryKey(account, files[1]));
await store.put(AppDbFileDbEntry.fromFile(account, file3).toJson(), await store.put(AppDbFileDbEntry.fromFile(account, files[2]).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file3)); AppDbFileDbEntry.toPrimaryKey(account, files[2]));
}); });
final albumRepo = MockAlbumMemoryRepo([ final albumRepo = MockAlbumMemoryRepo([album]);
Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(
items: [fileItem1, fileItem2, fileItem3],
latestItemTime: file3.lastModified,
),
coverProvider: AlbumManualCoverProvider(coverFile: file1),
sortProvider: const AlbumNullSortProvider(),
albumFile: albumFile,
),
]);
final shareRepo = MockShareRepo(); final shareRepo = MockShareRepo();
final fileRepo = MockFileMemoryRepo([albumFile, file1, file2, file3]); final fileRepo =
MockFileMemoryRepo([albumFile, files[0], files[1], files[2]]);
await RemoveFromAlbum(albumRepo, shareRepo, fileRepo, appDb, pref)( await RemoveFromAlbum(albumRepo, shareRepo, fileRepo, appDb, pref)(
account, albumRepo.findAlbumByPath(albumFile.path), [fileItem1]); account, albumRepo.findAlbumByPath(albumFile.path), [fileItems[0]]);
expect( expect(
albumRepo.albums albumRepo.albums
.map((e) => e.copyWith( .map((e) => e.copyWith(
@ -367,10 +251,10 @@ Future<void> _removeManualCoverFile() async {
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5), lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test", name: "test",
provider: AlbumStaticProvider( provider: AlbumStaticProvider(
items: [fileItem2, fileItem3], items: [fileItems[1], fileItems[2]],
latestItemTime: file3.lastModified, latestItemTime: files[2].lastModified,
), ),
coverProvider: AlbumAutoCoverProvider(coverFile: file3), coverProvider: AlbumAutoCoverProvider(coverFile: files[2]),
sortProvider: const AlbumNullSortProvider(), sortProvider: const AlbumNullSortProvider(),
albumFile: albumFile, albumFile: albumFile,
), ),
@ -386,20 +270,16 @@ Future<void> _removeFromSharedAlbumOwned() async {
final pref = Pref.scoped(PrefMemoryProvider({ final pref = Pref.scoped(PrefMemoryProvider({
"isLabEnableSharedAlbum": true, "isLabEnableSharedAlbum": true,
})); }));
final albumFile = test_util.buildAlbumFile( final files = (test_util.FilesBuilder(initialFileId: 1)
path: test_util.buildAlbumFilePath("test1.json"), ..addJpeg("admin/test1.jpg"))
fileId: 0, .build();
ownerId: "admin", final album = (test_util.AlbumBuilder()
); ..addFileItem(files[0])
final file1 = test_util.buildJpegFile( ..addShare("user1"))
path: "remote.php/dav/files/admin/test1.jpg", .build();
fileId: 1, final file1 = files[0];
); final fileItem1 = test_util.AlbumBuilder.fileItemsOf(album)[0];
final fileItem1 = AlbumFileItem( final albumFile = album.albumFile!;
file: file1,
addedBy: "admin".toCi(),
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 5),
);
final appDb = MockAppDb(); final appDb = MockAppDb();
await appDb.use((db) async { await appDb.use((db) async {
final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite); final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite);
@ -407,20 +287,7 @@ Future<void> _removeFromSharedAlbumOwned() async {
await store.put(AppDbFileDbEntry.fromFile(account, file1).toJson(), await store.put(AppDbFileDbEntry.fromFile(account, file1).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file1)); AppDbFileDbEntry.toPrimaryKey(account, file1));
}); });
final albumRepo = MockAlbumMemoryRepo([ final albumRepo = MockAlbumMemoryRepo([album]);
Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(
items: [fileItem1],
latestItemTime: file1.lastModified,
),
coverProvider: AlbumAutoCoverProvider(coverFile: file1),
sortProvider: const AlbumNullSortProvider(),
shares: [AlbumShare(userId: "user1".toCi())],
albumFile: albumFile,
),
]);
final shareRepo = MockShareMemoryRepo([ final shareRepo = MockShareMemoryRepo([
test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"), test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"),
test_util.buildShare(id: "1", file: file1, shareWith: "user1"), test_util.buildShare(id: "1", file: file1, shareWith: "user1"),
@ -445,20 +312,17 @@ Future<void> _removeFromSharedAlbumOwnedWithOtherShare() async {
final pref = Pref.scoped(PrefMemoryProvider({ final pref = Pref.scoped(PrefMemoryProvider({
"isLabEnableSharedAlbum": true, "isLabEnableSharedAlbum": true,
})); }));
final albumFile = test_util.buildAlbumFile( final files = (test_util.FilesBuilder(initialFileId: 1)
path: test_util.buildAlbumFilePath("test1.json"), ..addJpeg("user1/test1.jpg", ownerId: "user1"))
fileId: 0, .build();
ownerId: "admin", final album = (test_util.AlbumBuilder()
); ..addFileItem(files[0], addedBy: "user1")
final file1 = test_util.buildJpegFile( ..addShare("user1")
path: "remote.php/dav/files/admin/test1.jpg", ..addShare("user2"))
fileId: 1, .build();
); final file1 = files[0];
final fileItem1 = AlbumFileItem( final fileItem1 = test_util.AlbumBuilder.fileItemsOf(album)[0];
file: file1, final albumFile = album.albumFile!;
addedBy: "admin".toCi(),
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 5),
);
final appDb = MockAppDb(); final appDb = MockAppDb();
await appDb.use((db) async { await appDb.use((db) async {
final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite); final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite);
@ -466,20 +330,7 @@ Future<void> _removeFromSharedAlbumOwnedWithOtherShare() async {
await store.put(AppDbFileDbEntry.fromFile(account, file1).toJson(), await store.put(AppDbFileDbEntry.fromFile(account, file1).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file1)); AppDbFileDbEntry.toPrimaryKey(account, file1));
}); });
final albumRepo = MockAlbumMemoryRepo([ final albumRepo = MockAlbumMemoryRepo([album]);
Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(
items: [fileItem1],
latestItemTime: file1.lastModified,
),
coverProvider: AlbumAutoCoverProvider(coverFile: file1),
sortProvider: const AlbumNullSortProvider(),
shares: [AlbumShare(userId: "user1".toCi())],
albumFile: albumFile,
),
]);
final shareRepo = MockShareMemoryRepo([ final shareRepo = MockShareMemoryRepo([
test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"), test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"),
test_util.buildShare(id: "1", file: albumFile, shareWith: "user2"), test_util.buildShare(id: "1", file: albumFile, shareWith: "user2"),
@ -505,6 +356,52 @@ Future<void> _removeFromSharedAlbumOwnedWithOtherShare() async {
); );
} }
/// Remove a file from a shared album (admin -> user1) with extra unmanaged
/// share (admin -> user2)
///
/// Expect: share (admin -> user1) for the file deleted;
/// extra share (admin -> user2) unchanged
Future<void> _removeFromSharedAlbumOwnedLeaveExtraShare() async {
final account = test_util.buildAccount();
final pref = Pref.scoped(PrefMemoryProvider({
"isLabEnableSharedAlbum": true,
}));
final files = (test_util.FilesBuilder(initialFileId: 1)
..addJpeg("admin/test1.jpg"))
.build();
final album = (test_util.AlbumBuilder()
..addFileItem(files[0])
..addShare("user1"))
.build();
final file1 = files[0];
final fileItem1 = test_util.AlbumBuilder.fileItemsOf(album)[0];
final albumFile = album.albumFile!;
final appDb = MockAppDb();
await appDb.use((db) async {
final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite);
final store = transaction.objectStore(AppDb.fileDbStoreName);
await store.put(AppDbFileDbEntry.fromFile(account, file1).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file1));
});
final albumRepo = MockAlbumMemoryRepo([album]);
final shareRepo = MockShareMemoryRepo([
test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"),
test_util.buildShare(id: "1", file: file1, shareWith: "user1"),
test_util.buildShare(id: "2", file: file1, shareWith: "user2"),
]);
final fileRepo = MockFileMemoryRepo([albumFile, file1]);
await RemoveFromAlbum(albumRepo, shareRepo, fileRepo, appDb, pref)(
account, albumRepo.findAlbumByPath(albumFile.path), [fileItem1]);
expect(
shareRepo.shares,
[
test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"),
test_util.buildShare(id: "2", file: file1, shareWith: "user2"),
],
);
}
/// Remove a file from a shared album (user1 -> admin, user2) /// Remove a file from a shared album (user1 -> admin, user2)
/// ///
/// Expect: shares (admin -> user1, user2) for the file deleted /// Expect: shares (admin -> user1, user2) for the file deleted
@ -513,21 +410,17 @@ Future<void> _removeFromSharedAlbumNotOwned() async {
final pref = Pref.scoped(PrefMemoryProvider({ final pref = Pref.scoped(PrefMemoryProvider({
"isLabEnableSharedAlbum": true, "isLabEnableSharedAlbum": true,
})); }));
final albumFile = test_util.buildAlbumFile( final files = (test_util.FilesBuilder(initialFileId: 1)
path: test_util.buildAlbumFilePath("test1.json"), ..addJpeg("admin/test1.jpg"))
fileId: 0, .build();
ownerId: "user1", final album = (test_util.AlbumBuilder(ownerId: "user1")
); ..addFileItem(files[0])
final file1 = test_util.buildJpegFile( ..addShare("admin")
path: "remote.php/dav/files/admin/test1.jpg", ..addShare("user2"))
fileId: 1, .build();
lastModified: DateTime.utc(2020, 1, 2, 3, 4, 5), final file1 = files[0];
); final fileItem1 = test_util.AlbumBuilder.fileItemsOf(album)[0];
final fileItem1 = AlbumFileItem( final albumFile = album.albumFile!;
file: file1,
addedBy: "admin".toCi(),
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 5),
);
final appDb = MockAppDb(); final appDb = MockAppDb();
await appDb.use((db) async { await appDb.use((db) async {
final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite); final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite);
@ -535,23 +428,7 @@ Future<void> _removeFromSharedAlbumNotOwned() async {
await store.put(AppDbFileDbEntry.fromFile(account, file1).toJson(), await store.put(AppDbFileDbEntry.fromFile(account, file1).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file1)); AppDbFileDbEntry.toPrimaryKey(account, file1));
}); });
final albumRepo = MockAlbumMemoryRepo([ final albumRepo = MockAlbumMemoryRepo([album]);
Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(
items: [fileItem1],
latestItemTime: file1.lastModified,
),
coverProvider: AlbumAutoCoverProvider(coverFile: file1),
sortProvider: const AlbumNullSortProvider(),
shares: [
AlbumShare(userId: "admin".toCi()),
AlbumShare(userId: "user2".toCi()),
],
albumFile: albumFile,
),
]);
final shareRepo = MockShareMemoryRepo([ final shareRepo = MockShareMemoryRepo([
test_util.buildShare( test_util.buildShare(
id: "0", uidOwner: "user1", file: albumFile, shareWith: "admin"), id: "0", uidOwner: "user1", file: albumFile, shareWith: "admin"),
@ -585,21 +462,17 @@ Future<void> _removeFromSharedAlbumNotOwnedWithOwnerShare() async {
final pref = Pref.scoped(PrefMemoryProvider({ final pref = Pref.scoped(PrefMemoryProvider({
"isLabEnableSharedAlbum": true, "isLabEnableSharedAlbum": true,
})); }));
final albumFile = test_util.buildAlbumFile( final files = (test_util.FilesBuilder(initialFileId: 1)
path: test_util.buildAlbumFilePath("test1.json"), ..addJpeg("admin/test1.jpg"))
fileId: 0, .build();
ownerId: "user1", final album = (test_util.AlbumBuilder(ownerId: "user1")
); ..addFileItem(files[0])
final file1 = test_util.buildJpegFile( ..addShare("admin")
path: "remote.php/dav/files/admin/test1.jpg", ..addShare("user2"))
fileId: 1, .build();
lastModified: DateTime.utc(2020, 1, 2, 3, 4, 5), final file1 = files[0];
); final fileItem1 = test_util.AlbumBuilder.fileItemsOf(album)[0];
final fileItem1 = AlbumFileItem( final albumFile = album.albumFile!;
file: file1,
addedBy: "admin".toCi(),
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 5),
);
final appDb = MockAppDb(); final appDb = MockAppDb();
await appDb.use((db) async { await appDb.use((db) async {
final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite); final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite);
@ -607,23 +480,7 @@ Future<void> _removeFromSharedAlbumNotOwnedWithOwnerShare() async {
await store.put(AppDbFileDbEntry.fromFile(account, file1).toJson(), await store.put(AppDbFileDbEntry.fromFile(account, file1).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file1)); AppDbFileDbEntry.toPrimaryKey(account, file1));
}); });
final albumRepo = MockAlbumMemoryRepo([ final albumRepo = MockAlbumMemoryRepo([album]);
Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(
items: [fileItem1],
latestItemTime: file1.lastModified,
),
coverProvider: AlbumAutoCoverProvider(coverFile: file1),
sortProvider: const AlbumNullSortProvider(),
shares: [
AlbumShare(userId: "admin".toCi()),
AlbumShare(userId: "user2".toCi()),
],
albumFile: albumFile,
),
]);
final shareRepo = MockShareMemoryRepo([ final shareRepo = MockShareMemoryRepo([
test_util.buildShare( test_util.buildShare(
id: "0", uidOwner: "user1", file: albumFile, shareWith: "admin"), id: "0", uidOwner: "user1", file: albumFile, shareWith: "admin"),
@ -649,69 +506,3 @@ Future<void> _removeFromSharedAlbumNotOwnedWithOwnerShare() async {
], ],
); );
} }
/// Remove a file from a shared album (admin -> user1) with extra unmanaged
/// share (admin -> user2)
///
/// Expect: share (admin -> user1) for the file deleted;
/// extra share (admin -> user2) unchanged
Future<void> _removeFromSharedAlbumLeaveExtraShare() async {
final account = test_util.buildAccount();
final pref = Pref.scoped(PrefMemoryProvider({
"isLabEnableSharedAlbum": true,
}));
final albumFile = test_util.buildAlbumFile(
path: test_util.buildAlbumFilePath("test1.json"),
fileId: 0,
ownerId: "user1",
);
final file1 = test_util.buildJpegFile(
path: "remote.php/dav/files/admin/test1.jpg",
fileId: 1,
lastModified: DateTime.utc(2020, 1, 2, 3, 4, 5),
);
final fileItem1 = AlbumFileItem(
file: file1,
addedBy: "admin".toCi(),
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 5),
);
final appDb = MockAppDb();
await appDb.use((db) async {
final transaction = db.transaction(AppDb.fileDbStoreName, idbModeReadWrite);
final store = transaction.objectStore(AppDb.fileDbStoreName);
await store.put(AppDbFileDbEntry.fromFile(account, file1).toJson(),
AppDbFileDbEntry.toPrimaryKey(account, file1));
});
final albumRepo = MockAlbumMemoryRepo([
Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(
items: [fileItem1],
latestItemTime: file1.lastModified,
),
coverProvider: AlbumAutoCoverProvider(coverFile: file1),
sortProvider: const AlbumNullSortProvider(),
shares: [AlbumShare(userId: "admin".toCi())],
albumFile: albumFile,
),
]);
final shareRepo = MockShareMemoryRepo([
test_util.buildShare(
id: "0", uidOwner: "user1", file: albumFile, shareWith: "admin"),
test_util.buildShare(id: "1", file: file1, shareWith: "user1"),
test_util.buildShare(id: "2", file: file1, shareWith: "user2"),
]);
final fileRepo = MockFileMemoryRepo([albumFile, file1]);
await RemoveFromAlbum(albumRepo, shareRepo, fileRepo, appDb, pref)(
account, albumRepo.findAlbumByPath(albumFile.path), [fileItem1]);
expect(
shareRepo.shares,
[
test_util.buildShare(
id: "0", uidOwner: "user1", file: albumFile, shareWith: "admin"),
test_util.buildShare(id: "2", file: file1, shareWith: "user2"),
],
);
}

118
test/use_case/share_album_with_user_test.dart
View file

@ -1,11 +1,6 @@
import 'package:event_bus/event_bus.dart'; import 'package:event_bus/event_bus.dart';
import 'package:kiwi/kiwi.dart'; import 'package:kiwi/kiwi.dart';
import 'package:nc_photos/ci_string.dart'; import 'package:nc_photos/ci_string.dart';
import 'package:nc_photos/entity/album.dart';
import 'package:nc_photos/entity/album/cover_provider.dart';
import 'package:nc_photos/entity/album/item.dart';
import 'package:nc_photos/entity/album/provider.dart';
import 'package:nc_photos/entity/album/sort_provider.dart';
import 'package:nc_photos/use_case/share_album_with_user.dart'; import 'package:nc_photos/use_case/share_album_with_user.dart';
import 'package:test/test.dart'; import 'package:test/test.dart';
@ -29,20 +24,9 @@ void main() {
/// a new share (admin -> user1) is created for the album json /// a new share (admin -> user1) is created for the album json
Future<void> _shareWithoutFile() async { Future<void> _shareWithoutFile() async {
final account = test_util.buildAccount(); final account = test_util.buildAccount();
final albumFile = test_util.buildAlbumFile( final album = test_util.AlbumBuilder().build();
path: test_util.buildAlbumFilePath("test1.json"), final albumFile = album.albumFile!;
fileId: 0, final albumRepo = MockAlbumMemoryRepo([album]);
);
final albumRepo = MockAlbumMemoryRepo([
Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(items: []),
coverProvider: AlbumAutoCoverProvider(),
sortProvider: const AlbumNullSortProvider(),
albumFile: albumFile,
),
]);
final shareRepo = MockShareMemoryRepo(); final shareRepo = MockShareMemoryRepo();
await ShareAlbumWithUser(shareRepo, albumRepo)( await ShareAlbumWithUser(shareRepo, albumRepo)(
@ -52,7 +36,7 @@ Future<void> _shareWithoutFile() async {
); );
expect( expect(
albumRepo.findAlbumByPath(albumFile.path).shares, albumRepo.findAlbumByPath(albumFile.path).shares,
[AlbumShare(userId: "user1".toCi())], [test_util.buildAlbumShare(userId: "user1")],
); );
expect( expect(
shareRepo.shares, shareRepo.shares,
@ -67,33 +51,13 @@ Future<void> _shareWithoutFile() async {
/// files /// files
Future<void> _shareWithFile() async { Future<void> _shareWithFile() async {
final account = test_util.buildAccount(); final account = test_util.buildAccount();
final albumFile = test_util.buildAlbumFile( final files = (test_util.FilesBuilder(initialFileId: 1)
path: test_util.buildAlbumFilePath("test1.json"), ..addJpeg("admin/test1.jpg"))
fileId: 0, .build();
); final album = (test_util.AlbumBuilder()..addFileItem(files[0])).build();
final file1 = test_util.buildJpegFile( final file1 = files[0];
path: "remote.php/dav/files/admin/test1.jpg", final albumFile = album.albumFile!;
fileId: 1, final albumRepo = MockAlbumMemoryRepo([album]);
lastModified: DateTime.utc(2020, 1, 2, 3, 4, 5),
);
final fileItem1 = AlbumFileItem(
file: file1,
addedBy: "admin".toCi(),
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 5),
);
final albumRepo = MockAlbumMemoryRepo([
Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(
items: [fileItem1],
latestItemTime: file1.lastModified,
),
coverProvider: AlbumAutoCoverProvider(coverFile: file1),
sortProvider: const AlbumNullSortProvider(),
albumFile: albumFile,
),
]);
final shareRepo = MockShareMemoryRepo(); final shareRepo = MockShareMemoryRepo();
await ShareAlbumWithUser(shareRepo, albumRepo)( await ShareAlbumWithUser(shareRepo, albumRepo)(
@ -103,7 +67,7 @@ Future<void> _shareWithFile() async {
); );
expect( expect(
albumRepo.findAlbumByPath(albumFile.path).shares, albumRepo.findAlbumByPath(albumFile.path).shares,
[AlbumShare(userId: "user1".toCi())], [test_util.buildAlbumShare(userId: "user1")],
); );
expect( expect(
shareRepo.shares, shareRepo.shares,
@ -120,34 +84,12 @@ Future<void> _shareWithFile() async {
/// new shares (admin -> user1) are created for the album json /// new shares (admin -> user1) are created for the album json
Future<void> _shareWithFileOwnedByUser() async { Future<void> _shareWithFileOwnedByUser() async {
final account = test_util.buildAccount(); final account = test_util.buildAccount();
final albumFile = test_util.buildAlbumFile( final files = (test_util.FilesBuilder(initialFileId: 1)
path: test_util.buildAlbumFilePath("test1.json"), ..addJpeg("admin/test1.jpg", ownerId: "user1"))
fileId: 0, .build();
); final album = (test_util.AlbumBuilder()..addFileItem(files[0])).build();
final file1 = test_util.buildJpegFile( final albumFile = album.albumFile!;
path: "remote.php/dav/files/admin/test1.jpg", final albumRepo = MockAlbumMemoryRepo([album]);
fileId: 1,
lastModified: DateTime.utc(2020, 1, 2, 3, 4, 5),
ownerId: "user1"
);
final fileItem1 = AlbumFileItem(
file: file1,
addedBy: "admin".toCi(),
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 5),
);
final albumRepo = MockAlbumMemoryRepo([
Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(
items: [fileItem1],
latestItemTime: file1.lastModified,
),
coverProvider: AlbumAutoCoverProvider(coverFile: file1),
sortProvider: const AlbumNullSortProvider(),
albumFile: albumFile,
),
]);
final shareRepo = MockShareMemoryRepo(); final shareRepo = MockShareMemoryRepo();
await ShareAlbumWithUser(shareRepo, albumRepo)( await ShareAlbumWithUser(shareRepo, albumRepo)(
@ -157,7 +99,7 @@ Future<void> _shareWithFileOwnedByUser() async {
); );
expect( expect(
albumRepo.findAlbumByPath(albumFile.path).shares, albumRepo.findAlbumByPath(albumFile.path).shares,
[AlbumShare(userId: "user1".toCi())], [test_util.buildAlbumShare(userId: "user1")],
); );
expect( expect(
shareRepo.shares, shareRepo.shares,
@ -173,21 +115,9 @@ Future<void> _shareWithFileOwnedByUser() async {
/// a new share (admin -> user2) is created for the album json /// a new share (admin -> user2) is created for the album json
Future<void> _shareSharedAlbum() async { Future<void> _shareSharedAlbum() async {
final account = test_util.buildAccount(); final account = test_util.buildAccount();
final albumFile = test_util.buildAlbumFile( final album = (test_util.AlbumBuilder()..addShare("user1")).build();
path: test_util.buildAlbumFilePath("test1.json"), final albumFile = album.albumFile!;
fileId: 0, final albumRepo = MockAlbumMemoryRepo([album]);
);
final albumRepo = MockAlbumMemoryRepo([
Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(items: []),
coverProvider: AlbumAutoCoverProvider(),
sortProvider: const AlbumNullSortProvider(),
shares: [AlbumShare(userId: "user1".toCi())],
albumFile: albumFile,
),
]);
final shareRepo = MockShareMemoryRepo([ final shareRepo = MockShareMemoryRepo([
test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"), test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"),
]); ]);
@ -200,8 +130,8 @@ Future<void> _shareSharedAlbum() async {
expect( expect(
albumRepo.findAlbumByPath(albumFile.path).shares, albumRepo.findAlbumByPath(albumFile.path).shares,
[ [
AlbumShare(userId: "user1".toCi()), test_util.buildAlbumShare(userId: "user1"),
AlbumShare(userId: "user2".toCi()), test_util.buildAlbumShare(userId: "user2"),
], ],
); );
expect( expect(

147
test/use_case/unshare_album_with_user_test.dart
View file

@ -1,11 +1,6 @@
import 'package:event_bus/event_bus.dart'; import 'package:event_bus/event_bus.dart';
import 'package:kiwi/kiwi.dart'; import 'package:kiwi/kiwi.dart';
import 'package:nc_photos/ci_string.dart'; import 'package:nc_photos/ci_string.dart';
import 'package:nc_photos/entity/album.dart';
import 'package:nc_photos/entity/album/cover_provider.dart';
import 'package:nc_photos/entity/album/item.dart';
import 'package:nc_photos/entity/album/provider.dart';
import 'package:nc_photos/entity/album/sort_provider.dart';
import 'package:nc_photos/use_case/unshare_album_with_user.dart'; import 'package:nc_photos/use_case/unshare_album_with_user.dart';
import 'package:test/test.dart'; import 'package:test/test.dart';
@ -28,24 +23,12 @@ void main() {
/// share (admin -> user1) for the album json deleted /// share (admin -> user1) for the album json deleted
Future<void> _unshareWithoutFile() async { Future<void> _unshareWithoutFile() async {
final account = test_util.buildAccount(); final account = test_util.buildAccount();
final albumFile = test_util.buildAlbumFile( final album = (test_util.AlbumBuilder()
path: test_util.buildAlbumFilePath("test1.json"), ..addShare("user1")
fileId: 0, ..addShare("user2"))
); .build();
final albumRepo = MockAlbumMemoryRepo([ final albumFile = album.albumFile!;
Album( final albumRepo = MockAlbumMemoryRepo([album]);
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(items: []),
coverProvider: AlbumAutoCoverProvider(),
sortProvider: const AlbumNullSortProvider(),
shares: [
AlbumShare(userId: "user1".toCi()),
AlbumShare(userId: "user2".toCi()),
],
albumFile: albumFile,
),
]);
final fileRepo = MockFileMemoryRepo([albumFile]); final fileRepo = MockFileMemoryRepo([albumFile]);
final shareRepo = MockShareMemoryRepo([ final shareRepo = MockShareMemoryRepo([
test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"), test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"),
@ -55,7 +38,7 @@ Future<void> _unshareWithoutFile() async {
await UnshareAlbumWithUser(shareRepo, fileRepo, albumRepo)( await UnshareAlbumWithUser(shareRepo, fileRepo, albumRepo)(
account, albumRepo.findAlbumByPath(albumFile.path), "user1".toCi()); account, albumRepo.findAlbumByPath(albumFile.path), "user1".toCi());
expect(albumRepo.findAlbumByPath(albumFile.path).shares, expect(albumRepo.findAlbumByPath(albumFile.path).shares,
[AlbumShare(userId: "user2".toCi())]); [test_util.buildAlbumShare(userId: "user2")]);
expect( expect(
shareRepo.shares, shareRepo.shares,
[test_util.buildShare(id: "1", file: albumFile, shareWith: "user2")], [test_util.buildShare(id: "1", file: albumFile, shareWith: "user2")],
@ -69,37 +52,17 @@ Future<void> _unshareWithoutFile() async {
/// shares (admin -> user1) for the album files deleted /// shares (admin -> user1) for the album files deleted
Future<void> _unshareWithFile() async { Future<void> _unshareWithFile() async {
final account = test_util.buildAccount(); final account = test_util.buildAccount();
final albumFile = test_util.buildAlbumFile( final files = (test_util.FilesBuilder(initialFileId: 1)
path: test_util.buildAlbumFilePath("test1.json"), ..addJpeg("admin/test1.jpg"))
fileId: 0, .build();
); final album = (test_util.AlbumBuilder()
final file1 = test_util.buildJpegFile( ..addFileItem(files[0])
path: "remote.php/dav/files/admin/test1.jpg", ..addShare("user1")
fileId: 1, ..addShare("user2"))
lastModified: DateTime.utc(2020, 1, 2, 3, 4, 5), .build();
); final file1 = files[0];
final fileItem1 = AlbumFileItem( final albumFile = album.albumFile!;
file: file1, final albumRepo = MockAlbumMemoryRepo([album]);
addedBy: "admin".toCi(),
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 5),
);
final albumRepo = MockAlbumMemoryRepo([
Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(
items: [fileItem1],
latestItemTime: file1.lastModified,
),
coverProvider: AlbumAutoCoverProvider(coverFile: file1),
sortProvider: const AlbumNullSortProvider(),
shares: [
AlbumShare(userId: "user1".toCi()),
AlbumShare(userId: "user2".toCi()),
],
albumFile: albumFile,
),
]);
final fileRepo = MockFileMemoryRepo([albumFile, file1]); final fileRepo = MockFileMemoryRepo([albumFile, file1]);
final shareRepo = MockShareMemoryRepo([ final shareRepo = MockShareMemoryRepo([
test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"), test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"),
@ -111,7 +74,7 @@ Future<void> _unshareWithFile() async {
await UnshareAlbumWithUser(shareRepo, fileRepo, albumRepo)( await UnshareAlbumWithUser(shareRepo, fileRepo, albumRepo)(
account, albumRepo.findAlbumByPath(albumFile.path), "user1".toCi()); account, albumRepo.findAlbumByPath(albumFile.path), "user1".toCi());
expect(albumRepo.findAlbumByPath(albumFile.path).shares, expect(albumRepo.findAlbumByPath(albumFile.path).shares,
[AlbumShare(userId: "user2".toCi())]); [test_util.buildAlbumShare(userId: "user2")]);
expect( expect(
shareRepo.shares, shareRepo.shares,
[ [
@ -130,73 +93,43 @@ Future<void> _unshareWithFile() async {
/// shares (user2 -> user1) created by other unchanged /// shares (user2 -> user1) created by other unchanged
Future<void> _unshareWithFileNotOwned() async { Future<void> _unshareWithFileNotOwned() async {
final account = test_util.buildAccount(); final account = test_util.buildAccount();
final albumFile = test_util.buildAlbumFile( final files = (test_util.FilesBuilder(initialFileId: 1)
path: test_util.buildAlbumFilePath("test1.json"), ..addJpeg("admin/test1.jpg")
fileId: 0, ..addJpeg("user2/test2.jpg", ownerId: "user2"))
); .build();
final file1 = test_util.buildJpegFile( final album = (test_util.AlbumBuilder()
path: "remote.php/dav/files/admin/test1.jpg", ..addFileItem(files[0])
fileId: 1, ..addFileItem(files[1], addedBy: "user2")
lastModified: DateTime.utc(2020, 1, 2, 3, 4, 5), ..addShare("user1")
); ..addShare("user2"))
final fileItem1 = AlbumFileItem( .build();
file: file1, final albumFile = album.albumFile!;
addedBy: "admin".toCi(), final albumRepo = MockAlbumMemoryRepo([album]);
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 5), final fileRepo = MockFileMemoryRepo([albumFile, files[0]]);
);
final file2 = test_util.buildJpegFile(
path: "remote.php/dav/files/user2/test2.jpg",
fileId: 2,
lastModified: DateTime.utc(2020, 1, 2, 3, 4, 6),
ownerId: "user2",
);
final fileItem2 = AlbumFileItem(
file: file2,
addedBy: "user2".toCi(),
addedAt: DateTime.utc(2020, 1, 2, 3, 4, 6),
);
final albumRepo = MockAlbumMemoryRepo([
Album(
lastUpdated: DateTime.utc(2020, 1, 2, 3, 4, 5),
name: "test",
provider: AlbumStaticProvider(
items: [fileItem1, fileItem2],
latestItemTime: file2.lastModified,
),
coverProvider: AlbumAutoCoverProvider(coverFile: file2),
sortProvider: const AlbumNullSortProvider(),
shares: [
AlbumShare(userId: "user1".toCi()),
AlbumShare(userId: "user2".toCi()),
],
albumFile: albumFile,
),
]);
final fileRepo = MockFileMemoryRepo([albumFile, file1]);
final shareRepo = MockShareMemoryRepo([ final shareRepo = MockShareMemoryRepo([
test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"), test_util.buildShare(id: "0", file: albumFile, shareWith: "user1"),
test_util.buildShare(id: "1", file: albumFile, shareWith: "user2"), test_util.buildShare(id: "1", file: albumFile, shareWith: "user2"),
test_util.buildShare(id: "2", file: file1, shareWith: "user1"), test_util.buildShare(id: "2", file: files[0], shareWith: "user1"),
test_util.buildShare(id: "3", file: file1, shareWith: "user2"), test_util.buildShare(id: "3", file: files[0], shareWith: "user2"),
test_util.buildShare( test_util.buildShare(
id: "4", uidOwner: "user2", file: file2, shareWith: "admin"), id: "4", uidOwner: "user2", file: files[1], shareWith: "admin"),
test_util.buildShare( test_util.buildShare(
id: "5", uidOwner: "user2", file: file2, shareWith: "user1"), id: "5", uidOwner: "user2", file: files[1], shareWith: "user1"),
]); ]);
await UnshareAlbumWithUser(shareRepo, fileRepo, albumRepo)( await UnshareAlbumWithUser(shareRepo, fileRepo, albumRepo)(
account, albumRepo.findAlbumByPath(albumFile.path), "user1".toCi()); account, albumRepo.findAlbumByPath(albumFile.path), "user1".toCi());
expect(albumRepo.findAlbumByPath(albumFile.path).shares, expect(albumRepo.findAlbumByPath(albumFile.path).shares,
[AlbumShare(userId: "user2".toCi())]); [test_util.buildAlbumShare(userId: "user2")]);
expect( expect(
shareRepo.shares, shareRepo.shares,
[ [
test_util.buildShare(id: "1", file: albumFile, shareWith: "user2"), test_util.buildShare(id: "1", file: albumFile, shareWith: "user2"),
test_util.buildShare(id: "3", file: file1, shareWith: "user2"), test_util.buildShare(id: "3", file: files[0], shareWith: "user2"),
test_util.buildShare( test_util.buildShare(
id: "4", uidOwner: "user2", file: file2, shareWith: "admin"), id: "4", uidOwner: "user2", file: files[1], shareWith: "admin"),
test_util.buildShare( test_util.buildShare(
id: "5", uidOwner: "user2", file: file2, shareWith: "user1"), id: "5", uidOwner: "user2", file: files[1], shareWith: "user1"),
], ],
); );
} }