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

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

Firebase Local Emulator Suiteช่วยให้ตรวจสอบแอปโดยละเอียดได้ง่ายขึ้น ฟีเจอร์และลักษณะการทำงาน และยัง เครื่องมือที่ยอดเยี่ยมในการตรวจสอบการกำหนดค่า Firebase Security Rules ของคุณ ใช้โปรแกรมจำลอง Firebase เพื่อเรียกใช้และทำให้การทดสอบ 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 อื่นๆ Google อีกด้วย โปรดทราบว่าขั้นตอนการตรวจสอบสิทธิ์ 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 ลักษณะการทำงานเกือบทั้งหมดที่คุณอาจต้องการทดสอบ รวมถึงฟังก์ชันแบบไม่พร้อมกัน และโมดูลการทดสอบได้รับการออกแบบมาให้ทำงานร่วมกับ โค้ดที่อิงตามคำมั่นสัญญา

ไลบรารีการทดสอบหน่วยกฎ 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.

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

การสร้างและกำหนดค่า 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

// 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 ซึ่งจะใช้การข้ามกฎ Security บริบทที่เกี่ยวข้องและแสดงคำสัญญา บริบทจะถูกทำลายเมื่อสัญญา แก้ไข / ปฏิเสธ

RulesTestEnvironment.cleanup()

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

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

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

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

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

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

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

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

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

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

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

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

Cloud Firestore

RulesTestEnvironment.clearFirestore() => Promise<void>

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

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

เมธอดนี้จะได้รับอินสแตนซ์ Firestore สำหรับบริบทการทดสอบนี้ ผลลัพธ์ อินสแตนซ์ SDK ของไคลเอ็นต์ Firebase JS ใช้ได้กับ API ของไคลเอ็นต์ SDK (v9 modular v9 modular) หรือความเข้ากันได้กับ v9)

Realtime Database

RulesTestEnvironment.clearDatabase() => Promise<void>

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

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

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

Cloud Storage

RulesTestEnvironment.clearStorage() => Promise<void>

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

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

เมธอดนี้จะแสดงอินสแตนซ์พื้นที่เก็บข้อมูลที่กำหนดค่าไว้เพื่อเชื่อมต่อกับโปรแกรมจำลอง เมธอดนี้ยอมรับ URL gs:// ไปยังที่เก็บข้อมูล 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

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

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

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