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

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

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

หากคุณยังไม่ได้ ดำเนินการ ให้ตั้งค่า Firebase Emulators

ก่อนที่คุณจะเรียกใช้โปรแกรมจำลอง

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

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

ความแตกต่างระหว่างตัวจำลองฐานข้อมูลและการผลิต

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

การโต้ตอบกับโปรแกรมจำลองฐานข้อมูลเรียลไทม์

อินสแตนซ์ 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 ต่อไป

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

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

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

ไลบรารี v9 Rules Unit Testing รับรู้ถึงโปรแกรมจำลองเสมอและไม่เคยแตะต้องทรัพยากรการผลิตของคุณ

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

import {
  assertFails,
  assertSucceeds,
  initializeTestEnvironment,
  RulesTestEnvironment,
} 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.

เมื่อนำเข้าแล้ว การดำเนินการทดสอบหน่วยเกี่ยวข้องกับ:

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

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

ดู วิธีการทดสอบเฉพาะของอีมูเลเตอร์โดยใช้โมดูลาร์ API

initializeTestEnvironment() => RulesTestEnvironment

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

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

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

หมายเหตุ: อีมูเลเตอร์ยืนยันข้อมูลระหว่างการเรียกทดสอบในการเรียกใช้อีมูเลเตอร์เดี่ยว สิ่งนี้อาจส่งผลต่อผลลัพธ์ของคุณ หากต้องการล้างข้อมูลระหว่างการทดสอบแต่ละครั้ง ให้เรียกใช้เมธอด clear emulator data ที่เกี่ยวข้อง เช่น clearFirestoreData ระหว่างการทดสอบ

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

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

ใช้ออบเจกต์บริบทการทดสอบที่ส่งคืนในการทดสอบของคุณเพื่อเข้าถึงอินสแตนซ์อีมูเลเตอร์ที่กำหนดค่าไว้ รวมถึงอินสแตนซ์ที่กำหนดค่าด้วย 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 ซึ่งทำงานเหมือนไคลเอนต์ที่ไม่ได้ล็อกอินผ่านการรับรองความถูกต้อง คำขอที่สร้างผ่านบริบทที่ส่งกลับจะไม่มีการแนบโทเค็น Firebase Auth

// 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()

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

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

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 สำหรับบริบทการทดสอบนี้ อินสแตนซ์ SDK ของไคลเอ็นต์ Firebase JS ที่ส่งคืนใช้กับไคลเอ็นต์ SDK API ได้ (v9 แบบโมดูลาร์หรือ v9 ที่เข้ากันได้)

ฐานข้อมูลเรียลไทม์

RulesTestEnvironment.clearDatabase() => Promise<void>

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

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

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

การจัดเก็บเมฆ

RulesTestEnvironment.clearStorage() => Promise<void>

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

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

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

เรียกใช้การทดสอบหน่วยภายในด้วย 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"
});

ฐานข้อมูลเรียลไทม์

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

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

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

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"));

การจัดเก็บเมฆ

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());

API ไลบรารี RUT สำหรับ 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"
});

ฐานข้อมูลเรียลไทม์

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"));

การจัดเก็บเมฆ

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());