');
35 | $container.append($user).append($message);
36 | $chatWindow.append($container);
37 | $chatWindow.scrollTop($chatWindow[0].scrollHeight);
38 | }
39 |
40 | // Alert the user they have been assigned a random username
41 | print('Logging in...');
42 |
43 | // Get an access token for the current user, passing a username (identity)
44 | $.getJSON('/token', function(data) {
45 |
46 |
47 | // Initialize the Chat client
48 | Twilio.Chat.Client.create(data.token).then(client => {
49 | console.log('Created chat client');
50 | chatClient = client;
51 | chatClient.getSubscribedChannels().then(createOrJoinGeneralChannel);
52 |
53 | // when the access token is about to expire, refresh it
54 | chatClient.on('tokenAboutToExpire', function() {
55 | refreshToken(username);
56 | });
57 |
58 | // if the access token already expired, refresh it
59 | chatClient.on('tokenExpired', function() {
60 | refreshToken(username);
61 | });
62 |
63 | // Alert the user they have been assigned a random username
64 | username = data.identity;
65 | print('You have been assigned a random username of: '
66 | + '
' + username + '', true);
67 |
68 | }).catch(error => {
69 | console.error(error);
70 | print('There was an error creating the chat client:
' + error, true);
71 | print('Please check your .env file.', false);
72 | });
73 | });
74 |
75 | function refreshToken(identity) {
76 | console.log('Token about to expire');
77 | // Make a secure request to your backend to retrieve a refreshed access token.
78 | // Use an authentication mechanism to prevent token exposure to 3rd parties.
79 | $.getJSON('/token/' + identity, function(data) {
80 | console.log('updated token for chat client');
81 | chatClient.updateToken(data.token);
82 | });
83 | }
84 |
85 | function createOrJoinGeneralChannel() {
86 | // Get the general chat channel, which is where all the messages are
87 | // sent in this simple application
88 | print('Attempting to join "general" chat channel...');
89 | chatClient.getChannelByUniqueName('general')
90 | .then(function(channel) {
91 | generalChannel = channel;
92 | console.log('Found general channel:');
93 | console.log(generalChannel);
94 | setupChannel();
95 | }).catch(function() {
96 | // If it doesn't exist, let's create it
97 | console.log('Creating general channel');
98 | chatClient.createChannel({
99 | uniqueName: 'general',
100 | friendlyName: 'General Chat Channel'
101 | }).then(function(channel) {
102 | console.log('Created general channel:');
103 | console.log(channel);
104 | generalChannel = channel;
105 | setupChannel();
106 | }).catch(function(channel) {
107 | console.log('Channel could not be created:');
108 | console.log(channel);
109 | });
110 | });
111 | }
112 |
113 | // Set up channel after it has been found
114 | function setupChannel() {
115 | // Join the general channel
116 | generalChannel.join().then(function(channel) {
117 | print('Joined channel as '
118 | + '
' + username + '.', true);
119 | });
120 |
121 | // Listen for new messages sent to the channel
122 | generalChannel.on('messageAdded', function(message) {
123 | printMessage(message.author, message.body);
124 | });
125 | }
126 |
127 | // Send a new message to the general channel
128 | var $input = $('#chat-input');
129 | $input.on('keydown', function(e) {
130 |
131 | if (e.keyCode == 13) {
132 | if (generalChannel === undefined) {
133 | print('The Chat Service is not configured. Please check your .env file.', false);
134 | return;
135 | }
136 | generalChannel.sendMessage($input.val())
137 | $input.val('');
138 | }
139 | });
140 | });
141 |
--------------------------------------------------------------------------------
/public/config-check.js:
--------------------------------------------------------------------------------
1 | $(function() {
2 | $.get('/config', function(response) {
3 | Object.keys(fields).forEach(configureField(fields, response));
4 | Object.keys(buttons).forEach(configureButton(buttons, response));
5 | });
6 |
7 | // Button Ids' and Config Keys
8 | var buttons = {
9 | chatDemoButton: 'TwilioChatServiceSid',
10 | syncDemoButton: 'TwilioSyncServiceSid',
11 | notifyDemoButton: 'TwilioNotificationServiceSid'
12 | };
13 |
14 | // Field Ids' and Masked Flag
15 | var fields = {
16 | twilioAccountSid: false,
17 | twilioApiKey: false,
18 | twilioApiSecret: true,
19 | twilioNotificationServiceSid: false,
20 | twilioChatServiceSid: false,
21 | twilioSyncServiceSid: false
22 | };
23 |
24 | var configureField = function(fields, response) {
25 | var htmlContent = 'Not configured in .env';
26 | var cssClass = 'unset';
27 | return function(fieldId) {
28 | var configKey = strToConfig(fieldId);
29 | var isMasked = fields[fieldId];
30 | if (!!response[configKey]) {
31 | htmlContent = isMasked ? 'Configured properly' : response[configKey];
32 | cssClass = 'set';
33 | }
34 | $('#' + fieldId).html(htmlContent).addClass(cssClass);
35 | };
36 | };
37 |
38 | var configureButton = function(buttons, response) {
39 | var hasBasicConfig = !!response.TWILIO_ACCOUNT_SID &&
40 | !!response.TWILIO_API_KEY &&
41 | !!response.TWILIO_API_SECRET;
42 | return function(buttonId) {
43 | var configKey = strToConfig(buttons[buttonId]);
44 | var cssClass = hasBasicConfig && !!response[configKey]
45 | ? 'btn-success'
46 | : 'btn-danger';
47 | $('#' + buttonId).addClass(cssClass);
48 | };
49 | };
50 |
51 | var strToConfig = function(string) {
52 | return string
53 | .split(/(?=[A-Z])/)
54 | .map(function(e) { return e.toUpperCase(); })
55 | .join('_');
56 | }
57 | });
58 |
--------------------------------------------------------------------------------
/public/index.css:
--------------------------------------------------------------------------------
1 | .config-value.set {
2 | color:seagreen;
3 | }
4 |
5 | .config-value.unset {
6 | color:darkred;
7 | }
--------------------------------------------------------------------------------
/public/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
Twilio Server Starter Kit
5 |
6 |
9 |
10 |
11 |
12 |
13 |
14 |
Twilio Server Starter Kit Environment Setup
15 |
16 |
Account Information
17 |
18 |
19 | | TWILIO_ACCOUNT_SID |
20 | |
21 |
22 |
23 | | TWILIO_API_KEY |
24 | |
25 |
26 |
27 | | TWILIO_API_SECRET |
28 | |
29 |
30 |
31 |
32 |
Products
33 |
34 |
35 | | Notify |
36 | TWILIO_NOTIFICATION_SERVICE_SID |
37 | |
38 |
39 |
40 | | Chat |
41 | TWILIO_CHAT_SERVICE_SID |
42 | |
43 |
44 |
45 | | Sync |
46 | TWILIO_SYNC_SERVICE_SID |
47 | |
48 |
49 |
50 |
51 |
Demos
52 |
Sync
53 |
Notify
54 |
Chat
55 |
56 |
57 |
58 |
61 |
62 |
63 |
64 |
--------------------------------------------------------------------------------
/public/notify/facebook_messenger.html:
--------------------------------------------------------------------------------
1 |
2 |
27 |
32 |
33 |
34 |
--------------------------------------------------------------------------------
/public/notify/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
Hello App! - Notify Quickstart
5 |
6 |
7 |
8 |
9 |
10 |
15 |
16 |
27 |
28 |
29 |
30 |
31 |
32 |
--------------------------------------------------------------------------------
/public/notify/notify.css:
--------------------------------------------------------------------------------
1 | * {
2 | box-sizing:border-box;
3 | }
4 |
5 | html, body {
6 | padding:0;
7 | margin:0;
8 | height:100%;
9 | width:100%;
10 | color:#dedede;
11 | background-color: #849091;
12 | font-family: 'Helvetica Neue', Helvetica, sans-serif;
13 | }
14 |
15 | header {
16 | width:100%;
17 | position:absolute;
18 | text-align:center;
19 | bottom:20px;
20 | }
21 |
22 | header a, header a:visited {
23 | font-size:18px;
24 | color:#dedede;
25 | text-decoration:none;
26 | }
27 |
28 | header a:hover {
29 | text-decoration:underline;
30 | }
31 |
32 | section {
33 | background-color:#2B2B2A;
34 | text-align:center;
35 | padding:16px;
36 | }
37 |
38 | #message {
39 | padding:6px;
40 | }
41 |
--------------------------------------------------------------------------------
/public/notify/notify.js:
--------------------------------------------------------------------------------
1 | $(function() {
2 | $('#sendNotificationButton').on('click', function() {
3 | $.post('/send-notification', {
4 | identity: $('#identityInput').val(),
5 | body: "Hello, world!"
6 | }, function(response) {
7 | $('#identityInput').val('');
8 | $('#message').html(response.message);
9 | console.log(response);
10 | });
11 | });
12 | });
13 |
--------------------------------------------------------------------------------
/public/sync/index.css:
--------------------------------------------------------------------------------
1 | * {
2 | box-sizing:border-box;
3 | }
4 |
5 | html, body {
6 | padding:0;
7 | margin:0;
8 | height:100%;
9 | width:100%;
10 | color:#dedede;
11 | background-color: #849091;
12 | font-family: 'Helvetica Neue', Helvetica, sans-serif;
13 | }
14 |
15 | header {
16 | width:100%;
17 | position:absolute;
18 | text-align:center;
19 | bottom:20px;
20 | }
21 |
22 | header a, header a:visited {
23 | font-size:18px;
24 | color:#dedede;
25 | text-decoration:none;
26 | }
27 |
28 | header a:hover {
29 | text-decoration:underline;
30 | }
31 |
32 | section {
33 | background-color:#2B2B2A;
34 | text-align:center;
35 | padding:16px;
36 | }
37 |
38 | button:hover {
39 | cursor:pointer;
40 | background-color:#000;
41 | color:#fff;
42 | }
43 |
44 | #message {
45 | padding:6px;
46 | }
47 |
48 | #board {
49 | width: 33%;
50 | margin-left: auto;
51 | margin-right: auto;
52 | }
53 |
54 | #board .board-row {
55 | width: 100%;
56 | padding-bottom: 3px;
57 | }
58 |
59 | #board .board-row button {
60 | width: 30%;
61 | height: 100px;
62 | font-size: 50px;
63 | }
--------------------------------------------------------------------------------
/public/sync/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
Tic-Tac-Twilio - Sync Quickstart
5 |
6 |
7 |
8 |
9 |
10 |
17 |
18 |
19 | Tic-Tac-Twilio
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
40 | Welcome! Initializing Sync...
41 |
42 |
43 | Open this page in a few tabs to test!
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
--------------------------------------------------------------------------------
/public/sync/index.js:
--------------------------------------------------------------------------------
1 | $(function () {
2 | //We'll use message to tell the user what's happening
3 | var $message = $('#message');
4 |
5 | //Get handle to the game board buttons
6 | var $buttons = $('#board .board-row button');
7 |
8 | //Our interface to the Sync service
9 | var syncClient;
10 |
11 | // Every browser Sync client relies on FPA tokens to authenticate and authorize it
12 | // for access to your Sync data.
13 | //
14 | // In this quickstart, we're using our own token generator. You can generate a token
15 | // in any backend language that Twilio supports, or generate a Twilio Function so
16 | // Twilio can host it for you. See the docs for more details.
17 | //
18 | $.getJSON('/token', function (tokenResponse) {
19 |
20 | // Once we have the token, we can initialize the Sync client and start subscribing
21 | // to data. The client will initialize asynchronously while we load the rest of
22 | // the user interface.
23 | //
24 | syncClient = new Twilio.Sync.Client(tokenResponse.token, { logLevel: 'info' });
25 | syncClient.on('connectionStateChanged', function(state) {
26 | if (state != 'connected') {
27 | $message.html('Sync is not live (websocket connection
' + state + ')…');
28 | } else {
29 | // Now that we're connected, lets light up our board and play!
30 | $buttons.attr('disabled', false);
31 | $message.html('Sync is live!');
32 | }
33 | });
34 |
35 | // Let's pop a message on the screen to show that Sync is working
36 | $message.html('Loading board data…');
37 |
38 | // Our game state is stored in a Sync document. Here, we'll attach to that document
39 | // (or create it, if it doesn't exist) and connect the necessary event handlers.
40 | //
41 | syncClient.document('SyncGame').then(function(syncDoc) {
42 | var data = syncDoc.data;
43 | if (data.board) {
44 | updateUserInterface(data);
45 | }
46 |
47 | // Any time the board changes, we want to show the new state. The 'updated'
48 | // event is for this.
49 | syncDoc.on('updated', function(event) {
50 | console.debug("Board was updated", event.isLocal? "locally." : "by the other guy.");
51 | updateUserInterface(event.data);
52 | });
53 |
54 | // Let's make our buttons control the game state in Sync…
55 | $buttons.on('click', function (e) {
56 | // Toggle the value: X, O, or empty
57 | toggleCellValue($(e.target));
58 |
59 | // Send updated document to Sync. This will trigger "updated" events for all players.
60 | var data = readGameBoardFromUserInterface();
61 | syncDoc.set(data);
62 | });
63 | });
64 |
65 | });
66 |
67 | //Toggle the value: X, O, or empty ( for UI)
68 | function toggleCellValue($cell) {
69 | var cellValue = $cell.html();
70 |
71 | if (cellValue === 'X') {
72 | $cell.html('O');
73 | } else if (cellValue === 'O') {
74 | $cell.html(' ');
75 | } else {
76 | $cell.html('X');
77 | }
78 | }
79 |
80 | //Read the state of the UI and create a new document
81 | function readGameBoardFromUserInterface() {
82 | var board = [
83 | ['', '', ''],
84 | ['', '', ''],
85 | ['', '', '']
86 | ];
87 |
88 | for (var row = 0; row < 3; row++) {
89 | for (var col = 0; col < 3; col++) {
90 | var selector = '[data-row="' + row + '"]' +
91 | '[data-col="' + col + '"]';
92 | board[row][col] = $(selector).html().replace(' ', '');
93 | }
94 | }
95 |
96 | return {board: board};
97 | }
98 |
99 | //Update the buttons on the board to match our document
100 | function updateUserInterface(data) {
101 | for (var row = 0; row < 3; row++) {
102 | for (var col = 0; col < 3; col++) {
103 | var this_cell = '[data-row="' + row + '"]' + '[data-col="' + col + '"]';
104 | var cellValue = data.board[row][col];
105 | $(this_cell).html(cellValue === '' ? ' ' : cellValue);
106 | }
107 | }
108 | }
109 | });
110 |
--------------------------------------------------------------------------------
/src/config.js:
--------------------------------------------------------------------------------
1 | require('dotenv').config();
2 |
3 | module.exports = {
4 | TWILIO_ACCOUNT_SID: process.env.TWILIO_ACCOUNT_SID,
5 | TWILIO_API_KEY: process.env.TWILIO_API_KEY,
6 | TWILIO_API_SECRET: process.env.TWILIO_API_SECRET,
7 | TWILIO_CHAT_SERVICE_SID: process.env.TWILIO_CHAT_SERVICE_SID,
8 | TWILIO_NOTIFICATION_SERVICE_SID: process.env.TWILIO_NOTIFICATION_SERVICE_SID,
9 | TWILIO_SYNC_SERVICE_SID: process.env.TWILIO_SYNC_SERVICE_SID || 'default'
10 | }
11 |
--------------------------------------------------------------------------------
/src/notification_handler.js:
--------------------------------------------------------------------------------
1 | const Twilio = require('twilio');
2 |
3 | const config = require('./config');
4 |
5 | /**
6 | * Create a device binding from a POST HTTP request
7 | *
8 | * @param {Object} binding
9 | *
10 | * @return {Promise}
11 | * {Object.status}
12 | * {Object.data}
13 | * {Object.message}
14 | */
15 | exports.registerBind = function registerBind(binding) {
16 | const service = getTwilioClient();
17 |
18 | return service.bindings.create(binding).then((binding) => {
19 | console.log(binding);
20 | // Send a JSON response indicating success
21 | return {
22 | status: 200,
23 | data: {message: 'Binding created!'},
24 | };
25 | }).catch((error) => {
26 | console.log(error);
27 | return {
28 | status: 500,
29 | data: {
30 | error: error,
31 | message: 'Failed to create binding: ' + error,
32 | },
33 | };
34 | });
35 | };
36 |
37 | // Notify - send a notification from a POST HTTP request
38 | exports.sendNotification = function sendNotification(notification) {
39 | // Create a reference to the user notification service
40 | const service = getTwilioClient();
41 |
42 | // Send a notification
43 | return service.notifications.create(notification).then((message) => {
44 | console.log(message);
45 | return {
46 | status: 200,
47 | data: {message: 'Successful sending notification'},
48 | };
49 | }).catch((error) => {
50 | console.log(error);
51 | return {
52 | status: 500,
53 | data: {error: error},
54 | };
55 | });
56 | };
57 |
58 | function getTwilioClient() {
59 | // Twilio Library
60 | const client = new Twilio(
61 | config.TWILIO_API_KEY,
62 | config.TWILIO_API_SECRET,
63 | {accountSid: config.TWILIO_ACCOUNT_SID}
64 | );
65 |
66 | // Get a reference to the user notification service instance
67 | const service = client.notify.services(
68 | config.TWILIO_NOTIFICATION_SERVICE_SID
69 | );
70 |
71 | return service;
72 | }
73 |
--------------------------------------------------------------------------------
/src/router.js:
--------------------------------------------------------------------------------
1 | const Router = require('express').Router;
2 |
3 | const {registerBind, sendNotification} = require('./notification_handler');
4 | const tokenGenerator = require('./token_generator');
5 | const config = require('./config');
6 |
7 | const router = new Router();
8 |
9 | // Convert keys to camelCase to conform with the twilio-node api definition contract
10 | const camelCase = require('camelcase');
11 | function camelCaseKeys(hashmap) {
12 | var newhashmap = {};
13 | Object.keys(hashmap).forEach(function(key) {
14 | var newkey = camelCase(key);
15 | newhashmap[newkey] = hashmap[key];
16 | });
17 | return newhashmap;
18 | };
19 |
20 | router.get('/token/:id?', (req, res) => {
21 | const id = req.params.id;
22 | res.send(tokenGenerator(id));
23 | });
24 |
25 | router.post('/token', (req, res) => {
26 | const id = req.body.id;
27 | res.send(tokenGenerator(id));
28 | });
29 |
30 | router.post('/register', (req, res) => {
31 | var content = camelCaseKeys(req.body);
32 | registerBind(content).then((data) => {
33 | res.header('Access-Control-Allow-Origin', '*');
34 | res.status(data.status);
35 | res.send(data.data);
36 | });
37 | });
38 |
39 | router.post('/send-notification', (req, res) => {
40 | var content = camelCaseKeys(req.body);
41 | sendNotification(content).then((data) => {
42 | res.status(data.status);
43 | res.send(data.data);
44 | });
45 | });
46 |
47 | router.get('/config', (req, res) => {
48 | res.json(config);
49 | });
50 |
51 |
52 | //Create a facebook-messenger binding based on the authentication webhook from Facebook
53 | router.post('/messenger_auth', function(req, res) {
54 | //Extract the request received from Facebook
55 | const message = req.body.entry[0].messaging[0];
56 | console.log(message);
57 | // Set user identity using their fb messenger user id
58 | const identity = message.sender.id;
59 | //Let's create a new facebook-messenger Binding for our user
60 | const binding = {
61 | "identity":identity,
62 | "BindingType":'facebook-messenger',
63 | "Address":message.sender.id
64 | };
65 | registerBind(camelCaseKeys(binding)).then((data) => {
66 | res.status(data.status);
67 | res.send(data.data);
68 | });
69 | });
70 |
71 | //Verification endpoint for Facebook needed to register a webhook.
72 | router.get('/messenger_auth', function(req, res) {
73 | console.log(req.query["hub.challenge"]);
74 | res.send(req.query["hub.challenge"]);
75 | });
76 |
77 |
78 |
79 | module.exports = router;
80 |
--------------------------------------------------------------------------------
/src/sync_service_details.js:
--------------------------------------------------------------------------------
1 | const Twilio = require('twilio');
2 | require('dotenv').config();
3 |
4 | function syncServiceDetails() {
5 | const syncServiceSid = process.env.TWILIO_SYNC_SERVICE_SID || 'default';
6 |
7 | const client = new Twilio(
8 | process.env.TWILIO_API_KEY,
9 | process.env.TWILIO_API_SECRET,
10 | {accountSid: process.env.TWILIO_ACCOUNT_SID}
11 | );
12 | client.sync
13 | .services(syncServiceSid)
14 | .fetch()
15 | .then(response => {
16 | console.log(response);
17 | })
18 | .catch(error => {
19 | console.log(error);
20 | });
21 |
22 | }
23 |
24 | module.exports = syncServiceDetails;
--------------------------------------------------------------------------------
/src/token_generator.js:
--------------------------------------------------------------------------------
1 | const Twilio = require('twilio');
2 |
3 | const config = require('./config');
4 | const nameGenerator = require('../name_generator');
5 |
6 | // Access Token used for Chat and Sync
7 | const AccessToken = Twilio.jwt.AccessToken;
8 | const ChatGrant = AccessToken.ChatGrant;
9 | const SyncGrant = AccessToken.SyncGrant;
10 |
11 | /**
12 | * Generate an Access Token for an application user - it generates a random
13 | * username for the client requesting a token or generates a token with an
14 | * identity if one is provided.
15 | *
16 | * @return {Object}
17 | * {Object.identity} String random indentity
18 | * {Object.token} String token generated
19 | */
20 | function tokenGenerator(identity = 0) {
21 | // Create an access token which we will sign and return to the client
22 | const token = new AccessToken(
23 | config.TWILIO_ACCOUNT_SID,
24 | config.TWILIO_API_KEY,
25 | config.TWILIO_API_SECRET
26 | );
27 |
28 | // Assign the provided identity or generate a new one
29 | token.identity = identity || nameGenerator();
30 |
31 | if (config.TWILIO_CHAT_SERVICE_SID) {
32 | // Create a "grant" which enables a client to use IPM as a given user,
33 | // on a given device
34 | const chatGrant = new ChatGrant({
35 | serviceSid: config.TWILIO_CHAT_SERVICE_SID
36 | });
37 | token.addGrant(chatGrant);
38 | }
39 |
40 | if (config.TWILIO_SYNC_SERVICE_SID) {
41 | // Point to a particular Sync service, or use the account default to
42 | // interact directly with Functions.
43 | const syncGrant = new SyncGrant({
44 | serviceSid: config.TWILIO_SYNC_SERVICE_SID || 'default'
45 | });
46 | token.addGrant(syncGrant);
47 | }
48 |
49 | // Serialize the token to a JWT string and include it in a JSON response
50 | return {
51 | identity: token.identity,
52 | token: token.toJwt()
53 | };
54 | }
55 |
56 | module.exports = tokenGenerator;
57 |
--------------------------------------------------------------------------------
/test/config.test.js:
--------------------------------------------------------------------------------
1 | const config = require('../src/config');
2 |
3 | describe('#config', () => {
4 | it('contains the required keys', () => {
5 | expect(config).toHaveProperty('TWILIO_ACCOUNT_SID');
6 | expect(config).toHaveProperty('TWILIO_API_KEY');
7 | expect(config).toHaveProperty('TWILIO_API_SECRET');
8 | expect(config).toHaveProperty('TWILIO_CHAT_SERVICE_SID');
9 | expect(config).toHaveProperty('TWILIO_NOTIFICATION_SERVICE_SID');
10 | expect(config).toHaveProperty('TWILIO_SYNC_SERVICE_SID');
11 | });
12 | });
13 |
--------------------------------------------------------------------------------
/test/token_generator.test.js:
--------------------------------------------------------------------------------
1 | const jwt = require('jsonwebtoken');
2 | const tokenGenerator = require('../src/token_generator');
3 |
4 | describe('#tokenGenerator', () => {
5 | it('generates a new token', () => {
6 | const token = tokenGenerator();
7 | const decoded = jwt.decode(token.token, {complete: true});
8 |
9 | expect(decoded).toHaveProperty('payload.grants.identity', token.identity);
10 | expect(decoded).toHaveProperty('payload.grants.chat.service_sid');
11 | expect(decoded.payload.grants.chat.service_sid).toStartWith('IS')
12 | expect(decoded).toHaveProperty('payload.grants.data_sync.service_sid');
13 | expect(decoded.payload.grants.data_sync.service_sid).toStartWith('IS')
14 | });
15 |
16 | it('generates a new token using the specified identity', () => {
17 | const identity = "Alice";
18 | const token = tokenGenerator(identity);
19 | const decoded = jwt.decode(token.token, {complete: true});
20 |
21 | expect(token.identity).toEqual(identity);
22 | expect(decoded).toHaveProperty('payload.grants.identity', token.identity);
23 | });
24 |
25 |
26 | });
27 |
--------------------------------------------------------------------------------
3 |