forked from eatvio/eatvio_app
406 lines
16 KiB
Dart
406 lines
16 KiB
Dart
import 'package:eatvio_app/core/models/pagination_model.dart';
|
|
import 'package:eatvio_app/features/feed/models/comment_model.dart';
|
|
import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
|
|
import 'package:eatvio_app/features/feed/models/feed_blog_post_model.dart';
|
|
import 'package:eatvio_app/features/feed/models/feed_blog_post_settings_model.dart';
|
|
import 'package:eatvio_app/features/feed/models/feed_consultant_model.dart';
|
|
import 'package:eatvio_app/features/feed/models/plan_pagination_model.dart';
|
|
import 'package:eatvio_app/features/feed/models/recipes_model.dart';
|
|
import 'package:eatvio_app/features/feed/models/recipes_pagination_model.dart';
|
|
import 'package:eatvio_app/features/feed/models/view_model.dart';
|
|
import 'package:eatvio_app/features/feed/services/feed_service.dart';
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:mockito/annotations.dart';
|
|
import 'package:mockito/mockito.dart';
|
|
|
|
import '../../../fixtures/feed_fixtures.dart';
|
|
import 'feed_service_test.mocks.dart';
|
|
|
|
@GenerateNiceMocks([MockSpec<FeedService>()])
|
|
void main() {
|
|
group('FeedService', () {
|
|
late MockFeedService mockFeedService;
|
|
|
|
setUp(() {
|
|
mockFeedService = MockFeedService();
|
|
});
|
|
|
|
test('getBlogPostList returns settings', () async {
|
|
const page = 1;
|
|
final expected = FeedBlogPostSettingsModel(
|
|
feedBlogPostList: [
|
|
FeedBlogPostModel(
|
|
id: 1,
|
|
title: 'Post Title',
|
|
description: 'Test post description',
|
|
image: 'https://someurl.com/img.jpg',
|
|
state: 'published',
|
|
author: const Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
|
|
videoUrl: 'https://someurl.com/video.mp4',
|
|
createdAt: DateTime.now(),
|
|
updatedAt: DateTime.now(),
|
|
totalLikes: 5,
|
|
totalViews: 10,
|
|
totalComments: 2,
|
|
wasLikedByMe: false,
|
|
),
|
|
],
|
|
meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
|
|
);
|
|
|
|
when(mockFeedService.getBlogPostList(page: page, query: null)).thenAnswer((_) async => expected);
|
|
|
|
final result = await mockFeedService.getBlogPostList(page: page, query: null);
|
|
|
|
expect(result, isA<FeedBlogPostSettingsModel>());
|
|
verify(mockFeedService.getBlogPostList(page: page, query: null)).called(1);
|
|
});
|
|
|
|
test('getFeed returns cursor response', () async {
|
|
final expected = FeedFixtures.postFeedPaginationModel();
|
|
|
|
when(mockFeedService.getFeed(search: null, cursor: null)).thenAnswer((_) async => expected);
|
|
|
|
final result = await mockFeedService.getFeed(search: null, cursor: null);
|
|
|
|
expect(result.data, hasLength(3));
|
|
expect(result.meta.perPage, 20);
|
|
expect(result.meta.nextCursor, 'eyJpZCI6MTAzfQ');
|
|
verify(mockFeedService.getFeed(search: null, cursor: null)).called(1);
|
|
});
|
|
|
|
test('getFeed returns next page without cursor', () async {
|
|
const cursor = 'eyJpZCI6MTAzfQ';
|
|
final expected = FeedFixtures.postFeedNextPagePaginationModel();
|
|
|
|
when(mockFeedService.getFeed(search: null, cursor: cursor)).thenAnswer((_) async => expected);
|
|
|
|
final result = await mockFeedService.getFeed(search: null, cursor: cursor);
|
|
|
|
expect(result.data, hasLength(1));
|
|
expect(result.meta.nextCursor, isNull);
|
|
verify(mockFeedService.getFeed(search: null, cursor: cursor)).called(1);
|
|
});
|
|
|
|
test('getBlogPost returns post', () async {
|
|
const id = 10;
|
|
final expected = FeedBlogPostModel(
|
|
id: id,
|
|
title: 'Test',
|
|
description: 'Test post description',
|
|
image: 'https://someurl.com/img.jpg',
|
|
state: 'published',
|
|
author: const Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
|
|
videoUrl: 'https://someurl.com/video.mp4',
|
|
createdAt: DateTime.now(),
|
|
updatedAt: DateTime.now(),
|
|
totalLikes: 3,
|
|
totalViews: 14,
|
|
totalComments: 1,
|
|
wasLikedByMe: false,
|
|
);
|
|
|
|
when(mockFeedService.getBlogPost(postId: id)).thenAnswer((_) async => expected);
|
|
|
|
final result = await mockFeedService.getBlogPost(postId: id);
|
|
|
|
expect(result.id, id);
|
|
verify(mockFeedService.getBlogPost(postId: id)).called(1);
|
|
});
|
|
|
|
test('getRecipes returns recipes pagination', () async {
|
|
final expected = RecipesPagination(
|
|
recipesList: [
|
|
Recipe(
|
|
id: 1,
|
|
image: 'https://someurl.com/img.jpg',
|
|
state: 'published',
|
|
cookingTime: 30,
|
|
activeCookingTime: 20,
|
|
ingredients: [const Ingredient(name: 'ingredient1', unit: 'unit1', portion: 'portion1', productId: 1)],
|
|
description: 'Test post description',
|
|
steps: [const Step(description: 'step1', image: 'https://someurl.com/img.jpg')],
|
|
videoUrl: 'https://someurl.com/video.mp4',
|
|
createdAt: DateTime.now(),
|
|
updatedAt: DateTime.now(),
|
|
title: 'Test',
|
|
type: 'recipe',
|
|
slug: 'test-recipe',
|
|
commentsCount: 1,
|
|
wasLikedByMe: false,
|
|
isFavorite: false,
|
|
calories: 100,
|
|
servings: 1,
|
|
likesCount: 3,
|
|
viewsCount: 14,
|
|
tags: [const Tag(name: '1')],
|
|
author: const Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
|
|
),
|
|
],
|
|
);
|
|
|
|
when(mockFeedService.getRecipes(page: 1, tags: [1], query: null)).thenAnswer((_) async => expected);
|
|
|
|
await mockFeedService.getRecipes(page: 1, tags: [1], query: null);
|
|
|
|
verify(mockFeedService.getRecipes(page: 1, tags: [1], query: null)).called(1);
|
|
});
|
|
|
|
test('getDiets returns pagination', () async {
|
|
const expected = DietsPagination(
|
|
data: [
|
|
Diet(
|
|
id: 1,
|
|
slug: 'test-diet',
|
|
name: 'Test Diet',
|
|
image: 'https://someurl.com/img.jpg',
|
|
duration: 30,
|
|
state: DietState.active,
|
|
type: DietType(light: false, veg: false, carb: false, meat: false),
|
|
details: 'Test diet description',
|
|
dailySchedule: {},
|
|
author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
|
|
totalLikes: 1,
|
|
totalViews: 1,
|
|
totalComments: 1,
|
|
wasLikedByMe: false,
|
|
isFavorite: false,
|
|
dailyNutrition: [],
|
|
),
|
|
],
|
|
links: Links(first: '', last: '', prev: null, next: null),
|
|
meta: Meta(currentPage: 1, lastPage: 1, total: 0, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
|
|
);
|
|
|
|
when(mockFeedService.getDiets(page: 1, query: null)).thenAnswer((_) async => expected);
|
|
|
|
await mockFeedService.getDiets(page: 1, query: null);
|
|
|
|
verify(mockFeedService.getDiets(page: 1, query: null)).called(1);
|
|
});
|
|
|
|
test('getPlans returns pagination', () async {
|
|
const expected = PlanPaginationModel(
|
|
data: [
|
|
PlanModel(
|
|
id: 1,
|
|
slug: 'test-plan',
|
|
name: 'Test Plan',
|
|
image: 'https://someurl.com/img.jpg',
|
|
duration: 30,
|
|
state: 'active',
|
|
type: PlanType(fit: false, slim: false, behavior: false, wellness: false),
|
|
details: '',
|
|
packetsCount: 1,
|
|
author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
|
|
totalLikes: 1,
|
|
totalViews: 1,
|
|
totalComments: 1,
|
|
isFavorite: false,
|
|
minPriceOfOptions: 100,
|
|
maxPriceOfOptions: 500,
|
|
wasLikedByMe: false,
|
|
),
|
|
],
|
|
links: Links(first: '', last: '', prev: null, next: null),
|
|
meta: Meta(currentPage: 1, lastPage: 1, total: 0, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
|
|
);
|
|
|
|
when(mockFeedService.getPlans(page: 1, query: null)).thenAnswer((_) async => expected);
|
|
|
|
await mockFeedService.getPlans(page: 1, query: null);
|
|
|
|
verify(mockFeedService.getPlans(page: 1, query: null)).called(1);
|
|
});
|
|
|
|
test('getBlogPostComments returns comments', () async {
|
|
const id = "1";
|
|
final expected = CommentModel(
|
|
data: [
|
|
Comment(
|
|
id: 1,
|
|
authorName: 'user1',
|
|
authorSlug: '',
|
|
authorProfileIcon: '',
|
|
body: 'Nice',
|
|
childrenComments: [
|
|
Comment(id: 2, authorName: 'user2', authorSlug: '', authorProfileIcon: '', body: 'Great', childrenComments: [], createdAt: DateTime.now()),
|
|
],
|
|
createdAt: DateTime.now(),
|
|
),
|
|
],
|
|
links: const Links(first: '', last: '', prev: null, next: null),
|
|
meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
|
|
);
|
|
|
|
when(mockFeedService.getBlogPostComments(id: id)).thenAnswer((_) async => expected);
|
|
|
|
await mockFeedService.getBlogPostComments(id: id);
|
|
|
|
verify(mockFeedService.getBlogPostComments(id: id)).called(1);
|
|
});
|
|
|
|
test('sendBlogPostComment sends comment', () async {
|
|
when(mockFeedService.sendBlogPostComment(id: "1", body: "Great", parentCommentId: null)).thenAnswer((_) async => Future.value());
|
|
|
|
await mockFeedService.sendBlogPostComment(id: "1", body: "Great", parentCommentId: null);
|
|
|
|
verify(mockFeedService.sendBlogPostComment(id: "1", body: "Great", parentCommentId: null)).called(1);
|
|
});
|
|
|
|
test('getDietsComments returns comments', () async {
|
|
const id = "5";
|
|
final expected = CommentModel(
|
|
data: [Comment(id: 2, authorName: 'user2', authorSlug: '', authorProfileIcon: '', body: 'Cool diet!', childrenComments: [], createdAt: DateTime.now())],
|
|
links: const Links(first: '', last: '', prev: null, next: null),
|
|
meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
|
|
);
|
|
|
|
when(mockFeedService.getDietsComments(id: id)).thenAnswer((_) async => expected);
|
|
|
|
await mockFeedService.getDietsComments(id: id);
|
|
|
|
verify(mockFeedService.getDietsComments(id: id)).called(1);
|
|
});
|
|
|
|
test('sendDietsComment sends comment', () async {
|
|
when(mockFeedService.sendDietsComment(id: "5", body: "Nice diet", parentCommentId: null)).thenAnswer((_) async => Future.value());
|
|
|
|
await mockFeedService.sendDietsComment(id: "5", body: "Nice diet", parentCommentId: null);
|
|
|
|
verify(mockFeedService.sendDietsComment(id: "5", body: "Nice diet", parentCommentId: null)).called(1);
|
|
});
|
|
|
|
test('getPlansComments returns comments', () async {
|
|
const slug = "plan-1";
|
|
final expected = CommentModel(
|
|
data: [
|
|
Comment(id: 3, authorName: 'user3', authorSlug: '', authorProfileIcon: '', body: 'Super plan!', childrenComments: [], createdAt: DateTime.now()),
|
|
],
|
|
links: const Links(first: '', last: '', prev: null, next: null),
|
|
meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
|
|
);
|
|
|
|
when(mockFeedService.getPlansComments(slug: slug)).thenAnswer((_) async => expected);
|
|
|
|
await mockFeedService.getPlansComments(slug: slug);
|
|
|
|
verify(mockFeedService.getPlansComments(slug: slug)).called(1);
|
|
});
|
|
|
|
test('sendPlansComment sends comment', () async {
|
|
when(mockFeedService.sendPlansComment(slug: "plan-1", body: "Ok", parentCommentId: null)).thenAnswer((_) async => Future.value());
|
|
|
|
await mockFeedService.sendPlansComment(slug: "plan-1", body: "Ok", parentCommentId: null);
|
|
|
|
verify(mockFeedService.sendPlansComment(slug: "plan-1", body: "Ok", parentCommentId: null)).called(1);
|
|
});
|
|
|
|
test('getRecipesComments returns comments', () async {
|
|
const id = "33";
|
|
final expected = CommentModel(
|
|
data: [
|
|
Comment(id: 4, authorName: 'user4', authorSlug: '', authorProfileIcon: '', body: 'Looks tasty!', childrenComments: [], createdAt: DateTime.now()),
|
|
],
|
|
links: const Links(first: '', last: '', prev: null, next: null),
|
|
meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
|
|
);
|
|
|
|
when(mockFeedService.getRecipesComments(id: id)).thenAnswer((_) async => expected);
|
|
|
|
await mockFeedService.getRecipesComments(id: id);
|
|
|
|
verify(mockFeedService.getRecipesComments(id: id)).called(1);
|
|
});
|
|
|
|
test('sendRecipesComment sends comment', () async {
|
|
when(mockFeedService.sendRecipesComment(id: "33", body: "Tasty", parentCommentId: null)).thenAnswer((_) async => Future.value());
|
|
|
|
await mockFeedService.sendRecipesComment(id: "33", body: "Tasty", parentCommentId: null);
|
|
|
|
verify(mockFeedService.sendRecipesComment(id: "33", body: "Tasty", parentCommentId: null)).called(1);
|
|
});
|
|
|
|
test('likeBlogPost works', () async {
|
|
when(mockFeedService.likeBlogPost(id: 1)).thenAnswer((_) async => Future.value());
|
|
|
|
await mockFeedService.likeBlogPost(id: 1);
|
|
|
|
verify(mockFeedService.likeBlogPost(id: 1)).called(1);
|
|
});
|
|
|
|
test('unlikedBlogPost works', () async {
|
|
when(mockFeedService.unlikedBlogPost(id: 1)).thenAnswer((_) async => Future.value());
|
|
|
|
await mockFeedService.unlikedBlogPost(id: 1);
|
|
|
|
verify(mockFeedService.unlikedBlogPost(id: 1)).called(1);
|
|
});
|
|
|
|
test('getConsultants returns consultant pagination', () async {
|
|
const expected = FeedConsultantPaginationModel(
|
|
data: [
|
|
FeedConsultantModel(
|
|
slug: 'consultant-1',
|
|
name: 'Anna Ivanova',
|
|
description: 'Test consultant description',
|
|
totalScores: 5,
|
|
photo: 'https://someurl.com/consultant1.jpg',
|
|
badges: [],
|
|
),
|
|
],
|
|
links: Links(first: '', last: '', prev: null, next: null),
|
|
meta: Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
|
|
);
|
|
|
|
when(mockFeedService.getConsultants(name: 'Anna')).thenAnswer((_) async => expected);
|
|
|
|
await mockFeedService.getConsultants(name: 'Anna');
|
|
|
|
verify(mockFeedService.getConsultants(name: 'Anna')).called(1);
|
|
});
|
|
|
|
test('viewPost works', () async {
|
|
when(mockFeedService.viewPost(id: 1)).thenAnswer((_) async => Future.value());
|
|
|
|
await mockFeedService.viewPost(id: 1);
|
|
|
|
verify(mockFeedService.viewPost(id: 1)).called(1);
|
|
});
|
|
|
|
test('viewRecipe works', () async {
|
|
when(mockFeedService.viewRecipe(slug: 'abc')).thenAnswer((_) async => Future.value());
|
|
|
|
await mockFeedService.viewRecipe(slug: 'abc');
|
|
|
|
verify(mockFeedService.viewRecipe(slug: 'abc')).called(1);
|
|
});
|
|
|
|
test('viewDiet works', () async {
|
|
when(mockFeedService.viewDiet(id: 2)).thenAnswer((_) async => Future.value());
|
|
|
|
await mockFeedService.viewDiet(id: 2);
|
|
|
|
verify(mockFeedService.viewDiet(id: 2)).called(1);
|
|
});
|
|
|
|
test('viewPlan works', () async {
|
|
when(mockFeedService.viewPlan(slug: 'plan-7')).thenAnswer((_) async => Future.value());
|
|
|
|
await mockFeedService.viewPlan(slug: 'plan-7');
|
|
|
|
verify(mockFeedService.viewPlan(slug: 'plan-7')).called(1);
|
|
});
|
|
|
|
test('viewContent sends view model', () async {
|
|
final view = ViewModel(type: 'recipe', slugs: ['recipe-1']);
|
|
|
|
when(mockFeedService.viewContent(viewModel: view)).thenAnswer((_) async => Future.value());
|
|
|
|
await mockFeedService.viewContent(viewModel: view);
|
|
|
|
verify(mockFeedService.viewContent(viewModel: view)).called(1);
|
|
});
|
|
});
|
|
}
|