Watch demos on how to build & run AI-powered apps with Firebase at Demo Day '24. Watch now.

หน้านี้ได้รับการแปลโดย Cloud Translation API

สร้างการทดสอบ 1 หน่วย

Firebase Local Emulator Suite ช่วยให้ตรวจสอบฟีเจอร์และลักษณะการทำงานของแอปได้อย่างสมบูรณ์ได้ง่ายขึ้น นอกจากนี้ ยังใช้ยืนยันการกําหนดค่า Firebase Security Rules ได้อย่างยอดเยี่ยม ใช้ Firebase Emulator เพื่อเรียกใช้และทำให้การทดสอบ 1 หน่วยเป็นไปโดยอัตโนมัติในสภาพแวดล้อมในเครื่อง วิธีการที่ระบุไว้ในเอกสารนี้จะช่วยคุณสร้างและทำให้การทดสอบหน่วยสำหรับแอปของคุณเป็นแบบอัตโนมัติซึ่งจะตรวจสอบ Rules

ตั้งค่าโปรแกรมจำลอง Firebase หากยังไม่ได้ดำเนินการ

ก่อนเรียกใช้โปรแกรมจำลอง

ก่อนที่คุณจะเริ่มใช้โปรแกรมจำลอง โปรดคำนึงถึงสิ่งต่อไปนี้

ในตอนแรกโปรแกรมจำลองจะโหลดกฎที่ระบุในช่อง firestore.rules หรือ "storage.rules" ของไฟล์ firebase.json หากไม่มีไฟล์อยู่และคุณไม่ได้ใช้เมธอด loadFirestoreRules หรือ "loadStorageRules" ตามที่อธิบายไว้ด้านล่าง โปรแกรมจำลองจะถือว่าโปรเจ็กต์ทั้งหมดมีกฎแบบเปิด
แม้ว่า Firebase SDK ส่วนใหญ่จะทำงานร่วมกับโปรแกรมจำลองโดยตรงได้ แต่มีเพียงไลบรารี @firebase/rules-unit-testing เท่านั้นที่รองรับการจำลอง auth ในกฎการรักษาความปลอดภัย ซึ่งทำให้การทดสอบ 1 หน่วยง่ายขึ้นมาก นอกจากนี้ ไลบรารียังสนับสนุนคุณลักษณะเฉพาะโปรแกรมจำลองบางอย่าง เช่น การล้างข้อมูลทั้งหมด ตามที่แสดงด้านล่าง
นอกจากนี้ โปรแกรมจำลองจะยอมรับโทเค็นการตรวจสอบสิทธิ์ Firebase ที่ใช้งานจริงที่ให้บริการผ่าน SDK ของไคลเอ็นต์ และประเมินกฎให้สอดคล้องกัน ซึ่งทำให้สามารถเชื่อมต่อแอปพลิเคชันกับโปรแกรมจำลองได้โดยตรงในการผสานรวมและการทดสอบด้วยตนเอง

ความแตกต่างระหว่างโปรแกรมจำลองฐานข้อมูลกับเวอร์ชันที่ใช้งานจริง

คุณไม่จำเป็นต้องสร้างอินสแตนซ์ฐานข้อมูลอย่างชัดแจ้ง โปรแกรมจำลองจะสร้างอินสแตนซ์ฐานข้อมูลที่เข้าถึงโดยอัตโนมัติ
ฐานข้อมูลใหม่แต่ละรายการจะเริ่มต้นด้วยกฎแบบปิด ดังนั้นผู้ใช้ที่ไม่ใช่ผู้ดูแลระบบจะอ่านหรือเขียนไม่ได้
ฐานข้อมูลที่จําลองแต่ละแห่งจะใช้ขีดจํากัดและโควต้าของแพ็กเกจ Spark (โดยเฉพาะอย่างยิ่ง แต่ละอินสแตนซ์จะจำกัดการเชื่อมต่อพร้อมกันไว้ที่ 100 รายการ)
ฐานข้อมูลใดๆ จะยอมรับสตริง "owner" เป็นโทเค็นการตรวจสอบสิทธิ์ของผู้ดูแลระบบ
ปัจจุบันโปรแกรมจำลองยังไม่มีการโต้ตอบที่ใช้งานได้กับผลิตภัณฑ์ Firebase อื่นๆ โปรดทราบว่าขั้นตอนการตรวจสอบสิทธิ์ Firebase ปกติไม่ทำงาน แต่คุณใช้เมธอด initializeTestApp() ในไลบรารี rules-unit-testing ได้แทน ซึ่งจะใช้ฟิลด์ auth ออบเจ็กต์ Firebase ที่สร้างขึ้นโดยใช้วิธีนี้จะทํางานราวกับได้รับการตรวจสอบสิทธิ์เป็นเอนทิตีที่คุณระบุเรียบร้อยแล้ว หากคุณส่ง null ระบบจะทํางานเป็นผู้ใช้ที่ไม่ได้รับการตรวจสอบสิทธิ์ (เช่น กฎ auth != null จะใช้งานไม่ได้)

การโต้ตอบกับโปรแกรมจำลอง Realtime Database

คุณเข้าถึงอินสแตนซ์ Firebase Realtime Database เวอร์ชันที่ใช้งานจริงได้ที่โดเมนย่อยของ firebaseio.com และจะเข้าถึง REST API ได้โดยทำดังนี้

https://<database_name>.firebaseio.com/path/to/my/data.json

โปรแกรมจำลองจะทำงานภายในเครื่องและพร้อมให้ใช้งานที่ localhost:9000 หากต้องการโต้ตอบกับอินสแตนซ์ฐานข้อมูลหนึ่งๆ คุณจะต้องใช้พารามิเตอร์การค้นหา ns เพื่อระบุชื่อฐานข้อมูล

http://localhost:9000/path/to/my/data.json?ns=<database_name>

เรียกใช้การทดสอบหน่วยในเครื่องด้วย JavaScript SDK เวอร์ชัน 9

Firebase เผยแพร่ไลบรารีการทดสอบหน่วยของกฎการรักษาความปลอดภัยซึ่งมี JavaScript SDK ทั้งเวอร์ชัน 9 และ SDK เวอร์ชัน 8 API ของไลบรารีแตกต่างกันอย่างมาก เราขอแนะนําให้ใช้คลังการทดสอบ v9 ซึ่งมีประสิทธิภาพมากขึ้นและตั้งค่าเพื่อเชื่อมต่อกับโปรแกรมจำลองได้ง่ายขึ้น จึงหลีกเลี่ยงการใช้ทรัพยากรเวอร์ชันที่ใช้งานจริงโดยไม่ตั้งใจได้อย่างปลอดภัย เรายังคงให้บริการคลังการทดสอบ v8 ต่อไปเพื่อให้ใช้งานย้อนหลังได้

วิธีการทดสอบทั่วไปและฟังก์ชันยูทิลิตีใน SDK เวอร์ชัน 9
วิธีการทดสอบเฉพาะโปรแกรมจำลองใน SDK เวอร์ชัน 9

ใช้โมดูล @firebase/rules-unit-testing เพื่อโต้ตอบกับโปรแกรมจำลองที่ทำงานในเครื่อง หากได้รับข้อผิดพลาดเกี่ยวกับเวลาหมดหรือ ECONNREFUSED ให้ตรวจสอบอีกครั้งว่าโปรแกรมจำลองทำงานอยู่

เราขอแนะนําอย่างยิ่งให้ใช้ Node.js เวอร์ชันล่าสุดเพื่อให้คุณใช้การเขียนโปรแกรมแบบ async/await ได้ ลักษณะการทำงานเกือบทั้งหมดที่คุณอาจต้องการทดสอบจะเกี่ยวข้องกับฟังก์ชันแบบไม่พร้อมกัน และโมดูลการทดสอบได้รับการออกแบบมาให้ทำงานกับโค้ดที่อิงตามสัญญา

ไลบรารีการทดสอบ 1 หน่วยของกฎเวอร์ชัน 9 จะรับรู้ถึงโปรแกรมจำลองเสมอและจะไม่แตะต้องทรัพยากรเวอร์ชันที่ใช้งานจริง

คุณนำเข้าไลบรารีโดยใช้คำสั่งการนำเข้าแบบโมดูล v9 เช่น

import {
  assertFails,
  assertSucceeds,
  initializeTestEnvironment
} from "@firebase/rules-unit-testing"

// Use `const { … } = require("@firebase/rules-unit-testing")` if imports are not supported
// Or we suggest `const testing = require("@firebase/rules-unit-testing")` if necessary.

เมื่อนำเข้าแล้ว การใช้การทดสอบ 1 หน่วยเกี่ยวข้องกับสิ่งต่อไปนี้

การสร้างและกำหนดค่า RulesTestEnvironment ด้วยการเรียกใช้ initializeTestEnvironment
การตั้งค่าข้อมูลทดสอบโดยไม่ทริกเกอร์ Rules โดยใช้วิธีการที่สะดวกซึ่งช่วยให้คุณข้ามได้ชั่วคราว RulesTestEnvironment.withSecurityRulesDisabled
การตั้งค่าชุดการทดสอบและก่อน/หลังการทดสอบฮุกที่มีการเรียกใช้เพื่อล้างข้อมูลทดสอบและสภาพแวดล้อม เช่น RulesTestEnvironment.cleanup() หรือ RulesTestEnvironment.clearFirestore()
การใช้กรณีทดสอบที่จำลองสถานะการตรวจสอบสิทธิ์โดยใช้ RulesTestEnvironment.authenticatedContext และ RulesTestEnvironment.unauthenticatedContext

ได้ด้วย

วิธีการทั่วไปและฟังก์ชันยูทิลิตี

โปรดดูวิธีการทดสอบเฉพาะโปรแกรมจำลองโดยใช้ API แบบโมดูลด้วย

initializeTestEnvironment() => RulesTestEnvironment

ฟังก์ชันนี้จะเริ่มต้นสภาพแวดล้อมการทดสอบสำหรับการทดสอบหน่วยของกฎ เรียกใช้ฟังก์ชันนี้ก่อนเพื่อตั้งค่าการทดสอบ โปรแกรมจำลองต้องทำงานอยู่เพื่อให้การดำเนินการสำเร็จ

ฟังก์ชันนี้จะยอมรับออบเจ็กต์ที่ไม่บังคับซึ่งกำหนด TestEnvironmentConfig ซึ่งอาจประกอบด้วยรหัสโปรเจ็กต์และการตั้งค่าการจําลอง

let testEnv = await initializeTestEnvironment({
  projectId: "demo-project-1234",
  firestore: {
    rules: fs.readFileSync("firestore.rules", "utf8"),
  },
});

หมายเหตุ: โปรแกรมจำลองจะเก็บข้อมูลไว้ระหว่างการเรียกใช้การทดสอบในการเรียกใช้โปรแกรมจำลองครั้งเดียว ซึ่งอาจส่งผลต่อผลลัพธ์ หากต้องการล้างข้อมูลระหว่างการทดสอบแต่ละครั้ง ให้เรียกใช้เมธอดล้างข้อมูลโปรแกรมจำลองที่เกี่ยวข้อง เช่น clearFirestoreData ระหว่างการทดสอบ

RulesTestEnvironment.authenticatedContext({ user_id: string, tokenOptions?: TokenOptions }) => RulesTestContext

วิธีนี้จะสร้าง RulesTestContext ซึ่งทํางานเหมือนผู้ใช้ Authentication ที่ตรวจสอบสิทธิ์แล้ว คําขอที่สร้างผ่านบริบทที่แสดงผลจะมีโทเค็นจำลองAuthentication แนบอยู่ (ไม่บังคับ) ส่งออบเจ็กต์ที่กําหนดการอ้างสิทธิ์ที่กําหนดเองหรือการลบล้างสําหรับเพย์โหลดโทเค็น Authentication

ใช้ออบเจ็กต์บริบทการทดสอบที่แสดงผลในการทดสอบเพื่อเข้าถึงอินสแตนซ์โปรแกรมจำลองที่กําหนดค่าไว้ รวมถึงอินสแตนซ์ที่กําหนดค่าด้วย initializeTestEnvironment

// Assuming a Firestore app and the Firestore emulator for this example
import { setDoc } from "firebase/firestore";

const alice = testEnv.authenticatedContext("alice", { … });
// Use the Firestore instance associated with this context
await assertSucceeds(setDoc(alice.firestore(), '/users/alice'), { ... });

RulesTestEnvironment.unauthenticatedContext() => RulesTestContext

วิธีนี้จะสร้าง RulesTestContext ซึ่งทํางานเหมือนไคลเอ็นต์ที่ไม่ได้เข้าสู่ระบบผ่าน Authentication คำขอที่สร้างผ่านบริบทที่แสดงผลจะไม่มีโทเค็น Firebase Auth แนบอยู่

ใช้ออบเจ็กต์บริบททดสอบที่ส่งคืนในการทดสอบเพื่อเข้าถึงอินสแตนซ์โปรแกรมจำลองที่กำหนดค่าไว้ รวมถึงอินสแตนซ์ที่กำหนดค่าด้วย initializeTestEnvironment

// Assuming a Cloud Storage app and the Storage emulator for this example
import { getStorage, ref, deleteObject } from "firebase/storage";

const alice = testEnv.unauthenticatedContext();

// Use the Cloud Storage instance associated with this context
const desertRef = ref(alice.storage(), 'images/desert.jpg');
await assertSucceeds(deleteObject(desertRef));

RulesTestEnvironment.withSecurityRulesDisabled()

เรียกใช้ฟังก์ชันการตั้งค่าการทดสอบที่มีบริบทที่ทํางานเหมือนกับว่ากฎการรักษาความปลอดภัยถูกปิดใช้

เมธอดนี้ใช้ฟังก์ชัน Callback ซึ่งใช้บริบทการลบล้างกฎด้านความปลอดภัยและแสดงผลพรอมต์ บริบทจะถูกทำลายเมื่อ Promise ดำเนินการเสร็จสมบูรณ์/ปฏิเสธ

RulesTestEnvironment.cleanup()

วิธีนี้จะทำลาย RulesTestContexts ทั้งหมดที่สร้างขึ้นในสภาพแวดล้อมการทดสอบและล้างทรัพยากรที่เกี่ยวข้องเพื่อให้ออกจากระบบได้อย่างเรียบร้อย

วิธีนี้จะไม่เปลี่ยนสถานะของโปรแกรมจำลองไม่ว่าในทางใดก็ตาม หากต้องการรีเซ็ตข้อมูลระหว่างการทดสอบ ให้ใช้วิธีการล้างข้อมูลเฉพาะสำหรับโปรแกรมจำลองแอปพลิเคชัน

assertSucceeds(pr: Promise<any>)) => Promise<any>

นี่คือฟังก์ชันยูทิลิตีของเคสทดสอบ

ฟังก์ชันจะยืนยันว่า Promise ที่ระบุซึ่งรวมการดำเนินการของโปรแกรมจำลองจะได้รับการแก้ไขโดยไม่ละเมิดกฎความปลอดภัย

await assertSucceeds(setDoc(alice.firestore(), '/users/alice'), { ... });

assertFails(pr: Promise<any>)) => Promise<any>

นี่คือฟังก์ชันยูทิลิตีของกรอบการทดสอบ

ฟังก์ชันจะยืนยันว่า Promise ที่ระบุซึ่งรวมการดำเนินการของโปรแกรมจำลองจะได้รับการปฏิเสธเนื่องจากละเมิดกฎความปลอดภัย

await assertFails(setDoc(alice.firestore(), '/users/bob'), { ... });

วิธีการเฉพาะสำหรับโปรแกรมจำลอง

ดูเมธอดการทดสอบทั่วไปและฟังก์ชันยูทิลิตีที่ใช้ API แบบโมดูลด้วย

Cloud Firestore

RulesTestEnvironment.clearFirestore() => Promise<void>

วิธีนี้จะล้างข้อมูลในฐานข้อมูล Firestore ของ projectId ที่กําหนดค่าไว้สําหรับโปรแกรมจําลอง Firestore

RulesTestContext.firestore(settings?: Firestore.FirestoreSettings) => Firestore;

เมธอดนี้จะรับอินสแตนซ์ Firestore สําหรับบริบทการทดสอบนี้ อินสแตนซ์ Firebase JS Client SDK ที่แสดงผลสามารถใช้กับ API ของ SDK ของไคลเอ็นต์ (เวอร์ชัน 9 แบบโมดูลหรือเวอร์ชัน 9 ที่เข้ากันได้)

Realtime Database

RulesTestEnvironment.clearDatabase() => Promise<void>

วิธีนี้จะล้างข้อมูลใน Realtime Database ของ projectId ที่กําหนดค่าไว้สําหรับโปรแกรมจําลอง Realtime Database

RulesTestContext.database(databaseURL?: Firestore.FirestoreSettings) => Firestore;

รับอินสแตนซ์ Realtime Database สําหรับบริบทการทดสอบนี้ อินสแตนซ์ Firebase JS Client SDK ที่แสดงผลสามารถใช้กับ API ของ Client SDK (เวอร์ชัน 9 ขึ้นไปแบบโมดูลหรือที่มีเนมสเปซ) โดยเมธอดนี้จะยอมรับ URL ของอินสแตนซ์ Realtime Database หากระบุ จะแสดงผลอินสแตนซ์สําหรับเนมสเปซเวอร์ชันจําลองซึ่งมีพารามิเตอร์ที่ดึงมาจาก URL

Cloud Storage

RulesTestEnvironment.clearStorage() => Promise<void>

วิธีนี้จะล้างออบเจ็กต์และข้อมูลเมตาในที่เก็บข้อมูลของ projectId ที่กําหนดค่าไว้สําหรับโปรแกรมจําลอง Cloud Storage

RulesTestContext.storage(bucketUrl?: string) => Firebase Storage;

เมธอดนี้จะแสดงอินสแตนซ์ Storage ที่กําหนดค่าให้เชื่อมต่อกับโปรแกรมจําลอง เมธอดนี้ยอมรับ URL gs:// ไปยังที่เก็บข้อมูล Firebase Storage สำหรับการทดสอบ หากระบุ จะแสดงผลอินสแตนซ์ Storage สําหรับชื่อที่เก็บข้อมูลเวอร์ชันจําลอง

เรียกใช้การทดสอบหน่วยในเครื่องด้วย v8 JavaScript SDK

เลือกผลิตภัณฑ์เพื่อดูเมธอดที่ Firebase Test SDK ใช้เพื่อติดต่อกับโปรแกรมจำลอง

Cloud Firestore

initializeTestApp({ projectId: string, auth: Object }) => FirebaseApp

วิธีนี้จะแสดงแอป Firebase เริ่มต้นที่สอดคล้องกับรหัสโปรเจ็กต์และตัวแปรการตรวจสอบสิทธิ์ที่ระบุไว้ในตัวเลือก ใช้ตัวเลือกนี้เพื่อสร้างแอปที่ตรวจสอบสิทธิ์เป็นผู้ใช้ที่เฉพาะเจาะจงเพื่อใช้ในการทดสอบ

firebase.initializeTestApp({
  projectId: "my-test-project",
  auth: { uid: "alice", email: "alice@example.com" }
});

หมายเหตุ: โปรแกรมจำลอง Cloud Firestore จะยังคงเก็บข้อมูลระหว่างการเรียกใช้ทดสอบในการรันโปรแกรมจำลองเดียว ซึ่งอาจส่งผลต่อผลลัพธ์ หากต้องการล้างข้อมูลระหว่างการทดสอบแต่ละครั้ง ให้เรียกใช้เมธอด clearFirestoreData ระหว่างการทดสอบ

initializeAdminApp({ projectId: string }) => FirebaseApp

เมธอดนี้จะแสดงผลแอป Firebase สำหรับผู้ดูแลระบบที่เริ่มต้นแล้ว แอปนี้จะข้ามกฎการรักษาความปลอดภัยเมื่อทำการอ่านและเขียน ใช้เพื่อสร้างแอปที่ตรวจสอบสิทธิ์เป็นผู้ดูแลระบบเพื่อตั้งค่าสถานะสำหรับการทดสอบ

firebase.initializeAdminApp({ projectId: "my-test-project" });

apps() => [FirebaseApp] เมธอดนี้จะแสดงแอปทดสอบและแอปผู้ดูแลระบบที่เริ่มต้นใช้งานอยู่ทั้งหมด ใช้เพื่อล้างแอประหว่างหรือหลังการทดสอบ

Promise.all(firebase.apps().map(app => app.delete()))

loadFirestoreRules({ projectId: string, rules: Object }) => Promise

เมธอดนี้จะส่งกฎไปยังฐานข้อมูลที่ทำงานในเครื่อง โดยใช้ออบเจ็กต์ที่ระบุกฎเป็นสตริง ใช้วิธีนี้เพื่อตั้งค่ากฎของฐานข้อมูล

firebase.loadFirestoreRules({
  projectId: "my-test-project",
  rules: fs.readFileSync("/path/to/firestore.rules", "utf8")
});

assertFails(pr: Promise) => Promise

เมธอดนี้จะแสดงผลลัพธ์เป็นสัญญาที่ถูกปฏิเสธหากอินพุตสำเร็จ หรือแสดงผลลัพธ์เป็นสัญญาที่สำเร็จหากอินพุตถูกปฏิเสธ ใช้เพื่อยืนยันว่าการอ่านหรือเขียนฐานข้อมูลล้มเหลวหรือไม่

firebase.assertFails(app.firestore().collection("private").doc("super-secret-document").get());

assertSucceeds(pr: Promise) => Promise

เมธอดนี้จะแสดงผลลัพธ์เป็นสัญญาที่สำเร็จหากอินพุตสำเร็จและถูกปฏิเสธหากอินพุตถูกปฏิเสธ ใช้เพื่อยืนยันว่าการอ่านหรือเขียนฐานข้อมูลสําเร็จหรือไม่

firebase.assertSucceeds(app.firestore().collection("public").doc("test-document").get());

clearFirestoreData({ projectId: string }) => Promise

วิธีการนี้จะล้างข้อมูลทั้งหมดที่เชื่อมโยงกับโปรเจ็กต์ที่เฉพาะเจาะจงในอินสแตนซ์ Firestore ที่ทำงานอยู่ในเครื่อง ใช้วิธีนี้เพื่อทำความสะอาดหลังการทดสอบ

firebase.clearFirestoreData({
  projectId: "my-test-project"
});

Realtime Database

initializeTestApp({ databaseName: string, auth: Object }) => FirebaseApp

ใช้ตัวเลือกนี้เพื่อสร้างแอปที่ตรวจสอบสิทธิ์เป็นผู้ใช้ที่เฉพาะเจาะจงเพื่อใช้ในการทดสอบ

แสดงผลแอป Firebase ที่เริ่มต้นซึ่งตรงกับชื่อฐานข้อมูลและการลบล้างตัวแปรการตรวจสอบสิทธิ์ที่ระบุในตัวเลือก

firebase.initializeTestApp({
  databaseName: "my-database",
  auth: { uid: "alice" }
});

initializeAdminApp({ databaseName: string }) => FirebaseApp

ใช้ตัวเลือกนี้เพื่อสร้างแอปที่ตรวจสอบสิทธิ์เป็นผู้ดูแลระบบเพื่อตั้งค่าสถานะสำหรับการทดสอบ

แสดงผลแอป Firebase ของผู้ดูแลระบบที่เริ่มต้นซึ่งตรงกับชื่อฐานข้อมูลที่ระบุในตัวเลือก แอปนี้ข้ามกฎการรักษาความปลอดภัยเมื่ออ่านและเขียนลงในฐานข้อมูล

firebase.initializeAdminApp({ databaseName: "my-database" });

loadDatabaseRules({ databaseName: string, rules: Object }) => Promise

ใช้คำสั่งนี้เพื่อตั้งค่ากฎของฐานข้อมูล

ส่งกฎไปยังฐานข้อมูลที่ทำงานในเครื่อง รับออบเจ็กต์ตัวเลือกที่ระบุ "databaseName" และ "rules" เป็นสตริง

firebase
      .loadDatabaseRules({
        databaseName: "my-database",
        rules: "{'rules': {'.read': false, '.write': false}}"
      });

apps() => [FirebaseApp]

แสดงผลแอปทดสอบและแอปผู้ดูแลระบบที่เริ่มต้นแล้วทั้งหมดในปัจจุบัน

ใช้เพื่อล้างแอประหว่างหรือหลังการทดสอบ (โปรดทราบว่าแอปที่เริ่มต้นด้วย Listener ที่ใช้งานอยู่จะป้องกันไม่ให้ออก JavaScript)

 Promise.all(firebase.apps().map(app => app.delete()))

assertFails(pr: Promise) => Promise

แสดงผลพรอมต์ที่ถูกปฏิเสธหากอินพุตสำเร็จ และแสดงผลสำเร็จหากอินพุตถูกปฏิเสธ

ใช้คำสั่งนี้เพื่อยืนยันว่าการอ่านหรือเขียนฐานข้อมูลล้มเหลว

firebase.assertFails(app.database().ref("secret").once("value"));

assertSucceeds(pr: Promise) => Promise

แสดงผลลัพธ์เป็นสัญญาที่สำเร็จหากอินพุตสำเร็จและถูกปฏิเสธหากอินพุตถูกปฏิเสธ

ใช้คำสั่งนี้เพื่อยืนยันว่าการอ่านหรือเขียนฐานข้อมูลสําเร็จ

firebase.assertSucceeds(app.database().ref("public").once("value"));

Cloud Storage

initializeTestApp({ storageBucket: string, auth: Object }) => FirebaseApp

ใช้ตัวเลือกนี้เพื่อสร้างแอปที่ตรวจสอบสิทธิ์ในฐานะผู้ใช้ที่เฉพาะเจาะจงเพื่อใช้ในการทดสอบ

แสดงผลแอป Firebase ที่เริ่มต้นแล้วซึ่งสอดคล้องกับชื่อที่เก็บข้อมูลและลบล้างตัวแปรการตรวจสอบสิทธิ์ที่ระบุไว้ในตัวเลือก

firebase.initializeTestApp({
  storageBucket: "my-bucket",
  auth: { uid: "alice" }
});

initializeAdminApp({ storageBucket: string }) => FirebaseApp

ใช้ตัวเลือกนี้เพื่อสร้างแอปที่ตรวจสอบสิทธิ์ในฐานะผู้ดูแลระบบเพื่อตั้งค่าสถานะสำหรับการทดสอบ

แสดงผลแอป Firebase ของผู้ดูแลระบบที่เริ่มต้นแล้วซึ่งสอดคล้องกับชื่อที่เก็บข้อมูลในตัวเลือก แอปนี้ข้ามกฎความปลอดภัยเมื่ออ่านและเขียนไปยังที่เก็บข้อมูล

firebase.initializeAdminApp({ storageBucket: "my-bucket" });

loadStorageRules({ storageBucket: string, rules: Object }) => Promise

ใช้เพื่อตั้งค่ากฎของที่เก็บข้อมูล

ส่งกฎไปยังที่เก็บข้อมูลที่มีการจัดการในเครื่อง ใช้ออบเจ็กต์ตัวเลือกที่ระบุ "storageBucket" และ "กฎ" เป็นสตริง

firebase
      .loadStorageRules({
        storageBucket: "my-bucket",
        rules: fs.readFileSync("/path/to/storage.rules", "utf8")
      });

apps() => [FirebaseApp]

แสดงผลแอปทดสอบและแอปผู้ดูแลระบบที่เริ่มต้นแล้วทั้งหมดในปัจจุบัน

 Promise.all(firebase.apps().map(app => app.delete()))

assertFails(pr: Promise) => Promise

ใช้ข้อความนี้เพื่อยืนยันว่าที่เก็บข้อมูลของพื้นที่เก็บข้อมูลอ่านหรือเขียนไม่สำเร็จ

firebase.assertFails(app.storage().ref("letters/private.doc").getMetadata());

assertSucceeds(pr: Promise) => Promise

แสดงผลพรอมต์ที่สำเร็จหากอินพุตสำเร็จและถูกปฏิเสธหากอินพุตถูกปฏิเสธ

ใช้คำสั่งนี้เพื่อยืนยันว่าการอ่านหรือเขียนที่เก็บข้อมูลสําเร็จ

firebase.assertFails(app.storage().ref("images/cat.png").getMetadata());

RUT library API สำหรับ JS SDK v8

เลือกผลิตภัณฑ์เพื่อดูวิธีที่ Firebase Test SDK ใช้ในอินเทอร์เฟซด้วยโปรแกรมจำลอง

Cloud Firestore

initializeTestApp({ projectId: string, auth: Object }) => FirebaseApp

firebase.initializeTestApp({
  projectId: "my-test-project",
  auth: { uid: "alice", email: "alice@example.com" }
});

initializeAdminApp({ projectId: string }) => FirebaseApp

firebase.initializeAdminApp({ projectId: "my-test-project" });

Promise.all(firebase.apps().map(app => app.delete()))

loadFirestoreRules({ projectId: string, rules: Object }) => Promise

firebase.loadFirestoreRules({
  projectId: "my-test-project",
  rules: fs.readFileSync("/path/to/firestore.rules", "utf8")
});

assertFails(pr: Promise) => Promise

firebase.assertFails(app.firestore().collection("private").doc("super-secret-document").get());

assertSucceeds(pr: Promise) => Promise

firebase.assertSucceeds(app.firestore().collection("public").doc("test-document").get());

clearFirestoreData({ projectId: string }) => Promise

firebase.clearFirestoreData({
  projectId: "my-test-project"
});

Realtime Database

initializeTestApp({ databaseName: string, auth: Object }) => FirebaseApp

firebase.initializeTestApp({
  databaseName: "my-database",
  auth: { uid: "alice" }
});

initializeAdminApp({ databaseName: string }) => FirebaseApp

firebase.initializeAdminApp({ databaseName: "my-database" });

loadDatabaseRules({ databaseName: string, rules: Object }) => Promise

ใช้คำสั่งนี้เพื่อตั้งค่ากฎของฐานข้อมูล

firebase
      .loadDatabaseRules({
        databaseName: "my-database",
        rules: "{'rules': {'.read': false, '.write': false}}"
      });

apps() => [FirebaseApp]

แสดงผลแอปทดสอบและแอปผู้ดูแลระบบที่เริ่มต้นแล้วทั้งหมดในปัจจุบัน

 Promise.all(firebase.apps().map(app => app.delete()))

assertFails(pr: Promise) => Promise

ใช้คำสั่งนี้เพื่อยืนยันว่าการอ่านหรือเขียนฐานข้อมูลล้มเหลว

firebase.assertFails(app.database().ref("secret").once("value"));

assertSucceeds(pr: Promise) => Promise

ใช้คำสั่งนี้เพื่อยืนยันว่าการอ่านหรือเขียนฐานข้อมูลสําเร็จ

firebase.assertSucceeds(app.database().ref("public").once("value"));

Cloud Storage

initializeTestApp({ storageBucket: string, auth: Object }) => FirebaseApp

firebase.initializeTestApp({
  storageBucket: "my-bucket",
  auth: { uid: "alice" }
});

initializeAdminApp({ storageBucket: string }) => FirebaseApp

firebase.initializeAdminApp({ storageBucket: "my-bucket" });

loadStorageRules({ storageBucket: string, rules: Object }) => Promise

ใช้เพื่อตั้งค่ากฎของที่เก็บข้อมูล

firebase
      .loadStorageRules({
        storageBucket: "my-bucket",
        rules: fs.readFileSync("/path/to/storage.rules", "utf8")
      });

apps() => [FirebaseApp]

แสดงผลแอปทดสอบและแอปผู้ดูแลระบบที่เริ่มต้นแล้วทั้งหมดในปัจจุบัน

 Promise.all(firebase.apps().map(app => app.delete()))

assertFails(pr: Promise) => Promise

firebase.assertFails(app.storage().ref("letters/private.doc").getMetadata());

assertSucceeds(pr: Promise) => Promise

แสดงผลพรอมต์ที่สำเร็จหากอินพุตสำเร็จและถูกปฏิเสธหากอินพุตถูกปฏิเสธ

ใช้ข้อความนี้เพื่อยืนยันว่าที่เก็บข้อมูลของพื้นที่เก็บข้อมูลอ่านหรือเขียนได้สำเร็จ

firebase.assertFails(app.storage().ref("images/cat.png").getMetadata());