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

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

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

หากคุณยังไม่ได้ทำ โปรดตั้งค่า 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 จะไม่สำเร็จ)

การโต้ตอบกับ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>

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

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

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

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

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

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

คุณนำเข้าไลบรารีโดยใช้คำสั่งนำเข้าโมดูลาร์ 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.

เมื่อนำเข้าแล้ว การใช้ Unit Test จะเกี่ยวข้องกับสิ่งต่อไปนี้

การสร้างและกำหนดค่า 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().doc('/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()

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

วิธีการนี้ใช้ฟังก์ชันการโทรกลับ ซึ่งใช้บริบทการข้ามกฎความปลอดภัย และส่งคืนคำสัญญา ระบบจะทำลายบริบทเมื่อ 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 (v9 แบบโมดูลาร์หรือ v9 ที่เข้ากันได้)

Realtime Database

RulesTestEnvironment.clearDatabase() => Promise<void>

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

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

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

Cloud Storage

RulesTestEnvironment.clearStorage() => Promise<void>

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

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

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

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

เลือกผลิตภัณฑ์เพื่อดูวิธีการที่ใช้โดย 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

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

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

assertSucceeds(pr: Promise) => 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 ที่เริ่มต้นแล้วซึ่งสอดคล้องกับชื่อฐานข้อมูลและการลบล้างตัวแปร auth ที่ระบุในตัวเลือก

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" และ "กฎ" ของคุณเป็นสตริง

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

apps() => [FirebaseApp]

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

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

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

assertFails(pr: Promise) => Promise

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

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

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

assertSucceeds(pr: Promise) => 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

แสดงผล 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"
});

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

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

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

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

assertSucceeds(pr: Promise) => 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

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

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

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

assertSucceeds(pr: Promise) => Promise

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

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