หน้านี้จะอธิบายถึงแนวทางปฏิบัติแนะนำและเครื่องมือสำหรับการเขียนหน่วยทดสอบสำหรับฟังก์ชัน เช่น การทดสอบที่จะเป็นส่วนหนึ่งของระบบการผสานรวมอย่างต่อเนื่อง (CI) เพื่อให้การทดสอบง่ายขึ้น Firebase มี Firebase Test SDK สำหรับ Cloud Functions โดยมีการเผยแพร่ใน npm ในรูปแบบ firebase-functions-test
และเป็น SDK การทดสอบที่แสดงร่วมกันแก่ firebase-functions
Firebase Test SDK สำหรับ Cloud Functions
- ดูแลการตั้งค่าและการแยกส่วนที่เหมาะสมสำหรับการทดสอบ เช่น การตั้งค่าและยกเลิกการตั้งค่าตัวแปรสภาพแวดล้อมที่
firebase-functions
จำเป็นต้องใช้ - สร้างข้อมูลตัวอย่างและบริบทเหตุการณ์เพื่อให้คุณต้องระบุเฉพาะช่องที่เกี่ยวข้องกับการทดสอบเท่านั้น
ทดสอบการตั้งค่า
ติดตั้งทั้ง firebase-functions-test
และ Mocha ซึ่งเป็นเฟรมเวิร์กการทดสอบ โดยเรียกใช้คำสั่งต่อไปนี้ในโฟลเดอร์ฟังก์ชัน
npm install --save-dev firebase-functions-test
npm install --save-dev mocha
จากนั้นให้สร้างโฟลเดอร์ test
ในโฟลเดอร์ฟังก์ชัน สร้างไฟล์ใหม่ในโฟลเดอร์นั้นสำหรับโค้ดทดสอบ และตั้งชื่อว่า index.test.js
สุดท้ายให้แก้ไข functions/package.json
เพื่อเพิ่มสิ่งต่อไปนี้
"scripts": {
"test": "mocha --reporter spec"
}
เมื่อเขียนการทดสอบแล้ว คุณจะเรียกใช้การทดสอบได้โดยเรียกใช้ npm test
ภายในไดเรกทอรีฟังก์ชัน
การเริ่มต้น Firebase Test SDK สำหรับ Cloud Functions
คุณใช้ firebase-functions-test
ได้ 2 วิธีดังนี้
- โหมดออนไลน์ (แนะนำ): เขียนการทดสอบที่โต้ตอบกับโปรเจ็กต์ Firebase สำหรับทดสอบโดยเฉพาะเพื่อให้การเขียนฐานข้อมูล การสร้างโดยผู้ใช้ ฯลฯ เกิดขึ้นจริง และโค้ดทดสอบสามารถตรวจสอบผลลัพธ์ได้ ซึ่งหมายความว่า SDK อื่นๆ ของ Google ที่ใช้ในฟังก์ชันของคุณจะใช้งานได้เช่นกัน
- โหมดออฟไลน์: เขียนการทดสอบหน่วยโฆษณาแบบแยกส่วนและออฟไลน์โดยไม่มีผลข้างเคียง ซึ่งหมายความว่าคุณจะต้องตัดการเรียกเมธอดที่โต้ตอบกับผลิตภัณฑ์ Firebase (เช่น การเขียนลงในฐานข้อมูลหรือการสร้างผู้ใช้) โดยทั่วไปเราไม่แนะนำให้ใช้โหมดออฟไลน์หากคุณมีฟังก์ชัน Cloud Firestore หรือ Realtime Database เนื่องจากโหมดนี้จะเพิ่มความซับซ้อนของโค้ดทดสอบอย่างมาก
เริ่มต้น SDK ในโหมดออนไลน์ (แนะนำ)
หากต้องการเขียนการทดสอบที่โต้ตอบกับโปรเจ็กต์ทดสอบ คุณต้องจัดเตรียมค่าของการกำหนดค่าโปรเจ็กต์ที่จำเป็นสำหรับการเริ่มต้นแอปผ่าน firebase-admin
และเส้นทางไปยังไฟล์คีย์บัญชีบริการ
วิธีรับการกำหนดค่าของโปรเจ็กต์ Firebase
- เปิดการตั้งค่าโปรเจ็กต์ในคอนโซล Firebase
- ในแอปของคุณ ให้เลือกแอปที่ต้องการ
ในแผงด้านขวา ให้เลือกตัวเลือกเพื่อดาวน์โหลดไฟล์การกำหนดค่าสำหรับแอป Apple และ Android
สำหรับเว็บแอป ให้เลือกการกำหนดค่าเพื่อแสดงค่าของการกำหนดค่า
วิธีสร้างไฟล์คีย์
- เปิดแผงบัญชีบริการของคอนโซล Google Cloud
- เลือกบัญชีบริการเริ่มต้นของ App Engine และใช้เมนูตัวเลือกที่ด้านขวาเพื่อเลือกสร้างคีย์
- เมื่อมีข้อความแจ้ง ให้เลือก JSON สำหรับประเภทคีย์ และคลิกสร้าง
หลังจากบันทึกไฟล์คีย์แล้ว ให้เริ่มต้น SDK ดังนี้
// At the top of test/index.test.js
const test = require('firebase-functions-test')({
databaseURL: 'https://my-project.firebaseio.com',
storageBucket: 'my-project.appspot.com',
projectId: 'my-project',
}, 'path/to/serviceAccountKey.json');
เริ่มต้น SDK ในโหมดออฟไลน์
หากต้องการเขียนการทดสอบแบบออฟไลน์ทั้งหมด คุณสามารถเริ่มต้น SDK ได้โดยไม่ต้องมีพารามิเตอร์ใดๆ ดังนี้
// At the top of test/index.test.js
const test = require('firebase-functions-test')();
การจำลองการกำหนดค่า
หากใช้ functions.config()
ในโค้ดฟังก์ชัน คุณจะจำลองการกำหนดค่าได้ ตัวอย่างเช่น หาก functions/index.js
มีโค้ดต่อไปนี้
const functions = require('firebase-functions');
const key = functions.config().stripe.key;
จากนั้นคุณจะจำลองค่าภายในไฟล์ทดสอบได้ดังนี้
// Mock functions config values
test.mockConfig({ stripe: { key: '23wr42ewr34' }});
การนำเข้าฟังก์ชัน
หากต้องการนำเข้าฟังก์ชัน ให้ใช้ require
เพื่อนำเข้าไฟล์ฟังก์ชันหลักเป็นโมดูล โปรดดำเนินการนี้หลังจากกำหนดค่าเริ่มต้น firebase-functions-test
เท่านั้น
และจำลองการกำหนดค่า
// after firebase-functions-test has been initialized
const myFunctions = require('../index.js'); // relative path to functions code
หากคุณเริ่มต้น firebase-functions-test
ในโหมดออฟไลน์ และคุณมี admin.initializeApp()
ในโค้ดฟังก์ชัน คุณจะต้องหยุดคีย์ก่อนที่จะนำเข้าฟังก์ชัน ดังนี้
// If index.js calls admin.initializeApp at the top of the file, // we need to stub it out before requiring index.js. This is because the // functions will be executed as a part of the require process. // Here we stub admin.initializeApp to be a dummy function that doesn't do anything. adminInitStub = sinon.stub(admin, 'initializeApp'); // Now we can require index.js and save the exports inside a namespace called myFunctions. myFunctions = require('../index');
การทดสอบฟังก์ชันพื้นหลัง (ไม่ใช่ HTTP)
กระบวนการทดสอบฟังก์ชันที่ไม่ใช่ HTTP เกี่ยวข้องกับขั้นตอนต่อไปนี้
- ตัดฟังก์ชันที่คุณต้องการทดสอบด้วยเมธอด
test.wrap
- สร้างข้อมูลทดสอบ
- เรียกใช้ฟังก์ชันที่รวมไว้ด้วยข้อมูลทดสอบที่คุณสร้างและช่องบริบทเหตุการณ์ที่ต้องการระบุ
- ยืนยันเกี่ยวกับพฤติกรรม
ก่อนอื่น ให้รวมฟังก์ชันที่ต้องการทดสอบ สมมติว่าคุณมีฟังก์ชันใน functions/index.js
ชื่อ makeUppercase
ซึ่งต้องการทดสอบ เขียนรายการต่อไปนี้ใน functions/test/index.test.js
// "Wrap" the makeUpperCase function from index.js
const myFunctions = require('../index.js');
const wrapped = test.wrap(myFunctions.makeUppercase);
wrapped
คือฟังก์ชันที่จะเรียกใช้ makeUppercase
เมื่อมีการเรียกใช้ wrapped
ใช้พารามิเตอร์ 2 ตัว ได้แก่
- data (ต้องระบุ): ข้อมูลที่จะส่งถึง
makeUppercase
ซึ่งจะสอดคล้องโดยตรงกับพารามิเตอร์แรกที่ส่งไปยังเครื่องจัดการฟังก์ชันที่คุณเขียนไว้firebase-functions-test
ให้วิธีการในการสร้างข้อมูลที่กำหนดเองหรือข้อมูลตัวอย่าง - eventContextOptions (ไม่บังคับ): ช่องของบริบทเหตุการณ์ที่ต้องการระบุ บริบทเหตุการณ์คือพารามิเตอร์ที่ 2 ที่ส่งไปยังเครื่องจัดการฟังก์ชันที่คุณเขียนไว้ หากคุณไม่ได้รวมพารามิเตอร์
eventContextOptions
เมื่อเรียกใช้wrapped
ระบบจะยังคงสร้างบริบทเหตุการณ์โดยมีช่องที่เหมาะสม คุณลบล้างช่องที่สร้างขึ้นบางช่องได้โดยระบุช่องเหล่านั้นที่นี่ โปรดทราบว่าคุณจะต้องรวมเฉพาะช่อง ที่ต้องการลบล้างเท่านั้น ระบบจะสร้างช่องที่คุณไม่ได้ลบล้าง
const data = … // See next section for constructing test data
// Invoke the wrapped function without specifying the event context.
wrapped(data);
// Invoke the function, and specify params
wrapped(data, {
params: {
pushId: '234234'
}
});
// Invoke the function, and specify auth and auth Type (for real time database functions only)
wrapped(data, {
auth: {
uid: 'jckS2Q0'
},
authType: 'USER'
});
// Invoke the function, and specify all the fields that can be specified
wrapped(data, {
eventId: 'abc',
timestamp: '2018-03-23T17:27:17.099Z',
params: {
pushId: '234234'
},
auth: {
uid: 'jckS2Q0' // only for real time database functions
},
authType: 'USER' // only for real time database functions
});
การสร้างข้อมูลทดสอบ
พารามิเตอร์แรกของฟังก์ชันที่รวมไว้เป็นข้อมูลทดสอบที่จะเรียกใช้ฟังก์ชันพื้นฐาน การสร้างข้อมูลทดสอบมีหลายวิธี
การใช้ข้อมูลที่กำหนดเอง
firebase-functions-test
มีฟังก์ชันจำนวนมากสำหรับการสร้างข้อมูลที่จำเป็นต่อการทดสอบฟังก์ชัน เช่น ใช้ test.firestore.makeDocumentSnapshot
เพื่อสร้าง Firestore DocumentSnapshot
อาร์กิวเมนต์แรกคือข้อมูล และอาร์กิวเมนต์ที่ 2 คือเส้นทางการอ้างอิงแบบเต็ม และมีอาร์กิวเมนต์ที่ 3 ที่ไม่บังคับสำหรับพร็อพเพอร์ตี้อื่นๆ ของสแนปชอตที่คุณระบุได้
// Make snapshot
const snap = test.firestore.makeDocumentSnapshot({foo: 'bar'}, 'document/path');
// Call wrapped function with the snapshot
const wrapped = test.wrap(myFunctions.myFirestoreDeleteFunction);
wrapped(snap);
หากทดสอบฟังก์ชัน onUpdate
หรือ onWrite
คุณจะต้องสร้างสแนปชอต 2 รายการ โดยรายการหนึ่งสำหรับสถานะก่อนและอีกรายการสำหรับสถานะ "หลัง" จากนั้น คุณจะใช้เมธอด makeChange
เพื่อสร้างออบเจ็กต์ Change
ด้วยสแนปชอตเหล่านี้ได้
// Make snapshot for state of database beforehand
const beforeSnap = test.firestore.makeDocumentSnapshot({foo: 'bar'}, 'document/path');
// Make snapshot for state of database after the change
const afterSnap = test.firestore.makeDocumentSnapshot({foo: 'faz'}, 'document/path');
const change = test.makeChange(beforeSnap, afterSnap);
// Call wrapped function with the Change object
const wrapped = test.wrap(myFunctions.myFirestoreUpdateFunction);
wrapped(change);
ดูข้อมูลอ้างอิง API สำหรับฟังก์ชันที่คล้ายกันสำหรับข้อมูลประเภทอื่นๆ ทั้งหมด
การใช้ข้อมูลตัวอย่าง
หากคุณไม่จำเป็นต้องปรับแต่งข้อมูลที่ใช้ในการทดสอบ firebase-functions-test
จะเสนอวิธีสร้างข้อมูลตัวอย่างสำหรับฟังก์ชันแต่ละประเภท
// For Firestore onCreate or onDelete functions
const snap = test.firestore.exampleDocumentSnapshot();
// For Firestore onUpdate or onWrite functions
const change = test.firestore.exampleDocumentSnapshotChange();
โปรดดูวิธีรับข้อมูลตัวอย่างสำหรับฟังก์ชันทุกประเภทได้ที่ข้อมูลอ้างอิง API
กำลังใช้ข้อมูลที่ถูกตัดเนื้อหา (สำหรับโหมดออฟไลน์)
หากเริ่มต้น SDK ในโหมดออฟไลน์ และกำลังทดสอบฟังก์ชัน Cloud Firestore หรือ Realtime Database คุณควรใช้ออบเจ็กต์ธรรมดาที่มีต้นขั้วแทนการสร้าง DocumentSnapshot
หรือ DataSnapshot
จริง
สมมติว่าคุณกำลังเขียนการทดสอบ 1 หน่วยสำหรับฟังก์ชันต่อไปนี้
// Listens for new messages added to /messages/:pushId/original and creates an // uppercase version of the message to /messages/:pushId/uppercase exports.makeUppercase = functions.database.ref('/messages/{pushId}/original') .onCreate((snapshot, context) => { // Grab the current value of what was written to the Realtime Database. const original = snapshot.val(); functions.logger.log('Uppercasing', context.params.pushId, original); const uppercase = original.toUpperCase(); // You must return a Promise when performing asynchronous tasks inside a Functions such as // writing to the Firebase Realtime Database. // Setting an "uppercase" sibling in the Realtime Database returns a Promise. return snapshot.ref.parent.child('uppercase').set(uppercase); });
ภายในฟังก์ชัน ระบบจะใช้ snap
2 ครั้งดังนี้
snap.val()
snap.ref.parent.child('uppercase').set(uppercase)
ในโค้ดทดสอบ ให้สร้างออบเจ็กต์พื้นฐานที่เส้นทางโค้ดทั้ง 2 แบบจะทำงานได้ และใช้ Sinon เพื่อกำหนดวิธีการ
// The following lines creates a fake snapshot, 'snap', which returns 'input' when snap.val() is called, // and returns true when snap.ref.parent.child('uppercase').set('INPUT') is called. const snap = { val: () => 'input', ref: { parent: { child: childStub, } } }; childStub.withArgs(childParam).returns({ set: setStub }); setStub.withArgs(setParam).returns(true);
การยืนยัน
หลังจากเริ่มต้น SDK, การรวมฟังก์ชัน และการสร้างข้อมูลแล้ว คุณจะเรียกใช้ฟังก์ชันที่ปกปิดด้วยข้อมูลที่สร้างขึ้นและยืนยันลักษณะการทำงานได้ คุณสามารถใช้ไลบรารี เช่น Chai เพื่อยืนยันรายการเหล่านี้
การยืนยันในโหมดออนไลน์
หากเริ่มต้น Firebase Test SDK สำหรับ Cloud Functions ในโหมดออนไลน์ คุณจะยืนยันได้ว่าการดำเนินการที่ต้องการ (เช่น การเขียนฐานข้อมูล) เกิดขึ้นโดยใช้ firebase-admin
SDK
ตัวอย่างด้านล่างยืนยันว่ามีการเขียน "INPUT" ลงในฐานข้อมูลของโปรเจ็กต์ทดสอบแล้ว
// Create a DataSnapshot with the value 'input' and the reference path 'messages/11111/original'. const snap = test.database.makeDataSnapshot('input', 'messages/11111/original'); // Wrap the makeUppercase function const wrapped = test.wrap(myFunctions.makeUppercase); // Call the wrapped function with the snapshot you constructed. return wrapped(snap).then(() => { // Read the value of the data at messages/11111/uppercase. Because `admin.initializeApp()` is // called in functions/index.js, there's already a Firebase app initialized. Otherwise, add // `admin.initializeApp()` before this line. return admin.database().ref('messages/11111/uppercase').once('value').then((createdSnap) => { // Assert that the value is the uppercased version of our input. assert.equal(createdSnap.val(), 'INPUT'); }); });
การยืนยันในโหมดออฟไลน์
คุณสามารถยืนยันค่าผลตอบแทนที่คาดไว้ของฟังก์ชันได้ ดังนี้
const childParam = 'uppercase'; const setParam = 'INPUT'; // Stubs are objects that fake and/or record function calls. // These are excellent for verifying that functions have been called and to validate the // parameters passed to those functions. const childStub = sinon.stub(); const setStub = sinon.stub(); // The following lines creates a fake snapshot, 'snap', which returns 'input' when snap.val() is called, // and returns true when snap.ref.parent.child('uppercase').set('INPUT') is called. const snap = { val: () => 'input', ref: { parent: { child: childStub, } } }; childStub.withArgs(childParam).returns({ set: setStub }); setStub.withArgs(setParam).returns(true); // Wrap the makeUppercase function. const wrapped = test.wrap(myFunctions.makeUppercase); // Since we've stubbed snap.ref.parent.child(childParam).set(setParam) to return true if it was // called with the parameters we expect, we assert that it indeed returned true. return assert.equal(wrapped(snap), true);
คุณยังสามารถใช้สายลับ Sinon เพื่อยืนยันว่ามีการเรียกวิธีการบางอย่างโดยใช้พารามิเตอร์ที่คุณคาดไว้
การทดสอบฟังก์ชัน HTTP
หากต้องการทดสอบฟังก์ชัน HTTP onCall ให้ใช้วิธีการเดียวกันกับการทดสอบฟังก์ชันพื้นหลัง
หากกำลังทดสอบฟังก์ชัน HTTP onRequest คุณควรใช้ firebase-functions-test
ในกรณีต่อไปนี้
- คุณใช้
functions.config()
- ฟังก์ชันของคุณจะโต้ตอบกับโปรเจ็กต์ Firebase หรือ Google API อื่นๆ และคุณต้องการใช้โปรเจ็กต์ Firebase จริงและข้อมูลเข้าสู่ระบบของโปรเจ็กต์สำหรับการทดสอบ
ฟังก์ชัน HTTP onRequest มีพารามิเตอร์ 2 ตัว ได้แก่ ออบเจ็กต์คำขอและออบเจ็กต์การตอบกลับ ต่อไปนี้คือวิธีทดสอบฟังก์ชันตัวอย่าง addMessage()
- ลบล้างฟังก์ชันการเปลี่ยนเส้นทางในออบเจ็กต์การตอบสนอง เนื่องจาก
sendMessage()
เรียกใช้ฟังก์ชันดังกล่าว - ภายในฟังก์ชันเปลี่ยนเส้นทาง ให้ใช้ chai.assert เพื่อช่วยยืนยันว่าควรใช้พารามิเตอร์ใดในฟังก์ชันการเปลี่ยนเส้นทาง:
// A fake request object, with req.query.text set to 'input' const req = { query: {text: 'input'} }; // A fake response object, with a stubbed redirect function which asserts that it is called // with parameters 303, 'new_ref'. const res = { redirect: (code, url) => { assert.equal(code, 303); assert.equal(url, 'new_ref'); done(); } }; // Invoke addMessage with our fake request and response objects. This will cause the // assertions in the response object to be evaluated. myFunctions.addMessage(req, res);
ทดสอบการล้างข้อมูล
ที่ส่วนท้ายสุดของโค้ดทดสอบ ให้เรียกใช้ฟังก์ชันทำความสะอาด การดำเนินการนี้จะยกเลิกการตั้งค่าตัวแปรสภาพแวดล้อมที่ SDK ตั้งค่าเมื่อเริ่มต้น และลบแอป Firebase ที่อาจสร้างขึ้นหากคุณใช้ SDK ในการสร้างฐานข้อมูลแบบเรียลไทม์ DataSnapshot
หรือ Firestore DocumentSnapshot
test.cleanup();
ดูตัวอย่างทั้งหมดและดูข้อมูลเพิ่มเติม
คุณดูตัวอย่างทั้งหมดได้ในที่เก็บ Firebase GitHub
- การทดสอบฐานข้อมูลเรียลไทม์และฟังก์ชัน HTTP ในโหมดออนไลน์
- การทดสอบฐานข้อมูลเรียลไทม์และฟังก์ชัน HTTP ในโหมดออฟไลน์
ดูข้อมูลเพิ่มเติมได้ในเอกสารอ้างอิง API สำหรับ firebase-functions-test