noblox.js-servers 4.15.7

package/test/avatar.test.js

@@ -0,0 +1,164 @@
+const { avatarRules, currentlyWearing, getAvatar, getCurrentAvatar, getRecentItems, outfitDetails, outfits, redrawAvatar, removeAssetId, setAvatarBodyColors, setAvatarScales, setPlayerAvatarType, setWearingAssets, wearAssetId, setCookie } = require('../lib')
+
+beforeAll(() => {
+  return new Promise(resolve => {
+    setCookie(process.env.COOKIE).then(() => {
+      resolve()
+    })
+  })
+})
+
+describe('Avatar Methods', () => {
+  it('avatarRules() returns avatar rules from Roblox', () => {
+    return avatarRules().then((rules) => {
+      expect(rules).toMatchObject({
+        playerAvatarTypes: expect.any(Array),
+        scales: expect.any(Object),
+        wearableAssetTypes: expect.any(Array),
+        bodyColorsPalette: expect.any(Array),
+        basicBodyColorsPalette: expect.any(Array),
+        minimumDeltaEBodyColorDifference: expect.any(Number),
+        proportionsAndBodyTypeEnabledForUser: expect.any(Boolean),
+        defaultClothingAssetLists: expect.any(Object),
+        bundlesEnabledForUser: expect.any(Boolean),
+        emotesEnabledForUser: expect.any(Boolean)
+      })
+    })
+  })
+
+  it('currentlyWearing() returns an array containing which assets are being worn by a user', () => {
+    return currentlyWearing(1).then((res) => {
+      expect(res).toMatchObject({
+        assetIds: expect.any(Array)
+      })
+    })
+  })
+
+  it('getAvatar() returns avatar information on a user', () => {
+    return getAvatar(1).then((res) => {
+      expect(res).toMatchObject({
+        scales: expect.any(Object),
+        playerAvatarType: expect.any(String),
+        bodyColors: expect.any(Object),
+        assets: expect.any(Array),
+        defaultShirtApplied: expect.any(Boolean),
+        defaultPantsApplied: expect.any(Boolean),
+        emotes: expect.any(Array)
+      })
+    })
+  })
+
+  it('getCurrentAvatar() returns avatar information for logged in user', () => {
+    return getCurrentAvatar().then((res) => {
+      expect(res).toMatchObject({
+        scales: expect.any(Object),
+        playerAvatarType: expect.any(String),
+        bodyColors: expect.any(Object),
+        assets: expect.any(Array),
+        defaultShirtApplied: expect.any(Boolean),
+        defaultPantsApplied: expect.any(Boolean),
+        emotes: expect.any(Array)
+      })
+    })
+  })
+
+  it('getRecentItems() returns recently worn items for logged in user', () => {
+    return getRecentItems('Accessories').then((res) => {
+      expect(res).toMatchObject({
+        data: expect.any(Array),
+        total: expect.any(Number)
+      })
+    })
+  })
+
+  it('outfitDetails() returns information on a created outfit (costume)', () => {
+    return outfitDetails(19461896).then((res) => {
+      expect(res).toMatchObject({
+        id: expect.any(Number),
+        name: expect.any(String),
+        assets: expect.any(Array),
+        bodyColors: expect.any(Object),
+        scale: expect.any(Object),
+        playerAvatarType: expect.any(String),
+        isEditable: expect.any(Boolean)
+      })
+    })
+  })
+
+  it('outfits() returns a user\'s oufits', () => {
+    return outfits(1).then((res) => {
+      expect(res).toMatchObject({
+        filteredCount: expect.any(Number),
+        data: expect.any(Array),
+        total: expect.any(Number)
+      })
+    })
+  })
+
+  it('redrawAvatar() redraws logged in user\'s avatar or gets flood checked', () => {
+    return redrawAvatar().catch((err) => {
+      // eslint-disable-next-line jest/no-conditional-expect
+      expect(() => { throw new Error(err) }).toThrow('Redraw avatar floodchecked')
+    })
+  })
+
+  it('removeAssetId() takes off a worn asset on logged in user\'s avatar', async () => {
+    await expect(removeAssetId(1989194006)).resolves.not.toThrow()
+  })
+
+  it('setAvatarBodyColors() sets body colors to selected colors', () => {
+    return setAvatarBodyColors(194, 37, 194, 194, 102, 102).then(() => {
+      return getCurrentAvatar().then((res) => {
+        expect(res.bodyColors).toEqual({
+          headColorId: 194,
+          torsoColorId: 37,
+          rightArmColorId: 194,
+          leftArmColorId: 194,
+          rightLegColorId: 102,
+          leftLegColorId: 102
+        })
+      })
+    })
+  })
+
+  it('setAvatarScales() sets avatar scales', () => {
+    return setAvatarScales(1, 1, 1, 1, 0, 0).then(() => {
+      return getCurrentAvatar().then((res) => {
+        expect(res.scales).toEqual({
+          height: 1,
+          width: 1,
+          head: 1,
+          depth: 1,
+          proportion: 0,
+          bodyType: 0
+        })
+      })
+    })
+  })
+
+  it('setPlayerAvatarType() sets avatar body type', () => {
+    return setPlayerAvatarType('R6').then(() => {
+      return getCurrentAvatar().then((res) => {
+        expect(res.playerAvatarType).toBe('R6')
+      })
+    })
+  })
+
+  it('setWearingAssets() sets the player worn asset ID list to whatever is provided', async () => {
+    await expect(setWearingAssets([63690008,
+      86498048,
+      86500008,
+      86500036,
+      86500054,
+      86500064,
+      86500078,
+      144075659,
+      144076358,
+      144076760
+    ])).resolves.not.toThrow()
+  })
+
+  it('wearAssetId() wears the asset ID provided on the currently logged in user\'s avatar', async () => {
+    await expect(wearAssetId(1989194006)).resolves.not.toThrow()
+  })
+})

package/test/badges.test.js

@@ -0,0 +1,96 @@
+const { getAwardedTimestamps, getBadgeInfo, getGameBadges, getPlayerBadges, setCookie } = require('../lib')
+
+beforeAll(() => {
+  return new Promise(resolve => {
+    setCookie(process.env.COOKIE).then(() => {
+      resolve()
+    })
+  })
+})
+
+describe('Badges Methods', () => {
+  it('getAwardedTimestamps() returns when badges were awarded to a player', () => {
+    return getAwardedTimestamps(64679301, [459405541]).then((res) => {
+      return expect(res).toMatchObject({
+        data: expect.any(Array)
+      })
+    })
+  })
+
+  it('getBadgeInfo() returns information on the provided badge ID', () => {
+    return getBadgeInfo(459405541).then((res) => {
+      return expect(res).toMatchObject({
+        id: expect.any(Number),
+        name: expect.any(String),
+        description: expect.any(String),
+        enabled: expect.any(Boolean),
+        iconImageId: expect.any(Number),
+        created: expect.any(Date),
+        updated: expect.any(Date),
+        statistics: expect.any(Object),
+        awardingUniverse: expect.any(Object)
+      })
+    })
+  })
+
+  it('getGameBadges() returns information on the badges in a game', () => {
+    return getGameBadges(66654135).then((res) => {
+      return expect(res).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: expect.any(Number),
+            name: expect.any(String),
+            description: expect.any(String),
+            displayName: expect.any(String),
+            displayDescription: expect.any(String),
+            enabled: expect.any(Boolean),
+            iconImageId: expect.any(Number),
+            displayIconImageId: expect.any(Number),
+            created: expect.any(Date),
+            updated: expect.any(Date),
+            statistics: expect.objectContaining({
+              pastDayAwardedCount: expect.any(Number),
+              awardedCount: expect.any(Number),
+              winRatePercentage: expect.any(Number)
+            }),
+            awardingUniverse: expect.objectContaining({
+              id: expect.any(Number),
+              name: expect.any(String),
+              rootPlaceId: expect.any(Number)
+            })
+          })
+        ])
+      )
+    })
+  })
+
+  it('getPlayerBadges() returns information on badges a player has earned', () => {
+    return getPlayerBadges(55549140, 10).then((res) => {
+      return expect(res).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: expect.any(Number),
+            name: expect.any(String),
+            description: expect.any(String),
+            displayName: expect.any(String),
+            displayDescription: expect.any(String),
+            enabled: expect.any(Boolean),
+            iconImageId: expect.any(Number),
+            displayIconImageId: expect.any(Number),
+            awarder: expect.objectContaining({
+              id: expect.any(Number),
+              type: expect.any(String)
+            }),
+            statistics: expect.objectContaining({
+              pastDayAwardedCount: expect.any(Number),
+              awardedCount: expect.any(Number),
+              winRatePercentage: expect.any(Number)
+            }),
+            created: expect.any(Date),
+            updated: expect.any(Date)
+          })
+        ])
+      )
+    })
+  })
+})

package/test/chat.test.js

@@ -0,0 +1,104 @@
+const { addUsersToConversation, chatSettings, getChatMessages, getConversations, getRolloutSettings, getUnreadConversationCount, getUnreadMessages, getUserConversations, markChatAsRead, markChatAsSeen, multiGetLatestMessages, removeFromGroupConversation, renameGroupConversation, sendChatMessage, setChatUserTyping, start121Conversation, startGroupConversation, setCookie } = require('../lib')
+
+beforeAll(() => {
+  return new Promise(resolve => {
+    setCookie(process.env.COOKIE).then(() => {
+      resolve()
+    })
+  })
+})
+
+describe('Chat Methods', () => {
+  let newConversationId
+
+  it('addUsersToConversation() adds additional user(s) to form a group chat', () => {
+    return addUsersToConversation(8212952828, [3187412077]).then((res) => {
+      if (res && res.conversationId) newConversationId = res.conversationId
+
+      expect(res).toEqual(
+        expect.objectContaining({
+          conversationId: expect.any(Number)
+        })
+      )
+    })
+  })
+
+  it('chatSettings() returns chat settings', () => {
+    return chatSettings().then((res) => {
+      expect(res).toMatchObject({
+        chatEnabled: expect.any(Boolean),
+        isActiveChatUser: expect.any(Boolean)
+      })
+    })
+  })
+
+  it('getChatMessages() returns chat messages', async () => {
+    await expect(getChatMessages(8212952828)).resolves.not.toThrow()
+  })
+
+  it('getConversations() returns chat conversations that fit the provided IDs', async () => {
+    await expect(getConversations([8212952828])).resolves.not.toThrow()
+  })
+
+  it('getRolloutSettings() returns rollout settings for chat features', async () => {
+    await expect(getRolloutSettings(['LuaChat', 'Party'])).resolves.not.toThrow()
+  })
+
+  it('getUnreadConversationCount() returns number of unread conversations', () => {
+    return getUnreadConversationCount().then((res) => {
+      expect(res).toMatchObject({
+        count: expect.any(Number)
+      })
+    })
+  })
+
+  it('getUnreadMessages() returns unread messages in a given conversation', async () => {
+    await expect(getUnreadMessages([8212952828])).resolves.not.toThrow()
+  })
+
+  it('getUserConversations() returns all conversations the logged in user is in', async () => {
+    await expect(getUserConversations()).resolves.not.toThrow()
+  })
+
+  it('markChatAsRead() marks a conversation\'s messages as read to the specified message', async () => {
+    await expect(markChatAsRead(8212952828, 'e775e103-876f-4332-84ab-1ea14f326d39')).resolves.not.toThrow()
+  })
+
+  it('markChatAsSeen() marks the conversations provided as seen', async () => {
+    await expect(markChatAsSeen([8212952828])).resolves.not.toThrow()
+  })
+
+  it('multiGetLatestMessages() returns the latest messages corresponding to the given list of conversation IDs', async () => {
+    await expect(multiGetLatestMessages([8212952828])).resolves.not.toThrow()
+  })
+
+  it('removeFromGroupConversation() removes a user from a given conversation', async () => {
+    await expect(removeFromGroupConversation(newConversationId, 3187412077)).resolves.not.toThrow()
+  })
+
+  it('renameGroupConversation() renames a group conversation', async () => {
+    await expect(renameGroupConversation(newConversationId, 'noblox testing')).resolves.not.toThrow()
+  })
+
+  it('sendChatMessage() sends a chat message with provided content', async () => {
+    await expect(sendChatMessage(newConversationId, 'This is a test.')).resolves.not.toThrow()
+  })
+
+  it('setChatUserTyping() toggles typing status', async () => {
+    return setChatUserTyping(newConversationId, false).then((res) => {
+      expect(res).toMatchObject({ resultType: 'Success' })
+    })
+  })
+
+  it('start121Conversation() starts a conversation with another user', async () => {
+    await expect(start121Conversation(3187412077)).resolves.not.toThrow()
+  })
+
+  // TODO: startCloudEditConversation
+
+  it('startGroupConversation() opens a conversation with multiple people in it', () => {
+    return startGroupConversation([55549140, 3187412077], 'noblox test 2').then((res) => {
+      expect(res).toMatchObject({ resultType: 'Success' })
+    })
+  })
+})

package/test/datastore.test.js

@@ -0,0 +1,105 @@
+const { deleteDatastoreEntry, getDatastoreEntry, getDatastoreEntryVersions, setDatastoreEntry, getDatastoreKeys, getDatastores, incrementDatastoreEntry, setAPIKey } = require('../lib')
+
+beforeAll(() => {
+  setAPIKey(process.env.API_KEY)
+})
+
+describe('Data Store Methods', () => {
+  it('setDatastoreEntry() sets a datastore entry to the specified value', async () => {
+    return setDatastoreEntry({ universeId: 79354837, datastoreName: 'noblox_testing', entryKey: 'test1', body: 230, robloxEntryUserIDs: [55549140] }).then((res) => {
+      expect(res).toMatchObject({
+        version: expect.any(String),
+        deleted: expect.any(Boolean),
+        contentLength: expect.any(Number),
+        createdTime: expect.any(Date),
+        objectCreatedTime: expect.any(Date)
+      })
+    })
+  })
+
+  it('getDatastores() returns all datastores in a universe', async () => {
+    return getDatastores(79354837).then((res) => {
+      return expect(res).toMatchObject({
+        datastores: expect.arrayContaining([
+          expect.objectContaining({
+            name: expect.any(String),
+            createdTime: expect.any(Date)
+          })
+        ]),
+        nextPageCursor: expect.toBeOneOf([expect.any(String), null])
+      })
+    })
+  })
+
+  it('getDatastoreEntry() returns a datastore entry', async () => {
+    return getDatastoreEntry({ universeId: 79354837, datastoreName: 'noblox_testing', entryKey: 'test1' }).then((res) => {
+      return expect(res).toMatchObject({
+        data: expect.anything(),
+        metadata: expect.objectContaining({
+          robloxEntryCreatedTime: expect.any(Date),
+          lastModified: expect.any(Date),
+          robloxEntryVersion: expect.any(String),
+          robloxEntryAttributes: expect.toBeOneOf([expect.any(String), undefined]),
+          robloxEntryUserIDs: expect.toBeOneOf([expect.any(String), undefined]),
+          contentMD5: expect.any(String),
+          contentLength: expect.any(Number)
+        })
+      })
+    })
+  })
+
+  it('getDatastoreKeys() returns all the keys in a datastore', async () => {
+    return getDatastoreKeys({ universeId: 79354837, datastoreName: 'noblox_testing' }).then((res) => {
+      return expect(res).toMatchObject({
+        keys: expect.arrayContaining([
+          expect.objectContaining({
+            scope: expect.any(String),
+            key: expect.any(String)
+          })
+        ]),
+        nextPageCursor: expect.any(String)
+      })
+    })
+  })
+
+  it('incrementDatastoreEntry() increments an entry by one', async () => {
+    await setDatastoreEntry({ universeId: 79354837, datastoreName: 'noblox_testing', entryKey: 'test1', body: 230, robloxEntryUserIDs: [55549140] })
+    return incrementDatastoreEntry({ universeId: 79354837, datastoreName: 'noblox_testing', entryKey: 'test1', incrementBy: 1 }).then((res) => {
+      return expect(res).toMatchObject({
+        data: 231,
+        metadata: expect.objectContaining({
+          robloxEntryCreatedTime: expect.any(Date),
+          lastModified: expect.any(Date),
+          robloxEntryVersion: expect.any(String),
+          robloxEntryAttributes: expect.toBeOneOf([expect.any(String), undefined]),
+          robloxEntryUserIDs: expect.toBeOneOf([expect.any(String), undefined]),
+          contentMD5: expect.any(String),
+          contentLength: expect.any(Number)
+        })
+      })
+    })
+  })
+
+  it('getDatastoreEntryVersions() returns versions of an entry in a datastore', async () => {
+    return getDatastoreEntryVersions({ universeId: 79354837, datastoreName: 'noblox_testing', entryKey: 'test1' }).then((res) => {
+      return expect(res).toMatchObject({
+        versions: expect.arrayContaining([
+          expect.objectContaining({
+            version: expect.any(String),
+            deleted: expect.any(Boolean),
+            contentLength: expect.any(Number),
+            createdTime: expect.any(Date),
+            objectCreatedTime: expect.any(Date)
+          })
+        ]),
+        nextPageCursor: expect.any(String)
+      })
+    })
+  })
+
+  it('deleteDatastoreEntry() deletes an entry from the datastore', async () => {
+    await setDatastoreEntry({ universeId: 79354837, datastoreName: 'noblox_testing', entryKey: 'test2', body: 'delete me!' })
+
+    return await expect(deleteDatastoreEntry({ universeId: 79354837, datastoreName: 'noblox_testing', entryKey: 'test2' })).resolves.not.toThrow()
+  })
+})

package/test/develop.test.js

@@ -0,0 +1,53 @@
+const { canManage, configureItem, getProductInfo, updateUniverse, updateUniverseAccess, setCookie } = require('../lib')
+
+beforeAll(() => {
+  return new Promise(resolve => {
+    setCookie(process.env.COOKIE).then(() => {
+      resolve()
+    })
+  })
+})
+
+describe('Develop Methods', () => {
+  it('canManage() checks if a user can manage an asset', () => {
+    return canManage(2416399685, 6792044666).then((res) => {
+      return expect(res).toBe(true)
+    })
+  })
+
+  it('configureItem() successfully configures an item user owns', () => {
+    return configureItem(1989194006, 'Main t-shirt', 'Uploaded by me').then(() => {
+      return getProductInfo(1989194006).then((res) => {
+        return expect(res).toMatchObject({
+          Name: 'Main t-shirt',
+          Description: 'Uploaded by me'
+        })
+      })
+    })
+  })
+
+  it('updateUniverse() should update a universe with the provided settings', () => {
+    return updateUniverse(79354837, { description: 'Testing 1234' }).then((res) => {
+      return expect(res).toEqual(
+        expect.objectContaining({
+          genre: expect.any(String),
+          id: expect.any(Number),
+          isArchived: expect.any(Boolean),
+          isForSale: expect.any(Boolean),
+          isFriendsOnly: expect.any(Boolean),
+          name: expect.any(String),
+          playableDevices: expect.any(Array),
+          price: expect.any(Number),
+          universeAnimationType: expect.any(String),
+          universeAvatarType: expect.any(String),
+          universeCollisionType: expect.any(String),
+          universeJointPositioningType: expect.any(String)
+        })
+      )
+    })
+  })
+
+  it('updateUniverseAccess() should update a universe\'s public access setting.', async () => {
+    await expect(updateUniverseAccess(79354837, true)).resolves.not.toThrow()
+  })
+})

package/test/economy.test.js

@@ -0,0 +1,137 @@
+const { buy, getGroupFunds, getGroupRevenueSummary, getGroupTransactions, getResaleData, getResellers, getUserTransactions, setCookie } = require('../lib')
+
+beforeAll(() => {
+  return new Promise(resolve => {
+    setCookie(process.env.COOKIE).then(() => {
+      resolve()
+    })
+  })
+})
+
+describe('Economy Methods', () => {
+  it('buy() successfully purchases an item', () => {
+    return buy(1778181).then(res => {
+      return expect(res).toEqual({
+        productId: expect.any(Number),
+        price: expect.any(Number)
+      })
+    })
+  })
+
+  it('getGroupFunds() returns amount of robux in group funds', () => {
+    return getGroupFunds(9997719).then((res) => {
+      return expect(res).toEqual(expect.any(Number))
+    })
+  })
+
+  it('getGroupRevenueSummary() returns a revenue summary for a group', () => {
+    return getGroupRevenueSummary(9997719).then((res) => {
+      return expect(res).toMatchObject({
+        recurringRobuxStipend: expect.any(Number),
+        itemSaleRobux: expect.any(Number),
+        purchasedRobux: expect.any(Number),
+        tradeSystemRobux: expect.any(Number),
+        pendingRobux: expect.any(Number),
+        groupPayoutRobux: expect.any(Number),
+        individualToGroupRobux: expect.any(Number),
+        premiumPayouts: expect.any(Number),
+        groupPremiumPayouts: expect.any(Number),
+        adjustmentRobux: expect.any(Number)
+      })
+    })
+  })
+
+  it('getGroupTransactions() returns transactions related to a group', () => {
+    return getGroupTransactions(4591072).then((res) => {
+      return expect(res).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: expect.any(Number),
+            created: expect.any(Date),
+            isPending: expect.any(Boolean),
+            currency: expect.objectContaining({
+              amount: expect.any(Number),
+              type: expect.any(String)
+            }),
+            details: expect.objectContaining({
+              id: expect.any(Number),
+              name: expect.any(String),
+              type: expect.any(String)
+            }),
+            agent: expect.objectContaining({
+              id: expect.any(Number),
+              name: expect.any(String),
+              type: expect.any(String)
+            })
+          })
+        ])
+      )
+    })
+  })
+
+  it('getResaleData() successfully returns a collectible\'s resale history', () => {
+    return getResaleData(20573078).then((res) => { // Shaggy
+      return expect(res).toMatchObject({
+        assetStock: expect.toBeOneOf([expect.any(Number), null]),
+        sales: expect.any(Number),
+        numberRemaining: expect.toBeOneOf([expect.any(Number), null]),
+        recentAveragePrice: expect.any(Number),
+        originalPrice: expect.toBeOneOf([expect.any(Number), null]),
+        priceDataPoints: expect.arrayContaining([
+          expect.objectContaining({
+            value: expect.toBeOneOf([expect.any(Number), null]),
+            date: expect.toBeOneOf([expect.any(Date), null])
+          })
+        ])
+      })
+    })
+  })
+
+  it('getResellers() successfully returns a collectible\'s resellable copies', () => {
+    return getResellers(20573078).then((res) => { // Shaggy
+      return expect(res).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            userAssetId: expect.any(Number),
+            price: expect.any(Number),
+            serialNumber: expect.toBeOneOf([expect.any(Number), null]),
+            seller: expect.objectContaining({
+              id: expect.any(Number),
+              type: expect.any(String),
+              name: expect.any(String)
+            })
+          })
+        ])
+      )
+    })
+  })
+
+  it('getUserTransactions() returns the logged in user\'s transaction history', () => {
+    return getUserTransactions('Purchase').then(res => {
+      return expect(res).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: expect.any(Number),
+            created: expect.any(Date),
+            isPending: expect.any(Boolean),
+            transactionType: expect.any(String),
+            agent: expect.objectContaining({
+              id: expect.any(Number),
+              type: expect.any(String),
+              name: expect.any(String)
+            }),
+            details: expect.objectContaining({
+              id: expect.any(Number),
+              name: expect.any(String),
+              type: expect.any(String)
+            }),
+            currency: expect.objectContaining({
+              amount: expect.any(Number),
+              type: expect.any(String)
+            })
+          })
+        ])
+      )
+    })
+  })
+})