Cloud Code Functions
Unit Testing pada Cloud Code Menggunakan Parse di Back4App

22min
Cara Membuat Unit Test melalui Fungsi Cloud Code mereka
Pendahuluan
Bagian ini akan memungkinkan Anda untuk memeriksa operasi dan pengujian fungsi Anda secara lokal menggunakan pustaka parse-server-test-runner.
Prasyarat
Untuk menyelesaikan tutorial ini, Anda akan membutuhkan:

Lingkungan lokal dengan Node.js terinstal untuk menerapkan unit test. Anda dapat mengikuti tutorial resmi NodeJS untuk berhasil menginstal Node.js di terminal Anda.
Sebuah aplikasi yang dibuat di Back4App.
Ikuti tutorial Membuat Aplikasi Baru untuk belajar cara membuat aplikasi di Back4App.
Back4App Command Line yang dikonfigurasi dengan proyek.
Ikuti tutorial Menyiapkan Cloud Code untuk belajar cara menyiapkan cloud code untuk proyek.
Pertama-tama, kita perlu membicarakan tentang Unit Test!
Ketika pengembang mulai menulis fungsi dengan berbagai niat dalam pikiran, satu poin utama yang terlihat di komunitas perangkat lunak adalah penerapan skenario imajiner untuk kode yang dibuat agar dapat diuji. Sangat penting untuk melakukan prosedur Unit Tests karena ini memungkinkan Anda untuk menguji kode secara terpisah, yang memastikan bahwa kode utama Anda tetap utuh dan tidak terganggu.
Dan sekarang, bagaimana dengan contoh praktis yang sederhana?
Mari kita anggap bahwa Anda perlu menulis sebuah fungsi untuk menunjukkan dalam kalimat lengkap, nama dari pekerja, posisi dan perusahaan. Kita perlu menulis fungsi untuk mendapatkan item input berikut:
Perusahaan
Posisi
Nama pekerja
Langkah-langkah untuk menyelesaikan tes sederhana
Di terminal Anda, pertama-tama, kita akan membuat direktori dan mengonfigurasi Aplikasi tes Anda (package.json) terlebih dahulu, menggunakan perintah berikut:
$ mkdir unit-test-sample && cd unit-test-sample
$ npm init
Petunjuk:
Menggunakan npm init perintah, Anda akan dapat membuat file package.json. Ini hanya mencakup item yang paling umum dan mencoba menebak default yang masuk akal. Karena itu, kita akan menyediakan dependensi yang diperlukan agar kode dapat berfungsi.
Hasil dari “package.json” akan menjadi sesuatu seperti contoh di bawah ini:
JSON
{
  "name": "yourfoldername",
  "version": "1.0.0",
  "description": "Just a unit test with using a simple function.",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "repository": {
    "type": "git",
    "url": ""
  },
  "author": "Your Name",
  "license": "ISC",
  "bugs": {
    "url": "{url}/issues"
  },
  "homepage": ""
}
{
  "name": "yourfoldername",
  "version": "1.0.0",
  "description": "Just a unit test with using a simple function.",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "repository": {
    "type": "git",
    "url": ""
  },
  "author": "Your Name",
  "license": "ISC",
  "bugs": {
    "url": "{url}/issues"
  },
  "homepage": ""
}
﻿
Sekarang, mari kita buat file (index.js) menggunakan perintah di bawah ini:
~/unit-test-sample$ touch index.js
Kami sekarang akan memasukkan kode di bawah ini ke dalam file yang telah dibuat sebelumnya, dan fungsi ini akan memasukkan contoh yang dapat mendemonstrasikan tes ini dengan kode:
JS
1   // index.js
2     module.exports = function(name, position, company) {
3     let sentence = "Hi, " + name + "! You are " + position + " in " + company + " company.";
4       return sentence;
5     };
1   // index.js
2     module.exports = function(name, position, company) {
3     let sentence = "Hi, " + name + "! You are " + position + " in " + company + " company.";
4       return sentence;
5     };
﻿
Di NodeJS, modul mengenkapsulasi kode terkait ke dalam satu unit kode, dan ketika Anda menggunakan module.exports, itu meningkatkan kode yang terenkapsulasi yang dapat digunakan di file lain.
Mari kita uji 0/
Akhirnya, Anda dapat bekerja dengan terminal Anda:
~/unit-test-sample$ node
> var moduleBack4App = require('./index.js');
undefined
> moduleBack4App("Jonathan", "Developer", "Back4App")
Hi, Jonathan! Anda adalah Developer di perusahaan Back4App.
Petunjuk:
 Menggunakan require() fungsi, Anda dapat mengimpor dan mengekspor modul, dan dalam kasus di atas, kami menggunakan fungsi ini untuk memerlukan file di dalam aplikasi.
Dan menggunakan Parse, bisakah saya menguji fungsi saya?
Tentu saja, sebagai parameter uji, kami akan membuat backend untuk mengontrol informasi karyawan perusahaan.
Mari kita strukturkan kelas sebagai:
Parse.User (Referensi untuk karyawan)
username, email, password (diperlukan)
Kami merekomendasikan Anda untuk melihat dengan seksama Panduan Parse Server untuk mendapatkan informasi lebih lanjut tentang properti User.
infoEmployee
Posisi
Departemen
ShiftKerja
userId (Pointer)
1 - Pahami struktur akhir kami
Mari kita mulai! Kami akan menggunakan Panduan Javascript Parse Server sebagai parameter untuk pengembangan fungsi kami. Pertama, setelah menyelesaikan pengaturan menggunakan Antarmuka Baris Perintah (lihat prasyarat), kita akan memahami bagaimana ini akan bekerja dengan struktur akhir dari file-file:
├──ProyekBack4App
│  ├── cloud
│  │   ├── functions.js
│  │   ├── main.js
│  ├── publik
│  ├── package.json
│  ├── index.js
│  ├── node_modules
│  ├── src
│  │   ├── jasmine.js
Perhatian: Ketika Anda mengunggah file ke Cloud Code Anda, Antarmuka Baris Perintah (Lihat prasyarat) akan mengabaikan file lain dan hanya mengunggah file yang ada di folder publik dan cloud.
2 - Menulis fungsi kami
Setelah mengonfigurasi lingkungan untuk Antarmuka Baris Perintah, kita akan menulis fungsi untuk membangun proses untuk mendaftarkan Karyawan dan menyimpan informasi tambahan. Dengan merombak kode, di file main.js, kita akan mengimpor fungsi-fungsi ini ke dalam main, seperti:
JS
1   //In 1cloud/main.js
2
3   var cloudFunctions = require("./functions");
4
5   /* It's necessary to insert the Parse Instance in our code,
6   because at local context not is referenced.*/
7
8   Parse.Cloud.define("registerUser",  cloudFunctions.registerUser(Parse));
9
10  Parse.Cloud.beforeSave("infoEmployee", infoEmployee.infoEmployee(Parse));
1   //In 1cloud/main.js
2
3   var cloudFunctions = require("./functions");
4
5   /* It's necessary to insert the Parse Instance in our code,
6   because at local context not is referenced.*/
7
8   Parse.Cloud.define("registerUser",  cloudFunctions.registerUser(Parse));
9
10  Parse.Cloud.beforeSave("infoEmployee", infoEmployee.infoEmployee(Parse));
﻿
Ide ini adalah untuk memisahkan fungsi dari antarmuka cloud sehingga kita dapat mengujinya tanpa mengirim permintaan HTTP secara tidak efisien. Ini akan sangat masuk akal saat kita membuat suite pengujian.
Parse Server 3.X
Parse Server 2.X
1   //In cloud/functions.js
2
3   module.exports.registerUser = function(Parse){
4     return function (request, response){
5       var params = request.params; //Parameters received
6
7       var infoEmployee = Parse.Object.extend("infoEmployee"); //Store Information      
8
9       var userCreated = new Parse.User({
10        "email" : params.email,
11        "username": params.username,
12        "password" : params.password
13      })
14
15      //Save relation
16      userCreated.save().then((updatedUser) => {
17        var information = new infoEmployee({
18          "position"   : params.position,
19          "department" : params.department,
20          "workShift"  : params.shift,
21          "user" : updatedUser
22        });
23        return information.save();
24      }).then((info) => response.success(info))
25        .catch((e) => {
26          response.error(e.message);
27        })
28    }
29  }
30
31  module.exports.infoEmployee = function(Parse){
32    return function (request, response){
33      var req = request.object;
34
35      if (!req.get("position") || !req.get("department") || !req.get("workShift")) {
36        response.error("Missing params! The required parameters are: position, department. workShift");
37      } else {
38        response.success();
39      }
40    }
41  }
1   //In cloud/functions.js
2
3   module.exports.registerUser = function(Parse){
4     return function (request, response){
5       var params = request.params; //Parameters received
6
7       var infoEmployee = Parse.Object.extend("infoEmployee"); //Store Information      
8
9       var userCreated = new Parse.User({
10        "email" : params.email,
11        "username": params.username,
12        "password" : params.password
13      })
14
15      //Save relation
16      userCreated.save().then((updatedUser) => {
17        var information = new infoEmployee({
18          "position"   : params.position,
19          "department" : params.department,
20          "workShift"  : params.shift,
21          "user" : updatedUser
22        });
23        return information.save();
24      }).then((info) => response.success(info))
25        .catch((e) => {
26          response.error(e.message);
27        })
28    }
29  }
30
31  module.exports.infoEmployee = function(Parse){
32    return function (request, response){
33      var req = request.object;
34
35      if (!req.get("position") || !req.get("department") || !req.get("workShift")) {
36        response.error("Missing params! The required parameters are: position, department. workShift");
37      } else {
38        response.success();
39      }
40    }
41  }
﻿
 3 - Menyiapkan lingkungan untuk menguji kode di atas!
Untuk suite pengujian kami, kami akan menggunakan Jasmine, sebuah kerangka pengujian JavaScript yang sangat populer. Namun, kode kami sejauh ini sepenuhnya netral terhadap pengujian kami, jadi Anda dapat menggunakan kerangka kerja atau platform apa pun yang Anda pilih.
Instal ketergantungan pengembangan
Mari kita instal Jasmine secara global dan gunakan, dengan perintah di bawah ini:
~/Back4AppProject$ sudo npm install -g jasmine
~/Back4AppProject$ jasmine
Acak dengan benih 48094
Dimulai


Tidak ada spesifikasi ditemukan
Selesai dalam 0.002 detik
Tidak lengkap: Tidak ada spesifikasi ditemukan
4 - Mengonfigurasi Penguji Parse Server di folder
Dengan metode kami yang diterapkan di folder Cloud proyek di Back4App, kami akan membuat file baru di proyek kami di Node.js yang akan mengonfigurasi interaksi ini.
~/Back4AppProjectsrc$ touch index.js
~/Back4AppProject$ mkdir src && cd src
~/Back4AppProject/src$ touch jasmine.js
Sekarang, kita akan mengonfigurasi file yang dibuat di atas dengan kode yang ditunjukkan di bawah ini:
index.js
jasmine.js
1   const Promise = require('bluebird');
2     const express = require('express');
3     const http = require('http');
4     const {MongoClient} = require('mongodb');
5     const {ParseServer} = require('parse-server');
6
7     const mongoDBRunnerStart = require('mongodb-runner/mocha/before').bind({
8      timeout() {
9       },
10      slow() {
11      },
12    });
13    const mongoDBRunnerStop = require('mongodb-runner/mocha/after');
14
15    const startDB = () => (
16      new Promise((done, reject) => {
17        done.fail = reject;
18        mongoDBRunnerStart(done);
19      })
20    );
21
22    const stopDB = () => (
23      new Promise((done, reject) => {
24        done.fail = reject;
25        mongoDBRunnerStop(done);
26      })
27    );
28
29    const connectDB = (databaseURI) => new Promise((resolve, reject) => {
30      MongoClient.connect(databaseURI, (err, db) => {
31        if (err) {
32          reject(err);
33        } else {
34          resolve(db);
35        }
36      });
37    });
38
39    let parseServerState = {};
40
41    const dropDB = () => {
42      const {mongoConnection} = parseServerState;
43      return mongoConnection.dropDatabaseAsync();
44    };
45
46    /**
47      * Starts the ParseServer idropDatabaseAsyncnstance
48      * @param {Object} parseServerOptions Used for creating the `ParseServer`
49      * @return {Promise} Runner state
50     */
51    function startParseServer(parseServerOptions = {}) {
52      const mongodbPort = process.env.MONGODB_PORT || 27017;
53      const {
54        databaseName = 'parse-test',
55        databaseURI = 'mongodb://localhost:${mongodbPort}/${databaseName}',
56        masterKey = 'test',
57        javascriptKey = 'test',
58        appId = 'test',
59
60        port = 30001,
61        mountPath = '/1',
62        serverURL = 'http://localhost:${port}${mountPath}',
63      } = parseServerOptions;
64
65      return startDB()
66        .then(() => connectDB(databaseURI))
67        .then((mongoConnection) => {
68         parseServerOptions = Object.assign({
69            masterKey, javascriptKey, appId,
70            serverURL,
71            databaseURI,
72            silent: process.env.VERBOSE !== '1',
73          }, parseServerOptions);
74          const app = express();
75          const parseServer = new ParseServer(parseServerOptions);
76
77          app.use(mountPath, parseServer);
78
79          const httpServer = http.createServer(app);
80
81          Promise.promisifyAll(httpServer);
82          Promise.promisifyAll(mongoConnection);
83
84          return httpServer.listenAsync(port)
85            .then(() => Object.assign(parseServerState, {
86              parseServer,
87              httpServer,
88              mongoConnection,
89              expressApp: app,
90              parseServerOptions,
91            }));
92        });
93    }
94
95  /**
96   * Stops the ParseServer instance
97   * @return {Promise}
98   */
99    function stopParseServer() {
100     const {httpServer} = parseServerState;
101     return httpServer.closeAsync()
102       .then(stopDB)
103       .then(() => parseServerState = {});
104   }
105 
106   module.exports = {
107     dropDB,
108     startParseServer,
109     stopParseServer,
110     parseServerState,
111   };
1   const Promise = require('bluebird');
2     const express = require('express');
3     const http = require('http');
4     const {MongoClient} = require('mongodb');
5     const {ParseServer} = require('parse-server');
6
7     const mongoDBRunnerStart = require('mongodb-runner/mocha/before').bind({
8      timeout() {
9       },
10      slow() {
11      },
12    });
13    const mongoDBRunnerStop = require('mongodb-runner/mocha/after');
14
15    const startDB = () => (
16      new Promise((done, reject) => {
17        done.fail = reject;
18        mongoDBRunnerStart(done);
19      })
20    );
21
22    const stopDB = () => (
23      new Promise((done, reject) => {
24        done.fail = reject;
25        mongoDBRunnerStop(done);
26      })
27    );
28
29    const connectDB = (databaseURI) => new Promise((resolve, reject) => {
30      MongoClient.connect(databaseURI, (err, db) => {
31        if (err) {
32          reject(err);
33        } else {
34          resolve(db);
35        }
36      });
37    });
38
39    let parseServerState = {};
40
41    const dropDB = () => {
42      const {mongoConnection} = parseServerState;
43      return mongoConnection.dropDatabaseAsync();
44    };
45
46    /**
47      * Starts the ParseServer idropDatabaseAsyncnstance
48      * @param {Object} parseServerOptions Used for creating the `ParseServer`
49      * @return {Promise} Runner state
50     */
51    function startParseServer(parseServerOptions = {}) {
52      const mongodbPort = process.env.MONGODB_PORT || 27017;
53      const {
54        databaseName = 'parse-test',
55        databaseURI = 'mongodb://localhost:${mongodbPort}/${databaseName}',
56        masterKey = 'test',
57        javascriptKey = 'test',
58        appId = 'test',
59
60        port = 30001,
61        mountPath = '/1',
62        serverURL = 'http://localhost:${port}${mountPath}',
63      } = parseServerOptions;
64
65      return startDB()
66        .then(() => connectDB(databaseURI))
67        .then((mongoConnection) => {
68         parseServerOptions = Object.assign({
69            masterKey, javascriptKey, appId,
70            serverURL,
71            databaseURI,
72            silent: process.env.VERBOSE !== '1',
73          }, parseServerOptions);
74          const app = express();
75          const parseServer = new ParseServer(parseServerOptions);
76
77          app.use(mountPath, parseServer);
78
79          const httpServer = http.createServer(app);
80
81          Promise.promisifyAll(httpServer);
82          Promise.promisifyAll(mongoConnection);
83
84          return httpServer.listenAsync(port)
85            .then(() => Object.assign(parseServerState, {
86              parseServer,
87              httpServer,
88              mongoConnection,
89              expressApp: app,
90              parseServerOptions,
91            }));
92        });
93    }
94
95  /**
96   * Stops the ParseServer instance
97   * @return {Promise}
98   */
99    function stopParseServer() {
100     const {httpServer} = parseServerState;
101     return httpServer.closeAsync()
102       .then(stopDB)
103       .then(() => parseServerState = {});
104   }
105 
106   module.exports = {
107     dropDB,
108     startParseServer,
109     stopParseServer,
110     parseServerState,
111   };
﻿
Langkah terakhir adalah mengonfigurasi package.json, menggunakan perintah: $ npm init di direktori root (file di bawah ini hanya contoh dengan modul yang diperlukan):
JSON
1   {
2     "name": "back4approject",
3     "version": "1.0.0",
4     "description": "Back4App guide using for reference the Parse Server Test Runner",
5     "main": "index.js",
6     "engines": {
7       "node": ">=6"
8     },
9     "repository": {
10      "type": "",
11      "url": ""
12    },
13    "keywords": [
14      "parse",
15      "parse-server",
16      "testing",
17      "tests"
18    ],
19    "author": "",
20    "license": "ISC",
21    "dependencies": {
22      "bluebird": "^3.5.0",
23      "express": "latest",
24      "mongodb": "^2.2.30",
25      "mongodb-runner": "^3.5.0",
26      "parse": "^1.10.0",
27      "parse-server": "^2.5.3",
28      "parse-server-test-runner": "^1.0.0"
29    }
30  }
1   {
2     "name": "back4approject",
3     "version": "1.0.0",
4     "description": "Back4App guide using for reference the Parse Server Test Runner",
5     "main": "index.js",
6     "engines": {
7       "node": ">=6"
8     },
9     "repository": {
10      "type": "",
11      "url": ""
12    },
13    "keywords": [
14      "parse",
15      "parse-server",
16      "testing",
17      "tests"
18    ],
19    "author": "",
20    "license": "ISC",
21    "dependencies": {
22      "bluebird": "^3.5.0",
23      "express": "latest",
24      "mongodb": "^2.2.30",
25      "mongodb-runner": "^3.5.0",
26      "parse": "^1.10.0",
27      "parse-server": "^2.5.3",
28      "parse-server-test-runner": "^1.0.0"
29    }
30  }
﻿
Dan sekarang, Anda akan memeriksa bahwa kita mendekati struktur yang dijelaskan dalam langkah-langkah sebelumnya :)
5 - Kembali ke terminal
Kami akan mulai mengonfigurasi pengujian lokal, untuk ini kami akan mengikuti perintah di bawah ini untuk mengatur secara programatis untuk tujuan pengujian.
~/Back4AppProject$ # di direktori yang sama dari package.json
~/Back4AppProject$ npm install
Setelah instalasi berhasil, Anda dapat memeriksa pengujian unit Anda secara lokal dengan perintah yang dijelaskan dan menerima hasilnya, seperti:
~/Back4AppProject$ jasmine src/jasmine.js
Diacak dengan seed 79055
Dimulai
✔  Diunduh MongoDB 3.6.5
[]
.


1 spesifikasi, 0 kegagalan
Selesai dalam 19.983 detik
Diacak dengan seed 79055 (jasmine --random=true --seed=79055)


Luar biasa, sudah siap!
Dengan panduan yang dijelaskan di atas, Anda dapat bekerja dengan Parse Server Test Runner dan fungsi-fungsi yang dikembangkan untuk Cloud Code ke Back4App.
Diperbarui 27 Jan 2025
Apakah halaman ini membantu Anda?
SEBELUMNYA
Cara Memulai Proyek Xamarin dengan Template Visual Studio
BERIKUTNYA
Menganalisis Kompleksitas Kode Cloud dengan Plato Di Back4App