apple-dev-mcp
Version:
Complete Apple development guidance: Human Interface Guidelines (design) + Technical Documentation for iOS, macOS, watchOS, tvOS, and visionOS
600 lines • 30.6 kB
JavaScript
/**
* Comprehensive Concept Coverage Tests
*
* Tests the MCP's ability to handle diverse queries across all major Apple development
* concepts, simulating realistic AI agent query patterns for both HIG design guidelines
* and technical implementation queries.
*/
import { HIGToolProvider } from '../tools.js';
import { HIGCache } from '../cache.js';
// import type { UnifiedSearchResult } from '../types.js';
describe('Comprehensive Concept Coverage', () => {
let cache;
let toolProvider;
beforeEach(() => {
cache = new HIGCache(60);
toolProvider = new HIGToolProvider(cache);
});
afterEach(() => {
cache.clear();
});
describe('HIG Design Concept Queries', () => {
/**
* Test queries that an AI agent would make when helping users with Apple design guidelines.
* These simulate real-world scenarios where developers need design guidance.
*/
describe('Interactive Elements', () => {
test('should find comprehensive button design guidance', async () => {
const queries = [
'button design guidelines best practices',
'iOS button sizing accessibility requirements',
'button styles and states Apple HIG',
'custom button design patterns'
];
for (const query of queries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
// Should find button-related content
const buttonResults = result.results.filter(r => r.title.toLowerCase().includes('button') ||
r.content.toLowerCase().includes('button'));
expect(buttonResults.length).toBeGreaterThan(0);
// Should have good relevance for button queries
expect(result.results[0].relevanceScore).toBeGreaterThan(0.5);
}
});
test('should find tab bar design patterns and best practices', async () => {
const queries = [
'tab bar design guidelines iOS',
'tab navigation best practices',
'bottom navigation tab bar layout',
'iOS tab bar icons and labels'
];
for (const query of queries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
// Should find tab-related content
const tabResults = result.results.filter(r => r.title.toLowerCase().includes('tab') ||
r.content.toLowerCase().includes('tab'));
expect(tabResults.length).toBeGreaterThan(0);
expect(result.results[0].relevanceScore).toBeGreaterThan(0.4);
}
});
test('should find toggle and switch design guidance', async () => {
const queries = [
'toggle switch design guidelines',
'iOS switch component best practices',
'on off toggle interface design'
];
for (const query of queries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
const toggleResults = result.results.filter(r => r.title.toLowerCase().includes('toggle') ||
r.content.toLowerCase().includes('toggle') ||
r.content.toLowerCase().includes('switch'));
expect(toggleResults.length).toBeGreaterThan(0);
}
});
});
describe('Navigation Patterns', () => {
test('should find navigation design patterns', async () => {
const queries = [
'navigation bar design guidelines',
'iOS navigation hierarchy best practices',
'navigation stack design patterns',
'back button navigation guidelines'
];
for (const query of queries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
const navResults = result.results.filter(r => r.title.toLowerCase().includes('navigation') ||
r.content.toLowerCase().includes('navigation'));
expect(navResults.length).toBeGreaterThan(0);
expect(result.results[0].relevanceScore).toBeGreaterThan(0.4);
}
});
test('should find search interface design guidance', async () => {
const queries = [
'search field design guidelines',
'search bar best practices iOS',
'search interface patterns',
'search results layout design'
];
for (const query of queries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
const searchResults = result.results.filter(r => r.title.toLowerCase().includes('search') ||
r.content.toLowerCase().includes('search'));
expect(searchResults.length).toBeGreaterThan(0);
expect(result.results[0].relevanceScore).toBeGreaterThan(0.5);
}
});
});
describe('Data Presentation', () => {
test('should find progress indicator design guidance', async () => {
const queries = [
'progress indicator design guidelines',
'loading spinner best practices',
'progress bar design patterns iOS',
'activity indicator guidelines'
];
for (const query of queries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
const progressResults = result.results.filter(r => r.title.toLowerCase().includes('progress') ||
r.content.toLowerCase().includes('progress') ||
r.content.toLowerCase().includes('loading'));
expect(progressResults.length).toBeGreaterThan(0);
}
});
test('should find chart and data visualization guidelines', async () => {
const queries = [
'chart design guidelines Apple',
'data visualization best practices',
'iOS charts and graphs design',
'charting data presentation patterns'
];
for (const query of queries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
const chartResults = result.results.filter(r => r.title.toLowerCase().includes('chart') ||
r.content.toLowerCase().includes('chart') ||
r.content.toLowerCase().includes('data'));
expect(chartResults.length).toBeGreaterThan(0);
}
});
test('should find gauge and meter design patterns', async () => {
const queries = [
'gauge design guidelines Apple',
'meter interface design patterns',
'circular progress gauge design'
];
for (const query of queries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
// May find gauge-specific content or related measurement/progress content
expect(result.results[0].relevanceScore).toBeGreaterThan(0.1);
}
});
});
describe('Modal and Overlay Patterns', () => {
test('should find action sheet design guidelines', async () => {
const queries = [
'action sheet design guidelines iOS',
'iOS action sheet best practices',
'bottom sheet design patterns'
];
for (const query of queries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
const actionSheetResults = result.results.filter(r => r.title.toLowerCase().includes('action') ||
r.title.toLowerCase().includes('sheet') ||
r.content.toLowerCase().includes('action sheet'));
expect(actionSheetResults.length).toBeGreaterThan(0);
}
});
test('should find popover design guidelines', async () => {
const queries = [
'popover design guidelines iPad',
'popover best practices Apple',
'contextual popover design patterns'
];
for (const query of queries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
const popoverResults = result.results.filter(r => r.title.toLowerCase().includes('popover') ||
r.content.toLowerCase().includes('popover'));
expect(popoverResults.length).toBeGreaterThan(0);
}
});
test('should find alert design guidelines', async () => {
const queries = [
'alert design guidelines iOS',
'alert dialog best practices',
'system alert design patterns'
];
for (const query of queries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
const alertResults = result.results.filter(r => r.title.toLowerCase().includes('alert') ||
r.content.toLowerCase().includes('alert'));
expect(alertResults.length).toBeGreaterThan(0);
}
});
});
describe('Input and Selection', () => {
test('should find picker design guidelines', async () => {
const queries = [
'picker design guidelines iOS',
'segmented picker best practices',
'selection picker design patterns',
'date picker design guidelines'
];
for (const query of queries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
const pickerResults = result.results.filter(r => r.title.toLowerCase().includes('picker') ||
r.content.toLowerCase().includes('picker'));
expect(pickerResults.length).toBeGreaterThan(0);
}
});
test('should find text field design guidance', async () => {
const queries = [
'text field design guidelines',
'text input best practices iOS',
'form field design patterns'
];
for (const query of queries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
const textFieldResults = result.results.filter(r => r.title.toLowerCase().includes('text') ||
r.content.toLowerCase().includes('text field') ||
r.content.toLowerCase().includes('input'));
expect(textFieldResults.length).toBeGreaterThan(0);
}
});
});
describe('Platform-Specific Patterns', () => {
test('should find macOS-specific design patterns', async () => {
const queries = [
'macOS combo box design guidelines',
'macOS window design patterns',
'macOS menu bar best practices'
];
for (const query of queries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'macOS'
});
expect(result.results.length).toBeGreaterThan(0);
// Should prioritize macOS content
const macOSResults = result.results.filter(r => r.platform === 'macOS' || r.platform === 'universal');
expect(macOSResults.length).toBeGreaterThan(0);
}
});
test('should find watchOS-specific patterns', async () => {
const queries = [
'watchOS digital crown guidelines',
'watch complications design',
'watchOS interface best practices'
];
for (const query of queries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'watchOS'
});
expect(result.results.length).toBeGreaterThan(0);
const watchResults = result.results.filter(r => r.platform === 'watchOS' || r.platform === 'universal');
expect(watchResults.length).toBeGreaterThan(0);
}
});
});
describe('User Experience Patterns', () => {
test('should find onboarding design guidelines', async () => {
const queries = [
'onboarding design guidelines iOS',
'app onboarding best practices',
'user onboarding flow design'
];
for (const query of queries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
const onboardingResults = result.results.filter(r => r.title.toLowerCase().includes('onboarding') ||
r.content.toLowerCase().includes('onboarding'));
expect(onboardingResults.length).toBeGreaterThan(0);
}
});
test('should find notification management guidelines', async () => {
const queries = [
'managing notifications design guidelines',
'notification design best practices',
'push notification interface design'
];
for (const query of queries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
const notificationResults = result.results.filter(r => r.title.toLowerCase().includes('notification') ||
r.content.toLowerCase().includes('notification'));
expect(notificationResults.length).toBeGreaterThan(0);
}
});
test('should find account management patterns', async () => {
const queries = [
'managing accounts design guidelines',
'user account interface design',
'sign in design patterns'
];
for (const query of queries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
// May find sign-in, settings, or privacy-related content
expect(result.results[0].relevanceScore).toBeGreaterThan(0.1);
}
});
test('should find ratings and reviews interface guidance', async () => {
const queries = [
'ratings and reviews design guidelines',
'app rating interface design',
'review submission design patterns'
];
for (const query of queries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
const ratingResults = result.results.filter(r => r.title.toLowerCase().includes('rating') ||
r.content.toLowerCase().includes('rating') ||
r.content.toLowerCase().includes('review'));
expect(ratingResults.length).toBeGreaterThan(0);
}
});
});
});
describe('Technical Implementation Query Patterns', () => {
/**
* Test queries that simulate AI agents helping with technical implementation.
* These test the unified search that combines design guidelines with technical docs.
*/
describe('SwiftUI Layout Concepts', () => {
test('should find design and technical guidance for stack layouts', async () => {
const queries = [
'ZStack layout design patterns SwiftUI',
'LazyVStack performance best practices',
'HStack alignment design guidelines',
'VStack spacing design patterns'
];
for (const query of queries) {
const result = await toolProvider.searchUnified({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
expect(result.designResults.length).toBeGreaterThan(0);
// Should find layout-related design content
const layoutResults = result.designResults.filter(r => r.title.toLowerCase().includes('layout') ||
r.content.toLowerCase().includes('layout') ||
r.content.toLowerCase().includes('stack'));
expect(layoutResults.length).toBeGreaterThan(0);
}
});
test('should find view hierarchy design patterns', async () => {
const queries = [
'GeometryReader layout design patterns',
'View modifier design guidelines',
'SwiftUI view composition patterns'
];
for (const query of queries) {
const result = await toolProvider.searchUnified({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
// Should find relevant design content about views and layout
expect(result.designResults.length).toBeGreaterThan(0);
}
});
});
describe('Navigation Implementation', () => {
test('should find NavigationStack design and implementation guidance', async () => {
const queries = [
'NavigationStack design patterns iOS',
'navigation hierarchy implementation SwiftUI',
'navigation bar customization guidelines'
];
for (const query of queries) {
const result = await toolProvider.searchUnified({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
const navResults = result.designResults.filter(r => r.title.toLowerCase().includes('navigation') ||
r.content.toLowerCase().includes('navigation'));
// Should find navigation-related content or general design content
expect(navResults.length).toBeGreaterThanOrEqual(0);
// At minimum should return some design results
expect(result.designResults.length).toBeGreaterThan(0);
}
});
test('should find TabView design and implementation patterns', async () => {
const queries = [
'TabView design guidelines SwiftUI',
'tab navigation implementation patterns',
'bottom tab bar design best practices'
];
for (const query of queries) {
const result = await toolProvider.searchUnified({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
const tabResults = result.designResults.filter(r => r.title.toLowerCase().includes('tab') ||
r.content.toLowerCase().includes('tab'));
expect(tabResults.length).toBeGreaterThan(0);
}
});
});
describe('State Management Patterns', () => {
test('should find state management design patterns', async () => {
const queries = [
'StateObject design patterns SwiftUI',
'ObservableObject interface design',
'data binding design guidelines'
];
for (const query of queries) {
const result = await toolProvider.searchUnified({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
// Should find content about state, data, or interface patterns
const stateResults = result.designResults.filter(r => r.content.toLowerCase().includes('state') ||
r.content.toLowerCase().includes('data') ||
r.content.toLowerCase().includes('interface'));
expect(stateResults.length).toBeGreaterThan(0);
}
});
test('should find data model design patterns', async () => {
const queries = [
'Identifiable protocol design patterns',
'data model interface design',
'entity identification design guidelines'
];
for (const query of queries) {
const result = await toolProvider.searchUnified({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
expect(result.designResults.length).toBeGreaterThan(0);
}
});
});
describe('Async and Task Patterns', () => {
test('should find async task design patterns', async () => {
const queries = [
'Task async design patterns SwiftUI',
'async operation interface design',
'background task design guidelines'
];
for (const query of queries) {
const result = await toolProvider.searchUnified({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
// Should find content about loading, progress, or async operations
const asyncResults = result.designResults.filter(r => r.content.toLowerCase().includes('load') ||
r.content.toLowerCase().includes('progress') ||
r.content.toLowerCase().includes('async') ||
r.content.toLowerCase().includes('task'));
expect(asyncResults.length).toBeGreaterThan(0);
}
});
});
});
describe('Cross-Platform Consistency', () => {
test('should find consistent design patterns across platforms', async () => {
const concept = 'button design guidelines';
const platforms = ['iOS', 'macOS', 'watchOS'];
const results = await Promise.all(platforms.map(platform => toolProvider.searchHumanInterfaceGuidelines({
query: concept,
platform
})));
// All platforms should return relevant results
results.forEach((result, index) => {
expect(result.results.length).toBeGreaterThan(0);
// Should respect platform filtering
const validPlatforms = result.results.every(r => r.platform === platforms[index] || r.platform === 'universal');
expect(validPlatforms).toBe(true);
});
});
test('should prioritize universal design principles when appropriate', async () => {
const universalConcepts = [
'accessibility design guidelines',
'color design principles',
'typography design guidelines',
'layout design patterns'
];
for (const concept of universalConcepts) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query: concept,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
// Should find universal content
const universalResults = result.results.filter(r => r.platform === 'universal');
expect(universalResults.length).toBeGreaterThan(0);
}
});
});
describe('Query Quality and Consistency', () => {
test('should maintain consistent quality across different query styles', async () => {
// Test different ways an AI might ask about the same concept
const buttonQueries = [
'button design guidelines',
'iOS button best practices',
'Apple button design patterns',
'button interface design principles',
'touch target button guidelines'
];
const results = await Promise.all(buttonQueries.map(query => toolProvider.searchHumanInterfaceGuidelines({ query, platform: 'iOS' })));
// All should find button-related content
results.forEach(result => {
expect(result.results.length).toBeGreaterThan(0);
const hasButtonContent = result.results.some(r => r.title.toLowerCase().includes('button') ||
r.content.toLowerCase().includes('button'));
expect(hasButtonContent).toBe(true);
// Should have reasonable relevance scores
expect(result.results[0].relevanceScore).toBeGreaterThan(0.3);
});
});
test('should handle complex multi-concept queries effectively', async () => {
const complexQueries = [
'button accessibility design guidelines iOS',
'navigation tab bar layout best practices',
'search field text input design patterns',
'chart data visualization accessibility guidelines'
];
for (const query of complexQueries) {
const result = await toolProvider.searchHumanInterfaceGuidelines({
query,
platform: 'iOS'
});
expect(result.results.length).toBeGreaterThan(0);
// Should handle multi-concept queries with reasonable relevance
expect(result.results[0].relevanceScore).toBeGreaterThan(0.4);
// Content should be substantial
expect(result.results[0].content.length).toBeGreaterThan(200);
}
});
});
});
//# sourceMappingURL=comprehensive-concept-coverage.test.js.map