제8장: 구현 및 인증

8.1 구현 로드맵

WIA-ROB-011 표준을 준수하는 청소 로봇을 개발하기 위한 단계별 가이드입니다. 각 단계는 이전 단계의 완료를 전제로 하며, 점진적으로 기능을 추가합니다.

8.1.1 개발 단계

단계	기간	주요 작업	산출물
1. 계획	2주	요구사항 분석, 준수 레벨 선택	기술 사양서
2. 데이터 모델	3주	JSON 스키마 구현, 검증	데이터 구조 코드
3. API 개발	4주	REST/GraphQL API 구현	API 서버, 문서
4. 통신 계층	4주	WebSocket, MQTT 구현	통신 모듈
5. 통합	3주	스마트홈 플랫폼 연동	통합 어댑터
6. 테스트	4주	단위/통합/시스템 테스트	테스트 리포트
7. 인증	3주	WIA 인증 절차	인증서

8.2 개발 환경 설정

8.2.1 필수 도구

// package.json (Node.js 프로젝트 예시)
{
  "name": "wia-rob-011-implementation",
  "version": "1.0.0",
  "dependencies": {
    "@wia/rob-011-sdk": "^1.0.0",
    "express": "^4.18.0",
    "ws": "^8.14.0",
    "mqtt": "^5.0.0",
    "ajv": "^8.12.0",
    "joi": "^17.10.0"
  },
  "devDependencies": {
    "jest": "^29.7.0",
    "@types/node": "^20.0.0",
    "typescript": "^5.2.0",
    "eslint": "^8.50.0",
    "prettier": "^3.0.0"
  }
}

// 설치
npm install

// 타입 정의 생성
npm run generate-types

8.2.2 프로젝트 구조

wia-rob-011-robot/
├── src/
│   ├── models/
│   │   ├── device.ts
│   │   ├── status.ts
│   │   └── schema.ts
│   ├── api/
│   │   ├── rest/
│   │   │   ├── routes.ts
│   │   │   └── controllers/
│   │   └── graphql/
│   │       ├── schema.graphql
│   │       └── resolvers.ts
│   ├── communication/
│   │   ├── websocket.ts
│   │   ├── mqtt.ts
│   │   └── coap.ts
│   ├── integration/
│   │   ├── google-home.ts
│   │   ├── alexa.ts
│   │   └── homekit.ts
│   └── core/
│       ├── robot.ts
│       ├── navigator.ts
│       └── cleaner.ts
├── tests/
│   ├── unit/
│   ├── integration/
│   └── e2e/
├── docs/
│   └── api/
└── config/
    ├── default.json
    └── production.json

8.3 핵심 컴포넌트 구현

8.3.1 데이터 모델 구현

// src/models/device.ts
import Ajv from 'ajv';
import { deviceSchema } from './schema';

export class RobotDevice {
  private ajv = new Ajv();
  private data: DeviceData;

  constructor(initialData: Partial) {
    this.data = this.createDefault();
    Object.assign(this.data, initialData);
    this.validate();
  }

  private createDefault(): DeviceData {
    return {
      standard: 'WIA-ROB-011',
      version: '1.0.0',
      timestamp: new Date().toISOString(),
      device: {
        id: '',
        type: 'vacuum_cleaner',
        manufacturer: '',
        model: ''
      },
      status: {
        state: 'idle',
        battery: { level: 100, charging: false }
      }
    };
  }

  private validate() {
    const valid = this.ajv.validate(deviceSchema, this.data);
    if (!valid) {
      throw new Error(
        `Invalid data: ${this.ajv.errorsText()}`
      );
    }
  }

  toJSON() {
    return JSON.stringify(this.data, null, 2);
  }

  updateStatus(newStatus: Partial) {
    this.data.status = {
      ...this.data.status,
      ...newStatus
    };
    this.data.timestamp = new Date().toISOString();
    this.validate();
  }
}

8.3.2 API 서버 구현

// src/api/rest/server.ts
import express from 'express';
import { robotRouter } from './routes';

const app = express();
app.use(express.json());

// 미들웨어: 인증
app.use('/api/v1', authenticateToken);

// 라우트
app.use('/api/v1/robots', robotRouter);

// 오류 처리
app.use((err, req, res, next) => {
  res.status(err.status || 500).json({
    error: {
      code: err.code,
      message: err.message,
      timestamp: new Date().toISOString(),
      request_id: req.id
    }
  });
});

app.listen(3000, () => {
  console.log('WIA-ROB-011 API Server running on port 3000');
});

// src/api/rest/routes.ts
import { Router } from 'express';

const router = Router();

// 상태 조회
router.get('/:robotId/status', async (req, res) => {
  const robot = await robotService.find(req.params.robotId);
  res.json(robot.getStatus());
});

// 명령 실행
router.post('/:robotId/commands/:command', async (req, res) => {
  const { robotId, command } = req.params;
  const result = await robotService.executeCommand(
    robotId,
    command,
    req.body
  );
  res.status(202).json(result);
});

export { router as robotRouter };

8.3.3 WebSocket 서버

// src/communication/websocket.ts
import WebSocket from 'ws';

class RobotWebSocketServer {
  private wss: WebSocket.Server;
  private clients = new Map();

  constructor(port: number) {
    this.wss = new WebSocket.Server({ port });
    this.setupEventHandlers();
  }

  private setupEventHandlers() {
    this.wss.on('connection', (ws, req) => {
      const robotId = this.extractRobotId(req);

      // 연결 저장
      this.clients.set(robotId, ws);

      // 메시지 처리
      ws.on('message', (data) => {
        this.handleMessage(robotId, data);
      });

      // 핑-퐁
      ws.on('ping', () => ws.pong());

      // 연결 종료
      ws.on('close', () => {
        this.clients.delete(robotId);
      });
    });
  }

  private async handleMessage(robotId: string, data: any) {
    const message = JSON.parse(data.toString());

    switch (message.type) {
      case 'command':
        const result = await this.executeCommand(
          robotId,
          message.command,
          message.parameters
        );
        this.send(robotId, {
          type: 'response',
          request_id: message.id,
          data: result
        });
        break;

      case 'ping':
        this.send(robotId, { type: 'pong' });
        break;
    }
  }

  broadcast(robotId: string, event: string, data: any) {
    const ws = this.clients.get(robotId);
    if (ws && ws.readyState === WebSocket.OPEN) {
      this.send(robotId, {
        type: event,
        timestamp: new Date().toISOString(),
        data
      });
    }
  }
}

8.4 테스트 전략

8.4.1 단위 테스트

// tests/unit/device.test.ts
import { RobotDevice } from '@/models/device';

describe('RobotDevice', () => {
  test('should create valid device', () => {
    const device = new RobotDevice({
      device: {
        id: 'CR-TEST-001',
        type: 'vacuum_cleaner',
        manufacturer: 'Test Corp',
        model: 'Test Model'
      }
    });

    expect(device.toJSON()).toBeDefined();
  });

  test('should reject invalid data', () => {
    expect(() => {
      new RobotDevice({
        device: {
          id: 'CR-TEST-001',
          type: 'invalid_type' // 잘못된 타입
        }
      });
    }).toThrow();
  });

  test('should update status', () => {
    const device = new RobotDevice({...});
    device.updateStatus({
      state: 'cleaning',
      battery: { level: 85 }
    });

    const data = JSON.parse(device.toJSON());
    expect(data.status.state).toBe('cleaning');
    expect(data.status.battery.level).toBe(85);
  });
});

8.4.2 통합 테스트

// tests/integration/api.test.ts
import request from 'supertest';
import { app } from '@/api/rest/server';

describe('REST API', () => {
  let authToken: string;

  beforeAll(async () => {
    authToken = await getTestToken();
  });

  test('GET /api/v1/robots/:id/status', async () => {
    const response = await request(app)
      .get('/api/v1/robots/CR-TEST-001/status')
      .set('Authorization', `Bearer ${authToken}`)
      .expect(200);

    expect(response.body).toHaveProperty('state');
    expect(response.body).toHaveProperty('battery');
  });

  test('POST /api/v1/robots/:id/commands/start', async () => {
    const response = await request(app)
      .post('/api/v1/robots/CR-TEST-001/commands/start')
      .set('Authorization', `Bearer ${authToken}`)
      .send({
        mode: 'auto',
        power_level: 'high'
      })
      .expect(202);

    expect(response.body).toHaveProperty('task_id');
  });
});

8.4.3 E2E 테스트

// tests/e2e/cleaning-workflow.test.ts
describe('Complete Cleaning Workflow', () => {
  test('should perform full cleaning cycle', async () => {
    // 1. 초기 상태 확인
    let status = await robot.getStatus();
    expect(status.state).toBe('idle');
    expect(status.battery.level).toBeGreaterThan(30);

    // 2. 청소 시작
    const task = await robot.startCleaning({
      mode: 'auto',
      rooms: ['living_room']
    });

    // 3. 상태 모니터링
    await waitForState('cleaning', { timeout: 5000 });

    // 4. 진행 상황 확인
    status = await robot.getStatus();
    expect(status.cleaning.progress).toBeGreaterThan(0);

    // 5. 완료 대기
    await waitForState('idle', { timeout: 60000 });

    // 6. 결과 검증
    const history = await robot.getHistory({ limit: 1 });
    expect(history[0].completed).toBe(true);
    expect(history[0].area_cleaned).toBeGreaterThan(0);
  });
});

8.5 WIA 인증 프로세스

공식 WIA-ROB-011 인증을 받기 위한 단계별 절차입니다.

8.5.1 인증 절차

단계	내용	소요 시간	비용
1. 사전 등록	온라인 신청서 제출	1일	무료
2. 문서 심사	기술 사양서, 테스트 계획 검토	1주	무료
3. 자체 테스트	제조사 내부 검증	2-4주	무료
4. 공인 시험	WIA 공인 랩에서 테스트	2-3주	$2,000-5,000
5. 최종 검토	기술위원회 승인	1주	무료
6. 인증 발급	인증서 및 로고 발급	3일	$500

8.5.2 자체 테스트 체크리스트

8.5.3 공인 테스트 항목

테스트 분류	테스트 항목	합격 기준
기능 테스트	모든 API 엔드포인트	100% 성공
성능 테스트	API 응답 시간	< 200ms (95%ile)
부하 테스트	동시 연결 처리	> 100 connections
보안 테스트	암호화, 인증	취약점 없음
안정성 테스트	72시간 연속 운영	오류율 < 0.1%
상호운용성	타사 제품과 통신	성공적 통신

8.6 인증 후 혜택

WIA-ROB-011 인증을 획득하면 다음과 같은 혜택을 받습니다.

8.7 유지 및 갱신

인증은 3년간 유효하며, 갱신이 필요합니다.

8.7.1 갱신 절차

// 인증 유효 기간 관리
{
  "certificate": {
    "id": "WIA-ROB-011-2025-001234",
    "issued_date": "2025-12-29",
    "expiry_date": "2028-12-29",
    "status": "active",
    "level": "Premium"
  },
  "renewal": {
    "eligible_from": "2028-09-29",  // 만료 3개월 전
    "process": "simplified",         // 간소화 절차
    "fee": "$250"                    // 갱신 비용 (신규의 50%)
  }
}

8.7.2 연간 자체 감사

인증 유지를 위해 매년 자체 감사를 수행하고 보고서를 제출합니다.

점검 항목	빈도	보고 대상
표준 준수 확인	연 1회	WIA 기술위원회
보안 업데이트	분기별	내부 문서화
사용자 피드백	지속적	내부 검토
호환성 테스트	신규 펌웨어마다	내부 문서화

8.8 모범 사례

8.8.1 코드 품질

• 타입 안정성: TypeScript 등 정적 타입 언어 사용
• 코드 리뷰: 모든 변경사항 동료 검토
• 테스트 커버리지: 최소 80% 이상
• CI/CD: 자동화된 빌드 및 배포
• 문서화: 코드 주석, API 문서 최신 유지

8.8.2 보안 프랙티스

• 정기 보안 감사 (최소 연 1회)
• 의존성 취약점 스캔 (매주)
• 침투 테스트 (연 1회)
• 보안 패치 신속 배포 (7일 이내)

8.8.3 사용자 경험

• 명확한 에러 메시지
• 직관적인 API 설계
• 상세한 사용자 가이드
• 반응형 고객 지원

8.9 리소스 및 지원

8.9.1 공식 리소스

8.9.2 커뮤니티 지원

• Slack 채널: #wia-rob-011
• 월간 웨비나: 매월 마지막 수요일
• 연간 컨퍼런스: WIA RoboCon
• Stack Overflow: 태그 [wia-rob-011]

8.10 미래 로드맵

WIA-ROB-011 표준은 지속적으로 발전합니다.

버전	예정일	주요 변경사항
1.1.0	2026 Q2	멀티 로봇 협업 프로토콜 추가
1.2.0	2026 Q4	AI 의사결정 투명성 메커니즘
2.0.0	2027 Q2	차세대 센서 지원, 완전 자율 기능