เลขบัตรทดสอบและข้อมูลทดสอบ

เลขบัตรทดสอบแบบสมบูรณ์และข้อมูลการชำระเงินสำหรับการทดสอบทุกสถานการณ์การชำระเงินในสภาพแวดล้อมการทดสอบของ Omise ใช้บัตรเหล่านี้เพื่อจำลองการชำระเงินสำเร็จ, การปฏิเสธ, การตรวจสอบ 3D Secure และสถานการณ์ความล้มเหลวต่างๆ

ภาพรวม

Omise มีข้อมูลทดสอบที่ครอบคลุมสำหรับวิธีการชำระเงินที่รองรับทั้งหมด บัตรทดสอบและวิธีการชำระเงินเหล่านี้ช่วยให้คุณสามารถทดสอบการผสานรวมของคุณอย่างละเอียดก่อนไปใช้งานจริง โดยครอบคลุมสถานการณ์ความสำเร็จ, เหตุผลการปฏิเสธ, การตรวจจับ欺, การตรวจสอบ 3D Secure และวิธีการชำระเงินตามภูมิภาค

คุณสมบัติหลัก

• ความครอบคลุมแบบสมบูรณ์ของบัตร: บัตรทดสอบสำหรับแบรนด์บัตรครบครัน
• การทดสอบ 3D Secure: ทดสอบทั้งการตรวจสอบสิทธิ์ที่สำเร็จและล้มเหลว
• สถานการณ์การปฏิเสธ: ทดสอบเหตุผลการปฏิเสธเฉพาะและการตอบสนอง
• วิธีการตามภูมิภาค: บัตรทดสอบและวิธีการชำระเงินสำหรับแต่ละตลาดที่รองรับ
• สถานการณ์ในโลกจริง: ทดสอบกรณีพิเศษและสภาวะเพิ่มเติม
• การทดสอบ CVV และวันหมดอายุ: ทดสอบการตรวจสอบและการตรวจสอบความปลอดภัย

บัตรทดสอบมาตรฐาน

บัตรชำระเงินที่สำเร็จ

ใช้บัตรเหล่านี้เพื่อทดสอบสถานการณ์การชำระเงินที่สำเร็จ:

ยี่ห้อบัตร	เลขบัตร	CVV	วันหมดอายุ	3D Secure	คำอธิบาย
Visa	4242424242424242	เลข 3 หลักใดๆ	วันที่ใดๆ ในอนาคต	ไม่ลงทะเบียน	การชำระเงินสำเร็จแบบมาตรฐาน
Visa	4111111111111111	เลข 3 หลักใดๆ	วันที่ใดๆ ในอนาคต	ไม่ลงทะเบียน	บัตร Visa ทดสอบทางเลือก
Mastercard	5555555555554444	เลข 3 หลักใดๆ	วันที่ใดๆ ในอนาคต	ไม่ลงทะเบียน	การชำระเงินสำเร็จแบบมาตรฐาน
Mastercard	5454545454545454	เลข 3 หลักใดๆ	วันที่ใดๆ ในอนาคต	ไม่ลงทะเบียน	บัตร Mastercard ทดสอบทางเลือก
JCB	3530111333300000	เลข 3 หลักใดๆ	วันที่ใดๆ ในอนาคต	ไม่ลงทะเบียน	การชำระเงิน JCB มาตรฐาน
American Express	378282246310005	เลข 4 หลักใดๆ	วันที่ใดๆ ในอนาคต	ไม่ลงทะเบียน	การชำระเงิน Amex มาตรฐาน
American Express	371449635398431	เลข 4 หลักใดๆ	วันที่ใดๆ ในอนาคต	ไม่ลงทะเบียน	บัตร Amex ทดสอบทางเลือก
Diners Club	36227206271667	เลข 3 หลักใดๆ	วันที่ใดๆ ในอนาคต	ไม่ลงทะเบียน	การชำระเงิน Diners มาตรฐาน
Discover	6011111111111117	เลข 3 หลักใดๆ	วันที่ใดๆ ในอนาคต	ไม่ลงทะเบียน	การชำระเงิน Discover มาตรฐาน

หมายเหตุที่สำคัญ

• CVV: ใช้ CVV ที่ถูกต้องใดๆ (3 หลักสำหรับบัตรส่วนใหญ่, 4 หลักสำหรับ American Express)
• วันหมดอายุ: ใช้วันที่ใดๆ ในอนาคตในรูปแบบ MM/YY หรือ MM/YYYY
• ชื่อผู้ถือบัตร: ใช้ชื่อใดๆ (อย่างน้อย 2 อักขระ)
• จำนวนเงิน: ใช้จำนวนเงินที่ถูกต้องใดๆ เพื่อทดสอบค่าการชำระเงินที่แตกต่างกัน

บัตรทดสอบ 3D Secure

การตรวจสอบ 3D Secure ที่สำเร็จ

บัตรที่ต้องการและสำเร็จในการตรวจสอบ 3D Secure:

ยี่ห้อบัตร	เลขบัตร	CVV	วันหมดอายุ	การตรวจสอบสิทธิ์	คำอธิบาย
Visa	4000000000000002	เลข 3 หลักใดๆ	วันที่ใดๆ ในอนาคต	สำเร็จ	ลงทะเบียน 3DS, การตรวจสอบสำเร็จ
Mastercard	5200000000000007	เลข 3 หลักใดๆ	วันที่ใดๆ ในอนาคต	สำเร็จ	ลงทะเบียน 3DS, การตรวจสอบสำเร็จ
JCB	3530111333300001	เลข 3 หลักใดๆ	วันที่ใดๆ ในอนาคต	สำเร็จ	ลงทะเบียน 3DS, การตรวจสอบสำเร็จ

การตรวจสอบ 3D Secure ที่ล้มเหลว

บัตรที่ไม่สำเร็จในการตรวจสอบ 3D Secure:

ยี่ห้อบัตร	เลขบัตร	CVV	วันหมดอายุ	การตรวจสอบสิทธิ์	คำอธิบาย
Visa	4000000000000010	เลข 3 หลักใดๆ	วันที่ใดๆ ในอนาคต	ล้มเหลว	ลงทะเบียน 3DS, การตรวจสอบล้มเหลว
Mastercard	5200000000000015	เลข 3 หลักใดๆ	วันที่ใดๆ ในอนาคต	ล้มเหลว	ลงทะเบียน 3DS, การตรวจสอบล้มเหลว
Visa	4000000000000028	เลข 3 หลักใดๆ	วันที่ใดๆ ในอนาคต	ปฏิเสธ	ลงทะเบียน 3DS, ปฏิเสธโดยผู้ออกบัตร

ลำดับการทำงาน 3D Secure Authentication

// JavaScript - การทดสอบการชำระเงิน 3D Secure
const Omise = require('omise')({
  secretKey: 'skey_test_xxxxxxxxxx',
  omiseVersion: '2019-05-29'
});

async function test3DSecurePayment() {
  try {
    // 1. สร้างโทเค็นด้วยบัตรทดสอบ 3DS
    const token = await Omise.tokens.create({
      card: {
        name: 'Test User',
        number: '4000000000000002', // บัตรลงทะเบียน 3DS
        expiration_month: 12,
        expiration_year: 2026,
        security_code: '123'
      }
    });

    // 2. สร้างประจำ (จะส่งกลับ authorize_uri สำหรับ 3DS)
    const charge = await Omise.charges.create({
      amount: 100000, // 1,000.00 THB
      currency: 'THB',
      card: token.id,
      return_uri: 'https://example.com/orders/complete'
    });

    console.log('Charge Status:', charge.status); // 'pending'
    console.log('3DS Authorization URL:', charge.authorize_uri);

    // ลูกค้าทำการตรวจสอบ 3DS ที่ authorize_uri
    // หลังจากเสร็จสิ้น พวกเขาจะถูกเปลี่ยนเส้นทางไปยัง return_uri

    // 3. ดึงประจำเพื่อตรวจสอบสถานะสุดท้าย
    const updatedCharge = await Omise.charges.retrieve(charge.id);
    console.log('Final Status:', updatedCharge.status); // 'successful'

  } catch (error) {
    console.error('Error:', error.message);
  }
}

test3DSecurePayment();

บัตรทดสอบที่ปฏิเสธ

เหตุผลการปฏิเสธเฉพาะ

ทดสอบสถานการณ์การปฏิเสธเฉพาะด้วยบัตรเหล่านี้:

เลขบัตร	เหตุผลการปฏิเสธ	คำอธิบาย
4000000000000101	เงินไม่เพียงพอ	บัตรมีเงินไม่เพียงพอ
4000000000000119	ข้อผิดพลาดในการประมวลผล	ข้อผิดพลาดในการประมวลผลทั่วไป
4000000000000127	บัตรหาย	บัตรได้รับการรายงานว่าหาย
4000000000000135	บัตรถูกขโมย	บัตรได้รับการรายงานว่าถูกขโมย
4000000000000143	บัตรหมดอายุ	บัตรหมดอายุแล้ว
4000000000000150	CVV ไม่ถูกต้อง	การตรวจสอบ CVV ล้มเหลว
4000000000000168	เลขบัตรไม่ถูกต้อง	เลขบัตรไม่ถูกต้อง
4000000000000176	วันหมดอายุไม่ถูกต้อง	วันหมดอายุไม่ถูกต้อง
4000000000000184	ไม่อนุญาตธุรกรรม	ไม่อนุญาตธุรกรรมสำหรับบัตรนี้
4000000000000192	ปฏิเสธสงสัยเนื่องจากการทุจริต	ธุรกรรมถูกทำเครื่องหมายว่าเป็นการทุจริต
4000000000000200	บัตรมีข้อจำกัด	บัตรมีข้อจำกัด
4000000000000218	เกินขีดจำกัดการถอน	จำนวนเงินเกินขีดจำกัดบัตร
4000000000000226	ผู้ออกบัตรไม่พร้อม	ระบบผู้ออกบัตรไม่พร้อม
4000000000000234	ห้ามใช้	ปฏิเสธทั่วไปจากผู้ออกบัตร

วิธีการชำระเงินทางเลือก

ข้อมูลการทดสอบ PromptPay

ทดสอบการชำระเงินผ่าน PromptPay ในตลาดไทย:

ช่อง	ค่าการทดสอบ	คำอธิบาย
เลขโทรศัพท์	0812345678	หมายเลขมือถือไทยที่ถูกต้อง
เลขโทรศัพท์	+66812345678	ถูกต้องกับรหัสประเทศ
เลขประจำตัวประชาชน	1234567890123	เลขประจำตัวไทย 13 หลักที่ถูกต้อง
จำนวนเงิน	จำนวนใดๆ	ไม่มีขั้นต่ำสำหรับการทดสอบ

ข้อมูลการทดสอบ TrueMoney Wallet

ทดสอบการชำระเงินผ่าน TrueMoney Wallet:

ช่อง	ค่าการทดสอบ	คำอธิบาย
เลขโทรศัพท์	0812345678	หมายเลขมือถือไทยที่ถูกต้อง
จำนวนเงิน	20 - 1000000	จำนวนเงินในหน่วยย่อย THB

สถานการณ์การทดสอบในโลกจริง

สถานการณ์ 1: การทดสอบหลายสกุลเงิน

ทดสอบธุรกรรมเดียวกันในสกุลเงินต่างๆ:

// JavaScript - การทดสอบหลายสกุลเงิน
const currencies = ['THB', 'SGD', 'MYR', 'JPY', 'USD', 'EUR'];
const testCard = '4242424242424242';

async function testMultiCurrency() {
  for (const currency of currencies) {
    try {
      const token = await Omise.tokens.create({
        card: {
          name: 'Test User',
          number: testCard,
          expiration_month: 12,
          expiration_year: 2026,
          security_code: '123'
        }
      });

      const amount = currency === 'JPY' ? 10000 : 100000;

      const charge = await Omise.charges.create({
        amount: amount,
        currency: currency,
        card: token.id,
        description: `Test payment in ${currency}`
      });

      console.log(`${currency}: ${charge.status} - ${charge.id}`);

    } catch (error) {
      console.error(`${currency} failed:`, error.message);
    }
  }
}

testMultiCurrency();

สถานการณ์ 2: การทดสอบขีดจำกัดการชำระเงิน

ทดสอบจำนวนเงินขั้นต่ำและขั้นสูง:

# Python - การทดสอบขีดจำกัดการชำระเงิน
import omise

omise.api_secret = 'skey_test_xxxxxxxxxx'

def test_payment_limits():
    # ทดสอบจำนวนเงินสำหรับสถานการณ์ต่างๆ
    test_amounts = {
        'minimum': 2000,      # 20.00 THB
        'small': 10000,       # 100.00 THB
        'medium': 100000,     # 1,000.00 THB
        'large': 1000000,     # 10,000.00 THB
        'very_large': 10000000  # 100,000.00 THB
    }

    for test_name, amount in test_amounts.items():
        try:
            token = omise.Token.create(
                card={
                    'name': 'Test User',
                    'number': '4242424242424242',
                    'expiration_month': 12,
                    'expiration_year': 2026,
                    'security_code': '123'
                }
            )

            charge = omise.Charge.create(
                amount=amount,
                currency='THB',
                card=token.id,
                description=f'Test {test_name} amount'
            )

            print(f'{test_name} ({amount}): {charge.status}')

        except omise.errors.BaseError as e:
            print(f'{test_name} failed: {e.message}')

test_payment_limits()

สถานการณ์ 3: การทดสอบการชำระเงินพร้อมกัน

ทดสอบการชำระเงินพร้อมกันหลายรายการ:

// JavaScript - การทดสอบการชำระเงินพร้อมกัน
async function testConcurrentPayments() {
  const numberOfPayments = 5;
  const promises = [];

  for (let i = 0; i < numberOfPayments; i++) {
    const promise = (async () => {
      const token = await Omise.tokens.create({
        card: {
          name: `Test User ${i}`,
          number: '4242424242424242',
          expiration_month: 12,
          expiration_year: 2026,
          security_code: '123'
        }
      });

      const charge = await Omise.charges.create({
        amount: 100000,
        currency: 'THB',
        card: token.id,
        description: `Concurrent payment ${i}`
      });

      return { index: i, status: charge.status, id: charge.id };
    })();

    promises.push(promise);
  }

  try {
    const results = await Promise.all(promises);
    results.forEach(result => {
      console.log(`Payment ${result.index}: ${result.status} (${result.id})`);
    });
  } catch (error) {
    console.error('Error in concurrent payments:', error.message);
  }
}

testConcurrentPayments();

สถานการณ์ 4: การทดสอบลำดับการคืนเงิน

ทดสอบลำดับการคืนเงินแบบเต็มและบางส่วน:

# Ruby - การทดสอบลำดับการคืนเงิน
require 'omise'

Omise.api_key = 'skey_test_xxxxxxxxxx'

def test_refund_flow
  begin
    # สร้างประจำที่สำเร็จ
    token = Omise::Token.create(
      card: {
        name: 'Test User',
        number: '4242424242424242',
        expiration_month: 12,
        expiration_year: 2026,
        security_code: '123'
      }
    )

    charge = Omise::Charge.create(
      amount: 100_000,
      currency: 'THB',
      card: token.id
    )

    puts "Charge created: #{charge.id} - #{charge.status}"

    # ทดสอบการคืนเงินแบบเต็ม
    full_refund = Omise::Refund.create(charge.id)
    puts "Full refund: #{full_refund.id} - #{full_refund.amount}"

    # สร้างประจำอื่นสำหรับการทดสอบการคืนเงินบางส่วน
    token2 = Omise::Token.create(
      card: {
        name: 'Test User',
        number: '4242424242424242',
        expiration_month: 12,
        expiration_year: 2026,
        security_code: '123'
      }
    )

    charge2 = Omise::Charge.create(
      amount: 100_000,
      currency: 'THB',
      card: token2.id
    )

    # ทดสอบการคืนเงินบางส่วน (50%)
    partial_refund = Omise::Refund.create(charge2.id, amount: 50_000)
    puts "Partial refund: #{partial_refund.id} - #{partial_refund.amount}"

  rescue Omise::Error => e
    puts "Error: #{e.message}"
  end
end

test_refund_flow

แนวทางปฏิบัติที่ดีสำหรับการทดสอบ

1. ทดสอบสถานะการชำระเงินทั้งหมด

ตรวจสอบว่าการผสานรวมของคุณจัดการกับสถานะการชำระเงินที่เป็นไปได้ทั้งหมด:

• สำเร็จ: การชำระเงินเสร็จสิ้นเรียบร้อย
• อยู่ระหว่างดำเนินการ: รอการดำเนินการจากลูกค้า (3DS, การเปลี่ยนเส้นทาง)
• ล้มเหลว: การชำระเงินปฏิเสธหรือล้มเหลว
• หมดอายุ: การชำระเงินหมดเวลาโดยไม่มีการเสร็จสิ้น
• ย้อนกลับ: การชำระเงินถูกย้อนกลับ (หาร)

2. ทดสอบประเภทบัตรต่างๆ

ทดสอบด้วยแบรนด์บัตรหลายรายเพื่อให้แน่ใจว่าเข้ากันได้:

const testCards = [
  { brand: 'Visa', number: '4242424242424242' },
  { brand: 'Mastercard', number: '5555555555554444' },
  { brand: 'JCB', number: '3530111333300000' },
  { brand: 'Amex', number: '378282246310005' }
];

async function testAllCardBrands() {
  for (const card of testCards) {
    console.log(`Testing ${card.brand}...`);
    // สร้างโทเค็นและประจำ
  }
}

3. ทดสอบกรณีพิเศษ

ทดสอบสถานการณ์ที่ไม่ธรรมชาติแต่ถูกต้อง:

• จำนวนเงินที่มีความแม่นยำทศนิยม
• อักขระนานาชาติในชื่อผู้ถือบัตร
• ความยาวของช่องสูงสุด
• จำนวนเงินขั้นต่ำ
• บัตรเดียวกันหลายครั้ง
• การชำระเงินติดต่อกันอย่างรวดเร็ว

4. ทดสอบการจัดการข้อผิดพลาด

ตรวจสอบว่าแอปพลิเคชันของคุณจัดการข้อผิดพลาดอย่างสวยงาม:

# Python - การจัดการข้อผิดพลาดที่ครอบคลุม
def test_with_error_handling():
    try:
        token = omise.Token.create(
            card={
                'name': 'Test User',
                'number': '4000000000000101',  # จะปฏิเสธ
                'expiration_month': 12,
                'expiration_year': 2026,
                'security_code': '123'
            }
        )

        charge = omise.Charge.create(
            amount=100000,
            currency='THB',
            card=token.id
        )

        if charge.status == 'failed':
            # จัดการการชำระเงินที่ล้มเหลว
            print(f'Payment failed: {charge.failure_code}')
            print(f'Message: {charge.failure_message}')

    except omise.errors.InvalidRequestError as e:
        # จัดการข้อผิดพลาดในการขอ (ข้อผิดพลาดการตรวจสอบ)
        print(f'Invalid request: {e.message}')
    except omise.errors.AuthenticationError as e:
        # จัดการข้อผิดพลาดการตรวจสอบสิทธิ์
        print(f'Authentication error: {e.message}')
    except omise.errors.BaseError as e:
        # จัดการข้อผิดพลาด Omise อื่นๆ
        print(f'Omise error: {e.message}')
    except Exception as e:
        # จัดการข้อผิดพลาดที่ไม่คาดหวัง
        print(f'Unexpected error: {str(e)}')

5. ใช้ข้อมูลเมตาที่อธิบายได้

เพิ่มข้อมูลเมตาเพื่อให้ง่ายต่อการแก้ไขข้อบกพร่อง:

const charge = await Omise.charges.create({
  amount: 100000,
  currency: 'THB',
  card: token.id,
  metadata: {
    test_scenario: 'successful_visa_payment',
    test_run_id: 'test_' + Date.now(),
    environment: 'automated_testing'
  }
});

6. ทดสอบความเป็นปัญหาเดียวกัน

ตรวจสอบว่าจัดการคำขอที่ซ้ำกันอย่างถูกต้อง:

# Ruby - การทดสอบความเป็นปัญหาเดียวกัน
def test_idempotency
  idempotency_key = "test_#{Time.now.to_i}"

  # ทำคำขอเดียวกันสองครั้ง
  2.times do
    charge = Omise::Charge.create(
      {
        amount: 100_000,
        currency: 'THB',
        card: token.id
      },
      { 'Idempotency-Key': idempotency_key }
    )
    puts "Charge ID: #{charge.id}"
  end
  # ทั้งสองคำขอควรส่งกลับรหัสประจำเดียวกัน
end

ตรวจสอบการแก้ไขปัญหา

ปัญหาทั่วไป

ปัญหา: "เลขบัตรไม่ถูกต้อง"

สาเหตุ: ใช้เลขบัตรการผลิตในโหมดการทดสอบ

วิธีแก้ไข: ใช้เลขบัตรทดสอบจากเอกสารนี้ บัตรทดสอบมักจะเริ่มต้นด้วยคำนำหน้าเฉพาะ (เช่น 4242, 5555, 3530)

// ผิด - บัตรจริง
number: '4532015112830366'

// ถูกต้อง - บัตรทดสอบ
number: '4242424242424242'

ปัญหา: การเปลี่ยนเส้นทาง 3D Secure ไม่ทำงาน

สาเหตุ: ขาดหรือ return_uri ไม่ถูกต้อง

วิธีแก้ไข: ตั้งค่า return_uri ที่ถูกต้องเสมอสำหรับการชำระเงิน 3DS:

const charge = await Omise.charges.create({
  amount: 100000,
  currency: 'THB',
  card: token.id,
  return_uri: 'https://example.com/complete' // ต้องสำหรับ 3DS
});

ปัญหา: "จำนวนเงินต่ำกว่าขั้นต่ำ"

สาเหตุ: จำนวนเงินทดสอบต่ำเกินไปสำหรับสกุลเงิน

วิธีแก้ไข: ให้เคารพจำนวนเงินขั้นต่ำ:

• THB: 2000 (20.00 THB)
• SGD: 100 (1.00 SGD)
• MYR: 100 (1.00 MYR)
• JPY: 100 (100 JPY)

คำถามที่พบบ่อย

ฉันสามารถใช้เลขบัตรจริงในโหมดการทดสอบได้หรือไม่

ไม่, โหมดการทดสอบยอมรับเฉพาะเลขบัตรทดสอบ เลขบัตรจริงจะถูกปฏิเสธด้วยข้อผิดพลาด "เลขบัตรไม่ถูกต้อง" นี่คือมาตรการความปลอดภัยเพื่อป้องกันธุรกรรมจริงโดยไม่ตั้งใจในโหมดการทดสอบ

การชำระเงินทดสอบสร้างธุรกรรมจริงหรือไม่

ไม่, การชำระเงินทดสอบถูกแยกออกจากการผลิตอย่างสมบูรณ์ ไม่มีเงินที่เก็บจริง, ไม่มีการเชื่อมต่อธนาคารจริง และข้อมูลการทดสอบไม่มีผลต่อระบบการผลิต

โทเค็นการทดสอบจะเก็บไว้นานแค่ไหน

โทเค็นการทดสอบหมดอายุ 30 นาทีหลังการสร้าง เช่นเดียวกับโทเค็นการผลิต สร้างโทเค็นใหม่เสมอก่อนการใช้งาน

ฉันสามารถทดสอบเวบฮุกด้วยข้อมูลการทดสอบได้หรือไม่

ได้, โหมดการทดสอบส่งเวบฮุกไปยังจุดสิ้นสุดที่กำหนดค่าของคุณเหมือนการผลิต เหตุการณ์เวบฮุกทั้งหมดทำงานในโหมดการทดสอบ ดูคำแนะนำการทดสอบเวบฮุกสำหรับรายละเอียด

บัตรทดสอบ 3D Secure ต้องการการตรวจสอบสิทธิ์จริงหรือไม่

ไม่, บัตรทดสอบ 3D Secure จำลองลำดับการไหลของการตรวจสอบสิทธิ์โดยไม่ต้องการการตรวจสอบสิทธิ์ธนาคารจริง สภาพแวดล้อมการทดสอบจัดการกระบวนการ 3DS โดยอัตโนมัติ

ฉันสามารถทดสอบการคืนเงินในโหมดการทดสอบได้หรือไม่

ได้, การดำเนินการคืนเงินทั้งหมดทำงานในโหมดการทดสอบ คุณสามารถสร้างการคืนเงินแบบเต็มและบางส่วนบนประจำการทดสอบ การคืนเงินจะดำเนินการทันทีในโหมดการทดสอบ (ไม่มีการล่าช้า)

ฉันสามารถทดสอบเหตุผลการปฏิเสธเฉพาะต่างๆ ได้อย่างไร

ใช้เลขบัตรทดสอบเฉพาะที่อยู่ในส่วนเลขบัตรทดสอบที่ปฏิเสธ แต่ละบัตรเรียกใช้เหตุผลการปฏิเสธเฉพาะ

ทรัพยากรที่เกี่ยวข้อง

• คำแนะนำโหมดการทดสอบ - คำแนะนำที่สมบูรณ์สำหรับการใช้โหมดการทดสอบ
• การจำลองความล้มเหลว - การทดสอบสถานการณ์ข้อผิดพลาดและกรณีพิเศษ
• การทดสอบเวบฮุก - ลักษณะและเครื่องมือการทดสอบเวบฮุก
• การตรวจสอบสิทธิ์ API - ทำความเข้าใจคีย์การทดสอบเทียบกับการผลิต
• อ้างอิงรหัสข้อผิดพลาด - รายชื่อรหัสข้อผิดพลาดทั้งหมดและความหมาย
• คำแนะนำ 3D Secure - ความเข้าใจการตรวจสอบสิทธิ์ 3D Secure
• วิธีการชำระเงิน - วิธีการชำระเงินที่รองรับทั้งหมด

ขั้นตอนถัดไป

1. ทดสอบการชำระเงินสำเร็จ ด้วยบัตรทดสอบมาตรฐาน
2. ทดสอบลำดับการไหล 3D Secure ด้วยบัตรทดสอบลงทะเบียน
3. ทดสอบสถานการณ์การปฏิเสธ ด้วยบัตรปฏิเสธเฉพาะ
4. ทดสอบวิธีการชำระเงินตามภูมิภาค สำหรับตลาดเป้าหมายของคุณ
5. ตั้งค่าการทดสอบเวบฮุก เพื่อจัดการเหตุการณ์การชำระเงิน
6. ใช้การจัดการข้อผิดพลาด สำหรับสถานการณ์ความล้มเหลวทั้งหมด
7. ทดสอบลำดับการคืนเงิน เพื่อให้แน่ใจว่าการจัดการที่เหมาะสม
8. เรียกใช้การทดสอบอัตโนมัติ ด้วยชุดการทดสอบของคุณ

พร้อมทดสอบสถานการณ์ข้อผิดพลาด ดูการจำลองความล้มเหลว

ต้องการทดสอบเวบฮุก ดูการทดสอบเวบฮุก