julian/lunchpick
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 초기 프로젝트 설정 및 LunchPick 앱 구현

Browse Source 
LunchPick(오늘 뭐 먹Z?) Flutter 앱의 초기 구현입니다.

주요 기능:
- 네이버 지도 연동 맛집 추가
- 랜덤 메뉴 추천 시스템
- 날씨 기반 거리 조정
- 방문 기록 관리
- Bluetooth 맛집 공유
- 다크모드 지원

기술 스택:
- Flutter 3.8.1+
- Riverpod 상태 관리
- Hive 로컬 DB
- Clean Architecture

🤖 Generated with Claude Code

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
JiWoong Sul
2025-07-30 19:03:28 +09:00
commit 85fde36157
237 changed files with 30953 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

226
test/unit/data/datasources/remote/naver_map_parser_test.dart Normal file
View File

@@ -0,0 +1,226 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:lunchpick/data/datasources/remote/naver_map_parser.dart';
import 'package:lunchpick/domain/entities/restaurant.dart';
import 'package:lunchpick/data/api/naver/naver_local_search_api.dart';
import 'package:lunchpick/core/errors/network_exceptions.dart';
import '../../../../mocks/mock_naver_api_client.dart';
void main() {
late NaverMapParser parser;
late MockNaverApiClient mockApiClient;
setUp(() {
mockApiClient = MockNaverApiClient();
parser = NaverMapParser(apiClient: mockApiClient);
});
tearDown(() {
parser.dispose();
});
group('NaverMapParser', () {
group('URL 유효성 검증', () {
test('유효한 네이버 지도 URL을 인식해야 함', () async {
final validUrls = [
'https://map.naver.com/p/restaurant/1234567890',
'https://naver.me/abcdefgh',
'https://map.naver.com/p/entry/place/1234567890',
];
for (final url in validUrls) {
mockApiClient.setUrlRedirect(url, 'https://map.naver.com/p/restaurant/1234567890');
// 검색 API 응답 설정
mockApiClient.setSearchResults(
'https://map.naver.com/p/entry/place/1234567890',
[
NaverLocalSearchResult.fromJson({
'title': '테스트 식당',
'link': 'https://map.naver.com/p/restaurant/1234567890',
'category': '한식',
'description': '테스트 설명',
'telephone': '02-1234-5678',
'address': '서울 강남구 테스트동 123-45',
'roadAddress': '서울 강남구 테스트로 123',
'mapx': 1269780000,
'mapy': 375665000,
}),
],
);
final result = await parser.parseRestaurantFromUrl(url);
expect(result, isA<Restaurant>(), reason: 'URL: $url');
expect(result.name, '테스트 식당', reason: 'URL: $url');
}
});
test('잘못된 URL은 예외를 던져야 함', () async {
final invalidUrls = [
'https://www.google.com',
'https://map.kakao.com',
'https://naver.com',
'not-a-url',
'',
];
for (final url in invalidUrls) {
expect(
() => parser.parseRestaurantFromUrl(url),
throwsA(isA<NaverMapParseException>()),
reason: 'URL: $url should throw exception',
);
}
});
});
group('API 응답 처리', () {
test('검색 API로 식당 정보를 이지해야 함', () async {
const url = 'https://map.naver.com/p/restaurant/1234567890';
mockApiClient.setUrlRedirect(url, url);
// 검색 API 응답 설정
mockApiClient.setSearchResults(
'https://map.naver.com/p/entry/place/1234567890',
[
NaverLocalSearchResult.fromJson({
'title': '맛있는 한식당',
'link': 'https://map.naver.com/p/restaurant/1234567890',
'category': '한식>고기요리',
'description': '평일 11:00 - 22:00, 주말 10:00 - 23:00',
'telephone': '02-123-4567',
'address': '서울 강남구 역삼동 123-45',
'roadAddress': '서울 강남구 테헤란로 123',
'mapx': 1270396000,
'mapy': 375012000,
}),
],
);
final result = await parser.parseRestaurantFromUrl(url);
expect(result, isA<Restaurant>());
expect(result.name, '맛있는 한식당');
expect(result.category, '한식');
expect(result.description, contains('평일 11:00 - 22:00'));
expect(result.phoneNumber, '02-123-4567');
expect(result.roadAddress, '서울 강남구 테헤란로 123');
expect(result.latitude, closeTo(37.5012, 0.0001));
expect(result.longitude, closeTo(127.0396, 0.0001));
});
test('GraphQL API로 식당 정보를 가져와야 함', () async {
const url = 'https://map.naver.com/p/restaurant/9876543210';
mockApiClient.setUrlRedirect(url, url);
// GraphQL 응답 설정
mockApiClient.setGraphQLResponse({
'places': [{
'id': '9876543210',
'name': '메타태그 식당',
'category': '기타',
'description': '맛있는 음식점',
'address': '서울시 강남구',
'roadAddress': '서울시 강남구 테헤란로',
'phone': '02-987-6543',
'location': {
'lat': 37.5,
'lng': 127.0,
},
}],
});
final result = await parser.parseRestaurantFromUrl(url);
expect(result, isA<Restaurant>());
expect(result.name, '메타태그 식당');
expect(result.category, '기타');
});
test('필수 정보가 없으면 기본값을 사용해야 함', () async {
const url = 'https://map.naver.com/p/restaurant/1234567890';
mockApiClient.setUrlRedirect(url, url);
// 빈 GraphQL 응답
mockApiClient.setGraphQLResponse({});
// HTML 파싱도 실패하도록 설정
mockApiClient.setHtmlResponse(url, '<html></html>');
final result = await parser.parseRestaurantFromUrl(url);
// 기본값이 사용되어야 함
expect(result, isA<Restaurant>());
expect(result.name, contains('1234567890'));
expect(result.category, '음식점');
});
});
group('단축 URL 처리', () {
test('단축 URL을 실제 URL로 변환해야 함', () async {
const shortUrl = 'https://naver.me/abc123';
const actualUrl = 'https://map.naver.com/p/restaurant/1234567890';
mockApiClient.setUrlRedirect(shortUrl, actualUrl);
// 단축 URL용 한글 텍스트 추출 응답
mockApiClient.setKoreanTextsData('1234567890', {
'success': true,
'koreanTexts': ['리다이렉트 식당'],
'jsonLdName': '리다이렉트 식당',
'apolloStateName': null,
});
// 검색 API 응답 설정
mockApiClient.setSearchResults(
'리다이렉트 식당',
[
NaverLocalSearchResult.fromJson({
'title': '리다이렉트 식당',
'link': actualUrl,
'category': '카페',
'description': '',
'telephone': '',
'address': '서울 마포구',
'roadAddress': '서울 마포구 테스트로 100',
'mapx': 1268900000,
'mapy': 375200000,
}),
],
);
final result = await parser.parseRestaurantFromUrl(shortUrl);
expect(result, isA<Restaurant>());
expect(result.name, '리다이렉트 식당');
expect(result.category, '카페');
});
});
group('에러 처리', () {
test('네트워크 오류 시 예외를 던져야 함', () async {
const url = 'https://map.naver.com/p/restaurant/network-error';
mockApiClient.shouldThrowError = true;
mockApiClient.errorMessage = 'Network error';
expect(
() => parser.parseRestaurantFromUrl(url),
throwsException,
);
});
test('429 에러 시 적절한 예외를 던져야 함', () async {
const url = 'https://map.naver.com/p/restaurant/1234567890';
mockApiClient.setUrlRedirect(url, url);
// 429 에러 설정
mockApiClient.setThrow429Error();
expect(
() => parser.parseRestaurantFromUrl(url),
throwsA(isA<RateLimitException>()),
);
});
});
});
}

203
test/unit/data/datasources/remote/naver_parser_location_test.dart Normal file
View File

@@ -0,0 +1,203 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:lunchpick/data/datasources/remote/naver_map_parser.dart';
import 'package:lunchpick/data/api/naver_api_client.dart';
import 'package:lunchpick/data/api/naver/naver_local_search_api.dart';
import '../../../../mocks/mock_naver_api_client.dart';
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
group('NaverMapParser 위치 기반 필터링 테스트', () {
late NaverMapParser parser;
late MockNaverApiClient mockApiClient;
setUp(() {
mockApiClient = MockNaverApiClient();
parser = NaverMapParser(apiClient: mockApiClient);
});
test('사용자 위치가 제공되면 가장 가까운 식당을 선택해야 함', () async {
// Given
const url = 'https://naver.me/xtest1234';
const finalUrl = 'https://map.naver.com/p/restaurant/1234567890';
const placeId = '1234567890';
const placeName = '스타벅스';
const userLat = 37.5665;
const userLng = 126.9780;
// 단축 URL 리디렉션 설정
mockApiClient.setUrlRedirect(url, finalUrl);
// pcmap에서 장소명 추출 설정
mockApiClient.setPlaceName(placeId, placeName);
// 검색 결과 - 여러 개의 스타벅스
final searchResults = [
NaverLocalSearchResult(
title: '스타벅스 강남역점',
link: 'https://map.naver.com/p/restaurant/9999999999',
category: '카페>커피전문점',
description: '',
telephone: '02-1234-5678',
address: '서울특별시 강남구 강남대로 123',
roadAddress: '서울특별시 강남구 강남대로 123',
mapx: 1269780000, // 126.978 * 10000000
mapy: 375650000, // 37.565 * 10000000 (더 가까움)
),
NaverLocalSearchResult(
title: '스타벅스 시청점',
link: 'https://map.naver.com/p/restaurant/1234567890', // Place ID 일치
category: '카페>커피전문점',
description: '',
telephone: '02-2345-6789',
address: '서울특별시 중구 세종대로 110',
roadAddress: '서울특별시 중구 세종대로 110',
mapx: 1269784147, // 126.9784147 * 10000000
mapy: 375666805, // 37.5666805 * 10000000 (정확히 일치)
),
NaverLocalSearchResult(
title: '스타벅스 홍대입구점',
link: 'https://map.naver.com/p/restaurant/8888888888',
category: '카페>커피전문점',
description: '',
telephone: '02-3456-7890',
address: '서울특별시 마포구 양화로 123',
roadAddress: '서울특별시 마포구 양화로 123',
mapx: 1269250000, // 126.925 * 10000000
mapy: 375560000, // 37.556 * 10000000 (더 멈)
),
];
mockApiClient.setSearchResults(placeName, searchResults);
// When
final result = await parser.parseRestaurantFromUrl(
url,
userLatitude: userLat,
userLongitude: userLng,
);
// Then
expect(result.name, '스타벅스 시청점');
expect(result.naverPlaceId, placeId);
});
test('위치 정보가 없으면 첫 번째 결과를 사용해야 함', () async {
// Given
const url = 'https://naver.me/xtest1234';
const finalUrl = 'https://map.naver.com/p/restaurant/1234567890';
const placeId = '1234567890';
const placeName = '스타벅스';
// 단축 URL 리디렉션 설정
mockApiClient.setUrlRedirect(url, finalUrl);
// pcmap에서 장소명 추출 설정
mockApiClient.setPlaceName(placeId, placeName);
// 검색 결과
final searchResults = [
NaverLocalSearchResult(
title: '스타벅스 강남역점',
link: 'https://map.naver.com/p/restaurant/9999999999',
category: '카페>커피전문점',
description: '',
telephone: '02-1234-5678',
address: '서울특별시 강남구 강남대로 123',
roadAddress: '서울특별시 강남구 강남대로 123',
mapx: 1269780000,
mapy: 375650000,
),
];
mockApiClient.setSearchResults(placeName, searchResults);
// When
final result = await parser.parseRestaurantFromUrl(url);
// Then
expect(result.name, '스타벅스 강남역점');
});
test('HTML에서 첫 번째 한글 텍스트를 상호명으로 추출해야 함', () async {
// Given
const placeId = '1492377618';
const mockHtml = '''
<html>
<body>
<div><span class="GHAhO">카페 칼리스타 구로본점</span><span class="lnJFt">카페,디저트</span></div>
<div>영업시간: 09:00 - 22:00</div>
</body>
</html>
''';
// pcmap HTML 응답 설정
mockApiClient.setHtmlResponse('https://pcmap.place.naver.com/place/$placeId/home', mockHtml);
// 장소명 설정
mockApiClient.setPlaceName(placeId, '카페 칼리스타 구로본점');
// When
final placeName = await mockApiClient.fetchPlaceNameFromPcmap(placeId);
// Then
expect(placeName, '카페 칼리스타 구로본점');
});
test('거리 계산이 정확해야 함', () async {
// Given
const url = 'https://naver.me/xtest1234';
const finalUrl = 'https://map.naver.com/p/restaurant/1234567890';
const placeId = '1234567890';
const placeName = '테스트 식당';
// 서울시청 좌표
const userLat = 37.5666805;
const userLng = 126.9784147;
// 단축 URL 리디렉션 설정
mockApiClient.setUrlRedirect(url, finalUrl);
// pcmap에서 장소명 추출 설정
mockApiClient.setPlaceName(placeId, placeName);
// 검색 결과 - 거리가 다른 두 곳
final searchResults = [
NaverLocalSearchResult(
title: '테스트 식당 A점 (500m)',
link: 'https://map.naver.com/p/restaurant/1111111111',
category: '음식점',
description: '',
telephone: '',
address: '서울특별시',
roadAddress: '서울특별시',
mapx: 1269789000, // 약 500m 떨어진 곳
mapy: 375671000,
),
NaverLocalSearchResult(
title: '테스트 식당 B점 (1km)',
link: 'https://map.naver.com/p/restaurant/2222222222',
category: '음식점',
description: '',
telephone: '',
address: '서울특별시',
roadAddress: '서울특별시',
mapx: 1269873000, // 약 1km 떨어진 곳
mapy: 375676000,
),
];
mockApiClient.setSearchResults(placeName, searchResults);
// When
final result = await parser.parseRestaurantFromUrl(
url,
userLatitude: userLat,
userLongitude: userLng,
);
// Then - 더 가까운 A점이 선택되어야 함
expect(result.name.contains('A점'), true);
});
});
}

164
test/unit/data/datasources/remote/naver_parser_v2_test.dart Normal file
View File

@@ -0,0 +1,164 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:lunchpick/data/datasources/remote/naver_map_parser.dart';
import 'package:lunchpick/data/api/naver_api_client.dart';
import 'package:dio/dio.dart';
import 'package:lunchpick/core/errors/network_exceptions.dart';
import 'package:lunchpick/data/api/naver/naver_local_search_api.dart';
import '../../../../mocks/mock_naver_api_client.dart';
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
group('NaverMapParser V2 테스트 - 새로운 파싱 흐름', () {
late NaverMapParser parser;
late MockNaverApiClient mockApiClient;
setUp(() {
mockApiClient = MockNaverApiClient();
parser = NaverMapParser(apiClient: mockApiClient);
});
test('새로운 흐름: 단축 URL → 2차 리디렉션 → HTML → 두 번째 한글 추출', () async {
// Given
const url = 'https://naver.me/xtest1234';
const finalUrl = 'https://map.naver.com/p/restaurant/1234567890';
const placeId = '1234567890';
const placeName = '스타벅스 시청점'; // 두 번째 한글로 추출될 값
// 단축 URL 리디렉션 설정
mockApiClient.setUrlRedirect(url, finalUrl);
// 테스트용 메서드 추가 (실제로는 NaverApiClient에 구현)
mockApiClient.setFinalRedirectUrl(
'https://map.naver.com/p/entry/place/$placeId',
'https://pcmap.place.naver.com/place/$placeId/home'
);
mockApiClient.setSecondKoreanText(
'https://pcmap.place.naver.com/place/$placeId/home',
placeName
);
// 검색 결과 설정
final searchResults = [
NaverLocalSearchResult(
title: placeName,
link: 'https://map.naver.com/p/restaurant/$placeId',
category: '카페>커피전문점',
description: '',
telephone: '02-2345-6789',
address: '서울특별시 중구 세종대로 110',
roadAddress: '서울특별시 중구 세종대로 110',
mapx: 1269784147,
mapy: 375666805,
),
];
mockApiClient.setSearchResults(placeName, searchResults);
// When
final result = await parser.parseRestaurantFromUrl(url);
// Then
expect(result.name, placeName);
expect(result.naverPlaceId, placeId);
});
test('429 에러 발생 시 RateLimitException 발생', () async {
// Given
const url = 'https://naver.me/xtest1234';
const finalUrl = 'https://map.naver.com/p/restaurant/1234567890';
// 단축 URL 리디렉션은 성공
mockApiClient.setUrlRedirect(url, finalUrl);
// 429 에러 시뮬레이션
mockApiClient.shouldThrowError = true;
mockApiClient.errorMessage = '429 Too Many Requests';
mockApiClient.setThrow429Error();
// When & Then
expect(
() => parser.parseRestaurantFromUrl(url),
throwsA(isA<RateLimitException>()),
);
});
test('HTML에서 두 번째 한글 텍스트 추출 테스트', () async {
// Given
const html = '''
<html>
<body>
<div>네이버 플레이스</div>
<div>메뉴</div>
<div>카페 칼리스타 구로본점</div>
<div>영업시간: 09:00 - 22:00</div>
</body>
</html>
''';
// NaverApiClient의 private 메서드를 직접 테스트할 수 없으므로
// 전체 흐름으로 테스트
const placeId = '1234567890';
mockApiClient.setHtmlResponse(
'https://pcmap.place.naver.com/place/$placeId/home',
html
);
// extractSecondKoreanText 메서드 결과 설정
mockApiClient.setSecondKoreanText(
'https://pcmap.place.naver.com/place/$placeId/home',
'카페 칼리스타 구로본점' // 메뉴 다음의 두 번째 한글
);
// When
final result = await mockApiClient.extractSecondKoreanText(
'https://pcmap.place.naver.com/place/$placeId/home'
);
// Then
expect(result, '카페 칼리스타 구로본점');
});
test('각 단계별 지연 시간이 적용되는지 확인', () async {
// Given
const url = 'https://naver.me/xtest1234';
const finalUrl = 'https://map.naver.com/p/restaurant/1234567890';
const placeId = '1234567890';
const placeName = '테스트 식당';
// 모든 단계 설정
mockApiClient.setUrlRedirect(url, finalUrl);
mockApiClient.setFinalRedirectUrl(
'https://map.naver.com/p/entry/place/$placeId',
'https://pcmap.place.naver.com/place/$placeId/home'
);
mockApiClient.setSecondKoreanText(
'https://pcmap.place.naver.com/place/$placeId/home',
placeName
);
mockApiClient.setSearchResults(placeName, [
NaverLocalSearchResult(
title: placeName,
link: 'https://map.naver.com/p/restaurant/$placeId',
category: '한식',
description: '',
telephone: '',
address: '서울특별시',
roadAddress: '서울특별시',
mapx: 1269784147,
mapy: 375666805,
),
]);
// When
final stopwatch = Stopwatch()..start();
await parser.parseRestaurantFromUrl(url);
stopwatch.stop();
// Then - 최소 지연 시간 확인 (500ms * 3 = 1500ms 이상)
expect(stopwatch.elapsedMilliseconds, greaterThanOrEqualTo(1500));
});
});
}

576
test/unit/data/datasources/remote/naver_search_service_test.dart Normal file
View File

@@ -0,0 +1,576 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:lunchpick/data/datasources/remote/naver_search_service.dart';
import 'package:lunchpick/data/datasources/remote/naver_map_parser.dart';
import 'package:lunchpick/data/api/naver_api_client.dart';
import 'package:lunchpick/data/api/naver/naver_local_search_api.dart';
import 'package:lunchpick/domain/entities/restaurant.dart';
import 'package:lunchpick/core/errors/network_exceptions.dart';
// Mock 클래스들
class MockNaverApiClient extends NaverApiClient {
final Map<String, dynamic> _mockResponses = {};
final Map<String, Exception> _mockExceptions = {};
// Mock 설정 메서드들
void setSearchResponse({
required String query,
double? latitude,
double? longitude,
required List<NaverLocalSearchResult> results,
}) {
final key = _generateKey(query, latitude, longitude);
_mockResponses[key] = results;
}
void setSearchException({
required String query,
double? latitude,
double? longitude,
required Exception exception,
}) {
final key = _generateKey(query, latitude, longitude);
_mockExceptions[key] = exception;
}
String _generateKey(String query, double? latitude, double? longitude) {
return '$query-$latitude-$longitude';
}
// 호출 추적
final List<Map<String, dynamic>> callHistory = [];
bool disposeCalled = false;
@override
Future<List<NaverLocalSearchResult>> searchLocal({
required String query,
double? latitude,
double? longitude,
int display = 20,
int start = 1,
String sort = 'random',
}) async {
// 호출 기록
callHistory.add({
'query': query,
'latitude': latitude,
'longitude': longitude,
'display': display,
'sort': sort,
});
final key = _generateKey(query, latitude, longitude);
if (_mockExceptions.containsKey(key)) {
throw _mockExceptions[key]!;
}
if (_mockResponses.containsKey(key)) {
return _mockResponses[key] as List<NaverLocalSearchResult>;
}
return [];
}
@override
void dispose() {
disposeCalled = true;
}
}
class MockNaverMapParser extends NaverMapParser {
final Map<String, Restaurant> _mockResponses = {};
final Map<String, Exception> _mockExceptions = {};
void setParseResponse(String url, Restaurant restaurant) {
_mockResponses[url] = restaurant;
}
void setParseException(String url, Exception exception) {
_mockExceptions[url] = exception;
}
// 호출 추적
bool disposeCalled = false;
final List<String> parseCallHistory = [];
@override
Future<Restaurant> parseRestaurantFromUrl(
String url, {
double? userLatitude,
double? userLongitude,
}) async {
parseCallHistory.add(url);
if (_mockExceptions.containsKey(url)) {
throw _mockExceptions[url]!;
}
if (_mockResponses.containsKey(url)) {
return _mockResponses[url]!;
}
throw NaverMapParseException('No mock response set for URL: $url');
}
@override
void dispose() {
disposeCalled = true;
}
}
void main() {
late NaverSearchService service;
late MockNaverApiClient mockApiClient;
late MockNaverMapParser mockMapParser;
setUp(() {
mockApiClient = MockNaverApiClient();
mockMapParser = MockNaverMapParser();
service = NaverSearchService(
apiClient: mockApiClient,
mapParser: mockMapParser,
);
});
group('NaverSearchService', () {
group('getRestaurantFromUrl', () {
const testUrl = 'https://map.naver.com/p/restaurant/1234567890';
final testRestaurant = Restaurant(
id: '1',
name: 'Test Restaurant',
category: '한식',
subCategory: '백반',
roadAddress: '서울시 강남구 테헤란로 123',
jibunAddress: '서울시 강남구 역삼동 123-45',
latitude: 37.123456,
longitude: 127.123456,
source: DataSource.NAVER,
createdAt: DateTime.now(),
updatedAt: DateTime.now(),
);
test('URL에서 식당 정보를 성공적으로 가져온다', () async {
// Arrange
mockMapParser.setParseResponse(testUrl, testRestaurant);
// Act
final result = await service.getRestaurantFromUrl(testUrl);
// Assert
expect(result, equals(testRestaurant));
expect(mockMapParser.parseCallHistory, contains(testUrl));
});
test('NaverMapParseException을 그대로 전파한다', () async {
// Arrange
final exception = NaverMapParseException('파싱 실패');
mockMapParser.setParseException(testUrl, exception);
// Act & Assert
expect(
() async => await service.getRestaurantFromUrl(testUrl),
throwsA(isA<NaverMapParseException>()),
);
});
test('NetworkException을 그대로 전파한다', () async {
// Arrange
const exception = ServerException(message: '네트워크 오류', statusCode: 500);
mockMapParser.setParseException(testUrl, exception);
// Act & Assert
expect(
() async => await service.getRestaurantFromUrl(testUrl),
throwsA(isA<NetworkException>()),
);
});
test('일반 예외를 NetworkException으로 래핑한다', () async {
// Arrange
final exception = Exception('알 수 없는 오류');
mockMapParser.setParseException(testUrl, exception);
// Act & Assert
expect(
() async => await service.getRestaurantFromUrl(testUrl),
throwsA(
allOf(
isA<ParseException>(),
predicate<ParseException>((e) =>
e.message.contains('식당 정보를 가져올 수 없습니다') &&
e.originalError.toString() == exception.toString()
),
),
),
);
});
});
group('searchNearbyRestaurants', () {
const testQuery = '김치찌개';
const testLatitude = 37.123456;
const testLongitude = 127.123456;
final testSearchResults = [
NaverLocalSearchResult.fromJson({
'title': '김치찌개 맛집',
'category': '한식>찌개',
'description': '맛있는 김치찌개',
'telephone': '02-1234-5678',
'address': '서울시 강남구 역삼동',
'roadAddress': '서울시 강남구 테헤란로 123',
'mapx': 127123456,
'mapy': 37123456,
'link': 'https://map.naver.com/p/restaurant/1234567890',
}),
];
test('검색 결과를 Restaurant 리스트로 변환한다', () async {
// Arrange
mockApiClient.setSearchResponse(
query: testQuery,
latitude: testLatitude,
longitude: testLongitude,
results: testSearchResults,
);
// Act
final results = await service.searchNearbyRestaurants(
query: testQuery,
latitude: testLatitude,
longitude: testLongitude,
);
// Assert
expect(results.length, equals(1));
expect(results.first.name, equals('김치찌개 맛집'));
expect(results.first.category, equals('한식'));
expect(results.first.subCategory, equals('찌개'));
// API 호출 확인
expect(mockApiClient.callHistory.length, equals(1));
expect(mockApiClient.callHistory.first['query'], equals(testQuery));
expect(mockApiClient.callHistory.first['sort'], equals('random'));
});
test('빈 검색 결과를 처리한다', () async {
// Arrange
mockApiClient.setSearchResponse(
query: testQuery,
latitude: null,
longitude: null,
results: [],
);
// Act
final results = await service.searchNearbyRestaurants(query: testQuery);
// Assert
expect(results, isEmpty);
});
test('NetworkException을 그대로 전파한다', () async {
// Arrange
const exception = ServerException(message: '네트워크 오류', statusCode: 500);
mockApiClient.setSearchException(
query: testQuery,
latitude: null,
longitude: null,
exception: exception,
);
// Act & Assert
expect(
() async => await service.searchNearbyRestaurants(query: testQuery),
throwsA(isA<NetworkException>()),
);
});
test('일반 예외를 NetworkException으로 래핑한다', () async {
// Arrange
final exception = Exception('알 수 없는 오류');
mockApiClient.setSearchException(
query: testQuery,
latitude: null,
longitude: null,
exception: exception,
);
// Act & Assert
expect(
() async => await service.searchNearbyRestaurants(query: testQuery),
throwsA(
allOf(
isA<ParseException>(),
predicate<ParseException>((e) =>
e.message.contains('식당 검색에 실패했습니다') &&
e.originalError.toString() == exception.toString()
),
),
),
);
});
});
group('searchRestaurantDetails', () {
const testName = '김치찌개 맛집';
const testAddress = '서울시 강남구 역삼동';
const testLatitude = 37.123456;
const testLongitude = 127.123456;
final testSearchResults = [
NaverLocalSearchResult.fromJson({
'title': testName,
'category': '한식>찌개',
'description': '맛있는 김치찌개',
'telephone': '02-1234-5678',
'address': testAddress,
'roadAddress': '서울시 강남구 테헤란로 123',
'mapx': 127123456,
'mapy': 37123456,
'link': 'https://map.naver.com/p/restaurant/1234567890',
}),
];
test('정확히 일치하는 식당을 찾는다', () async {
// Arrange
mockApiClient.setSearchResponse(
query: '서울시 강남구 $testName',
latitude: testLatitude,
longitude: testLongitude,
results: testSearchResults,
);
// Act
final result = await service.searchRestaurantDetails(
name: testName,
address: testAddress,
latitude: testLatitude,
longitude: testLongitude,
);
// Assert
expect(result, isNotNull);
expect(result!.name, equals(testName));
});
test('검색 결과가 없으면 null을 반환한다', () async {
// Arrange
mockApiClient.setSearchResponse(
query: testName,
latitude: null,
longitude: null,
results: [],
);
// Act
final result = await service.searchRestaurantDetails(
name: testName,
);
// Assert
expect(result, isNull);
});
test('유사도가 낮은 결과는 null을 반환한다', () async {
// Arrange
final unmatchedResults = [
NaverLocalSearchResult.fromJson({
'title': '완전히 다른 식당',
'category': '양식',
'description': '파스타',
'telephone': '02-9999-9999',
'address': '서울시 종로구',
'roadAddress': '서울시 종로구 세종대로 99',
'mapx': 127999999,
'mapy': 37999999,
'link': 'https://map.naver.com/p/restaurant/9999999999',
}),
];
mockApiClient.setSearchResponse(
query: testName,
latitude: null,
longitude: null,
results: unmatchedResults,
);
// Act
final result = await service.searchRestaurantDetails(
name: testName,
);
// Assert
expect(result, isNull);
});
test('네이버 지도 URL이 있으면 상세 정보를 파싱한다', () async {
// Arrange
final detailedRestaurant = Restaurant(
id: '2',
name: testName,
category: '한식',
subCategory: '찌개',
description: '업데이트된 설명',
businessHours: '09:00 - 21:00',
naverPlaceId: '1234567890',
roadAddress: '서울시 강남구 테헤란로 123',
jibunAddress: '서울시 강남구 역삼동 123-45',
latitude: testLatitude,
longitude: testLongitude,
source: DataSource.NAVER,
createdAt: DateTime.now(),
updatedAt: DateTime.now(),
);
mockApiClient.setSearchResponse(
query: testName,
latitude: null,
longitude: null,
results: testSearchResults,
);
mockMapParser.setParseResponse(
'https://map.naver.com/p/restaurant/1234567890',
detailedRestaurant,
);
// Act
final result = await service.searchRestaurantDetails(name: testName);
// Assert
expect(result, isNotNull);
expect(result!.description, equals('업데이트된 설명'));
expect(result.businessHours, equals('09:00 - 21:00'));
expect(result.naverPlaceId, equals('1234567890'));
});
test('상세 파싱 실패해도 기본 정보를 반환한다', () async {
// Arrange
mockApiClient.setSearchResponse(
query: testName,
latitude: null,
longitude: null,
results: testSearchResults,
);
mockMapParser.setParseException(
'https://map.naver.com/p/restaurant/1234567890',
Exception('파싱 실패'),
);
// Act
final result = await service.searchRestaurantDetails(name: testName);
// Assert
expect(result, isNotNull);
expect(result!.name, equals(testName));
});
});
group('_findBestMatch', () {
test('정확히 일치하는 결과를 우선 반환한다', () {
// Arrange
const targetName = '김치찌개 맛집';
final results = [
NaverLocalSearchResult.fromJson({
'title': '다른 식당',
'category': '한식',
'description': '',
'telephone': '',
'address': '',
'roadAddress': '',
'mapx': 0,
'mapy': 0,
'link': '',
}),
NaverLocalSearchResult.fromJson({
'title': targetName,
'category': '한식',
'description': '',
'telephone': '',
'address': '',
'roadAddress': '',
'mapx': 0,
'mapy': 0,
'link': '',
}),
];
// Act
final result = service.findBestMatchForTesting(targetName, results);
// Assert
expect(result?.title, equals(targetName));
});
test('빈 리스트에서는 null을 반환한다', () {
// Act
final result = service.findBestMatchForTesting('test', []);
// Assert
expect(result, isNull);
});
});
group('_calculateSimilarity', () {
test('동일한 문자열은 1.0을 반환한다', () {
// Act
final similarity = service.calculateSimilarityForTesting('테스트', '테스트');
// Assert
expect(similarity, greaterThan(0.7));
});
test('포함 관계가 있으면 0.8을 반환한다', () {
// Act
final similarity = service.calculateSimilarityForTesting(
'김치찌개',
'김치찌개 맛집',
);
// Assert
expect(similarity, equals(0.8));
});
test('완전히 다른 문자열은 낮은 유사도를 반환한다', () {
// Act
final similarity = service.calculateSimilarityForTesting('한식', '양식');
// Assert
expect(similarity, lessThan(0.5));
});
test('빈 문자열은 0.0을 반환한다', () {
// Act
final similarity = service.calculateSimilarityForTesting('', 'test');
// Assert
expect(similarity, equals(0.0));
});
test('특수문자를 제거하고 비교한다', () {
// Act
final similarity = service.calculateSimilarityForTesting(
'김치찌개@#\$',
'김치찌개!!!',
);
// Assert
// 특수문자가 제거된 후 동일한 문자열이므로 0.8 이상이어야 함
expect(similarity, greaterThanOrEqualTo(0.8));
});
});
group('dispose', () {
test('dispose가 정상적으로 호출된다', () {
// Act
service.dispose();
// Assert
expect(mockApiClient.disposeCalled, isTrue);
expect(mockMapParser.disposeCalled, isTrue);
});
});
});
}

312
test/unit/data/datasources/remote/naver_url_redirect_test.dart Normal file
View File

@@ -0,0 +1,312 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:lunchpick/data/datasources/remote/naver_map_parser.dart';
import 'package:lunchpick/domain/entities/restaurant.dart';
import '../../../../mocks/mock_naver_api_client.dart';
void main() {
group('NaverMapParser - 단축 URL 리다이렉션 종합 테스트', () {
test('웹 환경에서 단축 URL 리다이렉션 성공', () async {
final mockApiClient = MockNaverApiClient();
// 단축 URL 리다이렉션 설정
mockApiClient.setUrlRedirect('https://naver.me/G7V4b1IN', 'https://map.naver.com/p/restaurant/1234567890');
// HTML 응답 설정
mockApiClient.setHtmlResponse('https://map.naver.com/p/entry/place/1234567890', '''
<html>
<head>
<meta property="og:title" content="테스트 음식점">
<meta property="og:url" content="https://map.naver.com/p/restaurant/1234567890?y=37.5666805&x=126.9784147">
</head>
<body>
<span class="GHAhO">테스트 음식점</span>
<span class="DJJvD">한식 > 김치찌개</span>
<span class="IH7VW">서울시 종로구 세종로 1</span>
<span class="xlx7Q">02-1234-5678</span>
<time class="aT6WB">매일 11:00 - 22:00</time>
</body>
</html>
''');
final parser = NaverMapParser(apiClient: mockApiClient);
final restaurant = await parser.parseRestaurantFromUrl('https://naver.me/G7V4b1IN');
expect(restaurant.name, '테스트 음식점');
expect(restaurant.category, '한식');
expect(restaurant.subCategory, '김치찌개');
expect(restaurant.phoneNumber, '02-1234-5678');
expect(restaurant.roadAddress, '서울시 종로구 세종로 1');
expect(restaurant.latitude, 37.5666805);
expect(restaurant.longitude, 126.9784147);
expect(restaurant.businessHours, '매일 11:00 - 22:00');
expect(restaurant.naverPlaceId, '1234567890');
});
test('리다이렉션 실패 시 폴백 처리', () async {
final mockApiClient = MockNaverApiClient();
// 리다이렉션 없음 (원본 URL 반환)
mockApiClient.setUrlRedirect('https://naver.me/abc123', 'https://naver.me/abc123');
final parser = NaverMapParser(apiClient: mockApiClient);
final restaurant = await parser.parseRestaurantFromUrl('https://naver.me/abc123');
// 리다이렉션 실패 시 단축 URL ID를 사용
expect(restaurant.naverPlaceId, 'abc123');
expect(restaurant.name, '네이버 지도 장소');
expect(restaurant.category, '음식점');
expect(restaurant.source, DataSource.NAVER);
});
test('다양한 리다이렉션 패턴 처리', () async {
final mockApiClient = MockNaverApiClient();
// 다른 형태의 URL로 리다이렉션
mockApiClient.setUrlRedirect('https://naver.me/xyz789', 'https://map.naver.com/p/entry/place/9999999999');
// 최소한의 HTML
mockApiClient.setHtmlResponse('https://map.naver.com/p/entry/place/9999999999', '''
<html>
<head>
<meta property="og:title" content="테스트 장소">
</head>
<body></body>
</html>
''');
final parser = NaverMapParser(apiClient: mockApiClient);
final restaurant = await parser.parseRestaurantFromUrl('https://naver.me/xyz789');
expect(restaurant.naverPlaceId, '9999999999');
expect(restaurant.name, '테스트 장소');
});
});
group('NaverMapParser - HTML 파싱 엣지 케이스', () {
test('불완전한 HTML 구조 처리', () async {
final mockApiClient = MockNaverApiClient();
// 일부 정보만 있는 HTML
mockApiClient.setHtmlResponse('https://map.naver.com/p/entry/place/7777777777', '''
<html>
<body>
<span class="GHAhO">부분 정보 식당</span>
<!-- 카테고리 정보 없음 -->
<!-- 주소 정보 없음 -->
<span class="xlx7Q">02-9999-8888</span>
</body>
</html>
''');
final parser = NaverMapParser(apiClient: mockApiClient);
final restaurant = await parser.parseRestaurantFromUrl(
'https://map.naver.com/p/restaurant/7777777777',
);
expect(restaurant.name, '부분 정보 식당');
expect(restaurant.category, '기타');
expect(restaurant.phoneNumber, '02-9999-8888');
expect(restaurant.roadAddress, '주소 정보 없음');
expect(restaurant.latitude, 37.5666805); // 기본값
expect(restaurant.longitude, 126.9784147); // 기본값
});
test('특수 문자가 포함된 데이터 처리', () async {
final mockApiClient = MockNaverApiClient();
mockApiClient.setHtmlResponse('https://map.naver.com/p/entry/place/5555555555', '''
<html>
<head>
<meta property="og:title" content="&lt;특수&gt; &amp; 문자 식당">
</head>
<body>
<span class="GHAhO">&lt;특수&gt; &amp; 문자 식당</span>
<span class="DJJvD">카페 &amp; 베이커리</span>
<span class="IH7VW">서울시 강남구 테헤란로 123 &lt;1층&gt;</span>
</body>
</html>
''');
final parser = NaverMapParser(apiClient: mockApiClient);
final restaurant = await parser.parseRestaurantFromUrl(
'https://map.naver.com/p/restaurant/5555555555',
);
// HTML 엔티티가 제대로 디코딩되는지 확인
expect(restaurant.name, contains('특수'));
expect(restaurant.name, contains('문자 식당'));
expect(restaurant.category, contains('카페'));
});
test('매우 긴 영업시간 정보 처리', () async {
final mockApiClient = MockNaverApiClient();
mockApiClient.setHtmlResponse('https://map.naver.com/p/entry/place/3333333333', '''
<html>
<body>
<span class="GHAhO">복잡한 영업시간 식당</span>
<time class="aT6WB">월요일 11:00-15:00, 17:00-22:00 (브레이크타임 15:00-17:00), 화-금 11:00-22:00, 토요일 12:00-23:00, 일요일 휴무, 공휴일 12:00-21:00</time>
</body>
</html>
''');
final parser = NaverMapParser(apiClient: mockApiClient);
final restaurant = await parser.parseRestaurantFromUrl(
'https://map.naver.com/p/restaurant/3333333333',
);
expect(restaurant.businessHours, isNotNull);
expect(restaurant.businessHours, contains('월요일'));
expect(restaurant.businessHours, contains('브레이크타임'));
});
});
group('NaverMapParser - 에러 처리 및 복구', () {
test('네트워크 타임아웃 처리', () async {
final mockApiClient = MockNaverApiClient();
mockApiClient.shouldThrowError = true;
mockApiClient.errorMessage = 'Request timeout';
final parser = NaverMapParser(apiClient: mockApiClient);
expect(
() => parser.parseRestaurantFromUrl('https://map.naver.com/p/restaurant/1234567890'),
throwsA(
allOf(
isA<NaverMapParseException>(),
predicate<NaverMapParseException>(
(e) => e.message.contains('네이버 지도 파싱 중 오류가 발생했습니다'),
),
),
),
);
});
test('잘못된 JSON 응답 처리', () async {
final mockApiClient = MockNaverApiClient();
mockApiClient.shouldThrowError = true;
mockApiClient.errorMessage = 'Invalid JSON';
final parser = NaverMapParser(apiClient: mockApiClient);
expect(
() => parser.parseRestaurantFromUrl('https://map.naver.com/p/restaurant/1234567890'),
throwsA(isA<NaverMapParseException>()),
);
});
test('빈 응답 처리', () async {
final mockApiClient = MockNaverApiClient();
mockApiClient.setHtmlResponse('https://map.naver.com/p/entry/place/1234567890', '');
final parser = NaverMapParser(apiClient: mockApiClient);
// 빈 응답이어도 기본값으로 처리되어야 함
final restaurant = await parser.parseRestaurantFromUrl('https://map.naver.com/p/restaurant/1234567890');
expect(restaurant.name, '이름 없음');
expect(restaurant.category, '기타');
});
test('404 응답 처리', () async {
final mockApiClient = MockNaverApiClient();
mockApiClient.shouldThrowError = true;
mockApiClient.errorMessage = 'Not Found';
final parser = NaverMapParser(apiClient: mockApiClient);
expect(
() => parser.parseRestaurantFromUrl('https://map.naver.com/p/restaurant/nonexistent'),
throwsA(
allOf(
isA<NaverMapParseException>(),
predicate<NaverMapParseException>(
(e) => e.message.contains('네이버 지도 파싱 중 오류가 발생했습니다'),
),
),
),
);
});
});
group('NaverMapParser - 성능 및 메모리 테스트', () {
test('대용량 HTML 파싱 성능', () async {
final mockApiClient = MockNaverApiClient();
// 큰 HTML 문서 생성
final largeHtml = '''
<html>
<head>
<meta property="og:title" content="성능 테스트 식당">
<meta property="og:url" content="https://map.naver.com/p/restaurant/1234567890?y=37.5&x=127.0">
${List.generate(1000, (i) => '<meta name="dummy$i" content="dummy content $i">').join('\n')}
</head>
<body>
<span class="GHAhO">성능 테스트 식당</span>
${List.generate(5000, (i) => '<div class="dummy">더미 콘텐츠 $i</div>').join('\n')}
<span class="DJJvD">한식</span>
<span class="IH7VW">서울시 종로구</span>
</body>
</html>
''';
mockApiClient.setHtmlResponse('https://map.naver.com/p/entry/place/1234567890', largeHtml);
final parser = NaverMapParser(apiClient: mockApiClient);
// 성능 측정
final stopwatch = Stopwatch()..start();
final restaurant = await parser.parseRestaurantFromUrl(
'https://map.naver.com/p/restaurant/1234567890',
);
stopwatch.stop();
// 기본적인 파싱이 성공했는지 확인
expect(restaurant.name, '성능 테스트 식당');
expect(restaurant.category, '한식');
// 파싱이 합리적인 시간 내에 완료되었는지 확인 (5초 이내)
expect(stopwatch.elapsedMilliseconds, lessThan(5000));
// 대용량 HTML 파싱 시간: ${stopwatch.elapsedMilliseconds}ms
});
test('여러 번의 연속 파싱', () async {
final mockApiClient = MockNaverApiClient();
final htmlContent = '''
<html>
<head>
<meta property="og:title" content="연속 파싱 테스트">
</head>
<body>
<span class="GHAhO">연속 파싱 테스트</span>
</body>
</html>
''';
// 여러 URL에 대해 같은 HTML 설정
for (int i = 0; i < 10; i++) {
mockApiClient.setHtmlResponse('https://map.naver.com/p/entry/place/${1000 + i}', htmlContent);
}
final parser = NaverMapParser(apiClient: mockApiClient);
// 여러 번 파싱 수행
final futures = List.generate(10, (i) =>
parser.parseRestaurantFromUrl('https://map.naver.com/p/restaurant/${1000 + i}')
);
final results = await Future.wait(futures);
// 모든 파싱이 성공했는지 확인
expect(results.length, 10);
for (final restaurant in results) {
expect(restaurant.name, '연속 파싱 테스트');
}
});
});
}