Load Testing

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

시나리오 1: 사용자 인증 및 프로필 조회
- POST /api/auth/login (사용자 인증)
- GET /api/users/profile (프로필 조회)
- 목표 부하: 초당 500 사용자
- 단계적 증가: 1분 간격으로 100명씩 증가

시나리오 2: 제품 검색 및 상세 조회
- GET /api/products?query=keyword (제품 검색)
- GET /api/products/{id} (제품 상세 조회)
- 목표 부하: 초당 1,000 요청
- 지속 시간: 30분

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

import http from 'k6/http';
import { sleep, check } from 'k6';
import { Rate } from 'k6/metrics';

// 사용자 정의 메트릭 설정
const errorRate = new Rate('errors');

// 테스트 구성
export const options = {
  stages: [
    { duration: '1m', target: 50 },   // 1분 동안 50명의 가상 사용자로 증가
    { duration: '3m', target: 50 },   // 3분 동안 50명의 가상 사용자 유지
    { duration: '1m', target: 100 },  // 1분 동안 100명의 가상 사용자로 증가
    { duration: '5m', target: 100 },  // 5분 동안 100명의 가상 사용자 유지
    { duration: '1m', target: 0 },    // 1분 동안 0명으로 감소 (정상 종료)
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'], // 95%의 요청이 500ms 미만이어야 함
    'http_req_duration{name:login}': ['p(99)<1000'], // 로그인은 99%가 1초 미만
    errors: ['rate<0.01'],           // 1% 미만의 오류율
  },
};

// 테스트 실행 로직
export default function() {
  // 로그인 API 호출
  const loginRes = http.post('https://api.example.com/login', {
    username: 'testuser',
    password: 'password123'
  }, {
    tags: { name: 'login' }
  });
  
  // 응답 검증
  const loginSuccess = check(loginRes, {
    'login status is 200': (r) => r.status === 200,
    'has access token': (r) => r.json('token') !== '',
  });
  
  // 오류 추적
  if (!loginSuccess) {
    errorRate.add(1);
  } else {
    // 인증 토큰 추출
    const token = loginRes.json('token');
    
    // 인증된 API 호출
    const userProfileRes = http.get('https://api.example.com/user/profile', {
      headers: {
        'Authorization': `Bearer ${token}`,
      },
      tags: { name: 'profile' }
    });
    
    // 응답 검증
    check(userProfileRes, {
      'profile status is 200': (r) => r.status === 200,
      'profile has data': (r) => r.json('data') !== null,
    });
    
    // 제품 검색 API 호출
    const searchRes = http.get('https://api.example.com/products?query=mobile&limit=10', {
      headers: {
        'Authorization': `Bearer ${token}`,
      },
      tags: { name: 'search' }
    });
    
    // 응답 검증
    check(searchRes, {
      'search status is 200': (r) => r.status === 200,
      'products returned': (r) => r.json('items').length > 0,
    });
  }
  
  // 사용자 행동 시뮬레이션을 위한 지연
  sleep(Math.random() * 3 + 1); // 1-4초 사이의 랜덤 지연
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

<?xml version="1.0" encoding="UTF-8"?>
<jmeterTestPlan version="1.2" properties="5.0">
  <hashTree>
    <TestPlan guiclass="TestPlanGui" testname="API Load Test Plan">
      <ThreadGroup guiclass="ThreadGroupGui" testname="API Users">
        <stringProp name="ThreadGroup.num_threads">100</stringProp>
        <stringProp name="ThreadGroup.ramp_time">60</stringProp>
        <boolProp name="ThreadGroup.scheduler">true</boolProp>
        <stringProp name="ThreadGroup.duration">300</stringProp>
        
        <!-- HTTP 요청 기본 설정 -->
        <ConfigTestElement guiclass="HttpDefaultsGui" testname="HTTP Request Defaults">
          <stringProp name="HTTPSampler.domain">api.example.com</stringProp>
          <stringProp name="HTTPSampler.protocol">https</stringProp>
        </ConfigTestElement>
        
        <!-- 로그인 요청 -->
        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testname="Login Request">
          <stringProp name="HTTPSampler.path">/login</stringProp>
          <stringProp name="HTTPSampler.method">POST</stringProp>
          <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
          <elementProp name="HTTPsampler.Arguments">
            <collectionProp name="Arguments.arguments">
              <elementProp name="username">
                <stringProp name="Argument.value">testuser</stringProp>
              </elementProp>
              <elementProp name="password">
                <stringProp name="Argument.value">password123</stringProp>
              </elementProp>
            </collectionProp>
          </elementProp>
          
          <!-- JSON 응답에서 토큰 추출 -->
          <JSONPostProcessor guiclass="JSONPostProcessorGui" testname="Extract Token">
            <stringProp name="JSONPostProcessor.referenceNames">token</stringProp>
            <stringProp name="JSONPostProcessor.jsonPathExprs">$.token</stringProp>
          </JSONPostProcessor>
          
          <!-- 응답 검증 -->
          <ResponseAssertion guiclass="AssertionGui" testname="Check Status">
            <collectionProp name="Asserion.test_strings">
              <stringProp>200</stringProp>
            </collectionProp>
            <stringProp name="Assertion.test_field">Assertion.response_code</stringProp>
          </ResponseAssertion>
        </HTTPSamplerProxy>
        
        <!-- 사용자 프로필 요청 -->
        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testname="Get Profile">
          <stringProp name="HTTPSampler.path">/user/profile</stringProp>
          <stringProp name="HTTPSampler.method">GET</stringProp>
          
          <!-- 헤더 추가 -->
          <HeaderManager guiclass="HeaderPanel" testname="Auth Headers">
            <collectionProp name="HeaderManager.headers">
              <elementProp name="Authorization">
                <stringProp name="Header.value">Bearer ${token}</stringProp>
              </elementProp>
            </collectionProp>
          </HeaderManager>
        </HTTPSamplerProxy>
        
        <!-- 결과 수집 -->
        <ResultCollector guiclass="ViewResultsFullVisualizer" testname="Results Tree"/>
        <ResultCollector guiclass="SummaryReport" testname="Summary Report"/>
        <ResultCollector guiclass="GraphVisualizer" testname="Graph Results"/>
      </ThreadGroup>
    </TestPlan>
  </hashTree>
</jmeterTestPlan>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#!/bin/bash

# 병렬 실행 수
PARALLEL=10

# 반복 횟수
ITERATIONS=100

# 시작 시간 기록
START=$(date +%s)

# 병렬로 Newman 실행
for i in $(seq 1 $PARALLEL); do
  newman run MyAPICollection.json -e TestEnvironment.json -n $ITERATIONS --silent &
done

# 모든 프로세스 완료 대기
wait

# 종료 시간 기록
END=$(date +%s)

# 결과 계산
DIFF=$(( $END - $START ))
TOTAL_REQUESTS=$(( $PARALLEL * $ITERATIONS * $(jq '.item | length' MyAPICollection.json) ))
RPS=$(echo "scale=2; $TOTAL_REQUESTS / $DIFF" | bc)

echo "병렬 프로세스: $PARALLEL"
echo "반복 횟수: $ITERATIONS"
echo "총 요청 수: $TOTAL_REQUESTS"
echo "총 소요 시간: ${DIFF}초"
echo "초당 요청 수(RPS): $RPS"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

# Grafana 대시보드 구성 (JSON 형식의 일부)
{
  "dashboard": {
    "title": "API 부하 테스트 모니터링",
    "panels": [
      {
        "title": "API 응답 시간",
        "type": "graph",
        "datasource": "Prometheus",
        "targets": [
          {
            "expr": "histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket{service=\"api\"}[1m])) by (le))",
            "legendFormat": "p95"
          },
          {
            "expr": "histogram_quantile(0.50, sum(rate(http_request_duration_seconds_bucket{service=\"api\"}[1m])) by (le))",
            "legendFormat": "p50"
          }
        ]
      },
      {
        "title": "초당 요청 수",
        "type": "graph",
        "datasource": "Prometheus",
        "targets": [
          {
            "expr": "sum(rate(http_requests_total{service=\"api\"}[1m]))",
            "legendFormat": "RPS"
          }
        ]
      },
      {
        "title": "오류율",
        "type": "graph",
        "datasource": "Prometheus",
        "targets": [
          {
            "expr": "sum(rate(http_requests_total{service=\"api\", code=~\"5..\"}[1m])) / sum(rate(http_requests_total{service=\"api\"}[1m]))",
            "legendFormat": "Error Rate"
          }
        ]
      },
      {
        "title": "CPU 사용률",
        "type": "graph",
        "datasource": "Prometheus",
        "targets": [
          {
            "expr": "avg(rate(process_cpu_seconds_total{service=\"api\"}[1m]) * 100)",
            "legendFormat": "CPU %"
          }
        ]
      },
      {
        "title": "메모리 사용량",
        "type": "graph",
        "datasource": "Prometheus",
        "targets": [
          {
            "expr": "process_resident_memory_bytes{service=\"api\"} / 1024 / 1024",
            "legendFormat": "Memory (MB)"
          }
        ]
      }
    ]
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

# .github/workflows/load-test.yml
name: API Load Testing

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]
  schedule:
    - cron: '0 2 * * 1'  # 매주 월요일 02:00 UTC에 실행

jobs:
  load-test:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v2
    
    - name: Set up Node.js
      uses: actions/setup-node@v2
      with:
        node-version: '16'
    
    - name: Install k6
      run: |
        curl -L https://github.com/loadimpact/k6/releases/download/v0.37.0/k6-v0.37.0-linux-amd64.tar.gz | tar xzf -
        sudo cp k6-v0.37.0-linux-amd64/k6 /usr/local/bin
    
    - name: Deploy test environment
      run: docker-compose -f docker-compose.test.yml up -d
    
    - name: Wait for services to start
      run: sleep 30
    
    - name: Run baseline load test
      run: k6 run --summary-export=baseline-results.json tests/performance/baseline.js
    
    - name: Run stress test
      run: k6 run --summary-export=stress-results.json tests/performance/stress.js
    
    - name: Run endurance test
      run: k6 run --summary-export=endurance-results.json tests/performance/endurance.js
    
    - name: Generate performance report
      run: node scripts/generate-performance-report.js
    
    - name: Archive test results
      uses: actions/upload-artifact@v2
      with:
        name: load-test-results
        path: |
          baseline-results.json
          stress-results.json
          endurance-results.json
          performance-report.html

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

# docker-compose 구성
version: '3'

services:
  prometheus:
    image: prom/prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"
  
  grafana:
    image: grafana/grafana
    depends_on:
      - prometheus
    ports:
      - "3000:3000"
    volumes:
      - grafana-storage:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=secret
  
  node-exporter:
    image: prom/node-exporter
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--collector.filesystem.ignored-mount-points=^/(sys|proc|dev|host|etc)($$|/)'
    ports:
      - "9100:9100"

volumes:
  grafana-storage:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'node'
    static_configs:
      - targets: ['node-exporter:9100']

  - job_name: 'api'
    metrics_path: '/metrics'
    static_configs:
      - targets: ['api:8080']

  # 앱 서비스가 Prometheus 메트릭을 노출한다고 가정
  - job_name: 'applications'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['app-service-1:8080', 'app-service-2:8080']

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

# CloudFormation 템플릿
Resources:
  ApiAutoScalingGroup:
    Type: AWS::AutoScaling::AutoScalingGroup
    Properties:
      LaunchConfigurationName: !Ref ApiLaunchConfig
      MinSize: 2
      MaxSize: 10
      DesiredCapacity: 2
      VPCZoneIdentifier: !Ref Subnets
      TargetGroupARNs:
        - !Ref ApiTargetGroup
      Tags:
        - Key: Name
          Value: API-Server
          PropagateAtLaunch: true
      # 가용 영역에 고르게 분산
      AvailabilityZones:
        - !Select [0, !GetAZs '']
        - !Select [1, !GetAZs '']
  
  ApiScalingPolicy:
    Type: AWS::AutoScaling::ScalingPolicy
    Properties:
      AutoScalingGroupName: !Ref ApiAutoScalingGroup
      PolicyType: TargetTrackingScaling
      TargetTrackingConfiguration:
        PredefinedMetricSpecification:
          PredefinedMetricType: ASGAverageCPUUtilization
        TargetValue: 70.0
        # 급격한 스케일 인/아웃 방지를 위한 쿨다운 기간
        ScaleInCooldown: 300
        ScaleOutCooldown: 60
  
  # 요청 대기열 길이 기반 추가 확장 정책
  ApiQueueLengthScalingPolicy:
    Type: AWS::AutoScaling::ScalingPolicy
    Properties:
      AutoScalingGroupName: !Ref ApiAutoScalingGroup
      PolicyType: TargetTrackingScaling
      TargetTrackingConfiguration:
        CustomizedMetricSpecification:
          MetricName: BacklogPerInstance
          Namespace: AWS/SQS
          Dimensions:
            - Name: QueueName
              Value: !GetAtt ApiQueue.QueueName
          Statistic: Average
        TargetValue: 100.0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

# nginx.conf
http {
    upstream api_servers {
        least_conn;                   # 최소 연결 알고리즘
        server api1.example.com:8080 weight=5;  # 더 강력한 서버에 높은 가중치
        server api2.example.com:8080 weight=3;
        server api3.example.com:8080 weight=1 backup;  # 백업 서버
        
        keepalive 100;  # 연결 유지 풀 크기
    }
    
    # 읽기 전용 작업을 위한 별도 업스트림
    upstream read_api_servers {
        ip_hash;  # 클라이언트 IP 기반 라우팅
        server read1.example.com:8080;
        server read2.example.com:8080;
        server read3.example.com:8080;
    }
    
    # 쓰기 작업을 위한 별도 업스트림
    upstream write_api_servers {
        server write1.example.com:8080;
        server write2.example.com:8080;
    }
    
    server {
        listen 80;
        server_name api.example.com;
        
        # 상태 모니터링 엔드포인트
        location /status {
            stub_status on;
            allow 127.0.0.1;  # 내부 접근만 허용
            deny all;
        }
        
        # 읽기 요청 라우팅
        location ~ ^/api/(products|categories|users)/([0-9]+)$ {
            limit_req zone=api_reqs burst=10;  # 요청 제한
            proxy_pass http://read_api_servers;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_http_version 1.1;
            proxy_set_header Connection "";
            
            # 타임아웃 설정
            proxy_connect_timeout 2s;
            proxy_send_timeout 5s;
            proxy_read_timeout 5s;
        }
        
        # 쓰기 요청 라우팅
        location ~ ^/api/(products|categories|users)$ {
            limit_req zone=api_write_reqs burst=5 nodelay;  # 더 엄격한 제한
            proxy_pass http://write_api_servers;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_http_version 1.1;
            proxy_set_header Connection "";
            
            # 더 긴 타임아웃 (쓰기 작업은 시간이 더 걸릴 수 있음)
            proxy_connect_timeout 3s;
            proxy_send_timeout 10s;
            proxy_read_timeout 10s;
        }
        
        # 기본 요청 라우팅
        location / {
            proxy_pass http://api_servers;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_http_version 1.1;
            proxy_set_header Connection "";
        }
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213

import http from 'k6/http';
import { sleep, check, group } from 'k6';
import { randomIntBetween } from 'https://jslib.k6.io/k6-utils/1.1.0/index.js';
import { Trend, Rate, Counter } from 'k6/metrics';

// 사용자 정의 메트릭
const searchLatency = new Trend('search_latency');
const cartAddSuccess = new Rate('cart_add_success');
const orderCount = new Counter('order_count');

// 테스트 구성
export const options = {
  scenarios: {
    // 브라우저 사용자 시나리오
    browser_users: {
      executor: 'ramping-vus',  // 점진적으로 사용자 증가
      startVUs: 0,
      stages: [
        { duration: '2m', target: 100 },  // 2분 동안 100명까지 증가
        { duration: '5m', target: 100 },  // 5분 동안 100명 유지
        { duration: '2m', target: 0 },    // 2분 동안 0명으로 감소
      ],
      gracefulRampDown: '30s',
    },
    // 모바일 앱 사용자 시나리오
    mobile_app_users: {
      executor: 'constant-vus',  // 일정한 사용자 수
      vus: 50,
      duration: '10m',
      startTime: '30s',  // 30초 후에 시작
    }
  },
  thresholds: {
    'http_req_duration': ['p(95)<500'],
    'search_latency': ['p(95)<300'],
    'cart_add_success': ['rate>0.95'],
  },
};

// 브라우저 사용자 시뮬레이션
export function browserUsers() {
  let userJourney = Math.random();  // 사용자 여정 무작위 선택
  
  // 로그인 (모든 사용자 공통)
  group('Login', function() {
    let loginRes = http.post('https://api.example.com/login', {
      username: `user_${__VU}@example.com`,
      password: 'password123'
    });
    
    check(loginRes, {
      'login successful': (r) => r.status === 200 && r.json('token') !== '',
    });
    
    // 로그인 후 생각하는 시간
    sleep(randomIntBetween(2, 5));
  });
  
  // 상품 검색 및 브라우징 (80% 사용자)
  if (userJourney < 0.8) {
    group('Product Search', function() {
      // 검색어 배열에서 무작위 선택
      const searchTerms = ['smartphone', 'laptop', 'headphones', 'camera', 'watch'];
      const searchTerm = searchTerms[Math.floor(Math.random() * searchTerms.length)];
      
      let searchStart = new Date().getTime();
      let searchRes = http.get(`https://api.example.com/products?query=${searchTerm}&limit=20`);
      let searchEnd = new Date().getTime();
      
      // 검색 지연 시간 기록
      searchLatency.add(searchEnd - searchStart);
      
      check(searchRes, {
        'search successful': (r) => r.status === 200,
        'search has results': (r) => r.json('items').length > 0,
      });
      
      // 검색 결과 탐색 시간
      sleep(randomIntBetween(3, 8));
      
      // 상품 상세 페이지 조회 (검색 결과에서 무작위 선택)
      if (searchRes.json('items').length > 0) {
        const products = searchRes.json('items');
        const randomProduct = products[Math.floor(Math.random() * products.length)];
        
        let productRes = http.get(`https://api.example.com/products/${randomProduct.id}`);
        
        check(productRes, {
          'product details loaded': (r) => r.status === 200
        });
        
        // 상품 상세 페이지 탐색 시간
        sleep(randomIntBetween(5, 15));
        
        // 관련 상품 확인 (50% 확률)
        if (Math.random() < 0.5) {
          let relatedRes = http.get(`https://api.example.com/products/${randomProduct.id}/related`);
          
          check(relatedRes, {
            'related products loaded': (r) => r.status === 200
          });
          
          sleep(randomIntBetween(3, 7));
        }
        
        // 장바구니에 추가 (60% 확률)
        if (Math.random() < 0.6) {
          let cartRes = http.post('https://api.example.com/cart/items', {
            productId: randomProduct.id,
            quantity: Math.floor(Math.random() * 3) + 1
          });
          
          let cartSuccess = check(cartRes, {
            'added to cart successfully': (r) => r.status === 200 || r.status === 201
          });
          
          cartAddSuccess.add(cartSuccess);
          
          sleep(randomIntBetween(2, 5));
        }
      }
    });
  }
  
  // 장바구니 확인 및 주문 (30% 확률)
  if (Math.random() < 0.3) {
    group('Checkout Process', function() {
      // 장바구니 조회
      let cartRes = http.get('https://api.example.com/cart');
      
      check(cartRes, {
        'cart retrieved': (r) => r.status === 200
      });
      
      sleep(randomIntBetween(3, 8));
      
      // 장바구니에 상품이 있는 경우 결제 진행
      if (cartRes.json('items') && cartRes.json('items').length > 0) {
        // 배송 정보 입력
        let shippingRes = http.post('https://api.example.com/checkout/shipping', {
          address: '123 Test Street',
          city: 'Test City',
          zipCode: '12345',
          country: 'Test Country'
        });
        
        check(shippingRes, {
          'shipping info added': (r) => r.status === 200
        });
        
        sleep(randomIntBetween(5, 10));
        
        // 결제 정보 입력
        let paymentRes = http.post('https://api.example.com/checkout/payment', {
          cardType: 'visa',
          cardNumber: '4111111111111111',
          expiryMonth: '12',
          expiryYear: '2025',
          cvv: '123'
        });
        
        check(paymentRes, {
          'payment info added': (r) => r.status === 200
        });
        
        sleep(randomIntBetween(3, 7));
        
        // 주문 완료
        let orderRes = http.post('https://api.example.com/orders');
        
        let orderSuccess = check(orderRes, {
          'order placed successfully': (r) => r.status === 201
        });
        
        if (orderSuccess) {
          orderCount.add(1);
        }
        
        sleep(randomIntBetween(5, 10));
      }
    });
  }
  
  // 사용자 계정 정보 확인 (20% 확률)
  if (Math.random() < 0.2) {
    group('Account Management', function() {
      let profileRes = http.get('https://api.example.com/user/profile');
      
      check(profileRes, {
        'profile loaded': (r) => r.status === 200
      });
      
      sleep(randomIntBetween(5, 15));
      
      // 주문 이력 확인 (70% 확률)
      if (Math.random() < 0.7) {
        let ordersRes = http.get('https://api.example.com/user/orders');
        
        check(ordersRes, {
          'order history loaded': (r) => r.status === 200
        });
        
        sleep(randomIntBetween(3, 10));
      }
    });
  }
}

// 모바일 앱 사용자 시뮬레이션
export function mobileAppUsers() {
  // 모바일 앱 사용자에 맞는 다른 사용자 패턴 구현
  // ...
}