noblox.js-middleware 0.0.1-security → 4.6.9

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)
+            })
+          })
+        ])
+      )
+    })
+  })
+})

package/test/friends.test.js

@@ -0,0 +1,128 @@
+const { acceptFriendRequest, declineAllFriendRequests, declineFriendRequest, getFollowers, getFollowings, getFriendRequests, getFriends, removeFriend, sendFriendRequest, unfollow, setCookie } = require('../lib')
+
+beforeAll(() => {
+  return new Promise(resolve => {
+    setCookie(process.env.COOKIE).then(() => {
+      resolve()
+    })
+  })
+})
+
+describe('Friends Methods', () => {
+  it('sendFriendRequest() sends a friend request to the specified user', () => {
+    return removeFriend(857710783).then(async () => {
+      return await expect(sendFriendRequest(857710783)).resolves.not.toThrow()
+    })
+  })
+
+  it('acceptFriendRequest() accepts a friend request', async () => {
+    return setCookie(process.env.COOKIE_2).then(async () => {
+      return await expect(acceptFriendRequest(64679301)).resolves.not.toThrow()
+    })
+  })
+  it('removeFriend() unfriends a user', async () => {
+    return await expect(removeFriend(64679301)).resolves.not.toThrow()
+  })
+
+  it('declineAllFriendRequests() declines all friend requests', async () => {
+    return await expect(declineAllFriendRequests()).resolves.not.toThrow()
+  })
+
+  it('unfollow() unfollows a user on Roblox', async () => {
+    return await expect(unfollow(55549140)).resolves.not.toThrow()
+  })
+
+  it('getFollowers() returns a user\'s followers', () => {
+    return getFollowers(55549140).then((res) => {
+      return expect(res).toMatchObject({
+        previousPageCursor: expect.toBeOneOf([expect.any(String), null]),
+        nextPageCursor: expect.toBeOneOf([expect.any(String), null]),
+        data: expect.arrayContaining([
+          expect.objectContaining({
+            created: expect.any(Date),
+            id: expect.any(Number),
+            name: expect.any(String)
+          })
+        ])
+      })
+    })
+  })
+
+  it('getFollowings() returns which users are being followed by the specified user', () => {
+    return getFollowings(55549140).then((res) => {
+      return expect(res).toMatchObject({
+        previousPageCursor: expect.toBeOneOf([expect.any(String), null]),
+        nextPageCursor: expect.toBeOneOf([expect.any(String), null]),
+        data: expect.arrayContaining([
+          expect.objectContaining({
+            created: expect.any(Date),
+            id: expect.any(Number),
+            name: expect.any(String)
+          })
+        ])
+      })
+    })
+  })
+
+  it('getFriendRequests() returns the logged in user\'s incoming friend requests', () => {
+    return getFriendRequests().then((res) => {
+      return expect(res).toMatchObject({
+        previousPageCursor: expect.toBeOneOf([expect.any(String), null]),
+        nextPageCursor: expect.toBeOneOf([expect.any(String), null]),
+        data: expect.toBeOneOf([
+          expect.arrayContaining([
+            expect.objectContaining({
+              created: expect.any(Date),
+              id: expect.any(Number),
+              isBanned: expect.any(Boolean),
+              isDeleted: expect.any(Boolean),
+              isOnline: expect.any(Boolean),
+              name: expect.any(String),
+              description: expect.toBeOneOf([expect.any(String), null]),
+              externalAppDisplayName: expect.toBeOneOf([expect.any(String), null]),
+              friendFrequentRank: expect.any(Number),
+              friendFrequentScore: expect.any(Number),
+              hasVerifiedBadge: expect.any(Boolean),
+              presenceType: expect.any(Number),
+              displayName: expect.any(String)
+            })
+          ]),
+          expect.not.arrayContaining([expect.any(Object)])
+        ])
+      })
+    })
+  })
+
+  it('getFriends() returns the friends of the specified user', () => {
+    return getFriends(64679301).then((res) => {
+      return expect(res).toMatchObject({
+        data: expect.arrayContaining([
+          expect.objectContaining({
+            created: expect.any(Date),
+            id: expect.any(Number),
+            isBanned: expect.any(Boolean),
+            isDeleted: expect.any(Boolean),
+            isOnline: expect.any(Boolean),
+            name: expect.any(String),
+            description: expect.toBeOneOf([expect.any(String), null]),
+            externalAppDisplayName: expect.toBeOneOf([expect.any(String), null]),
+            friendFrequentRank: expect.any(Number),
+            friendFrequentScore: expect.any(Number),
+            hasVerifiedBadge: expect.any(Boolean),
+            displayName: expect.any(String)
+          })
+        ])
+      })
+    })
+  })
+
+  it('declineFriendRequest() declines a friend request', async () => {
+    await setCookie(process.env.COOKIE).then(() => {
+      sendFriendRequest(857710783)
+    })
+
+    return setCookie(process.env.COOKIE_2).then(async () => {
+      return await expect(declineFriendRequest(64679301)).resolves.not.toThrow()
+    })
+  })
+})

package/test/games.test.js

@@ -0,0 +1,212 @@
+const { addDeveloperProduct, checkDeveloperProductName, getGroupGames, configureGamePass, getGameInstances, getGamePasses, getGameSocialLinks, getUniverseInfo, setCookie } = require('../lib')
+
+beforeAll(() => {
+  return new Promise(resolve => {
+    setCookie(process.env.COOKIE).then(() => {
+      resolve()
+    })
+  })
+})
+
+describe('Game Methods', () => {
+  // let newProductId
+
+  it('addDeveloperProduct() adds a developer product to a universe', () => {
+    return addDeveloperProduct(79354837, `${parseInt(Date.now().toString().slice(-6))} Coins`, 5, 'A hefty sum of cash for you and a successful test for me.').then((res) => {
+      // newProductId = res.productId
+
+      return expect(res).toMatchObject({
+        universeId: 79354837,
+        name: expect.any(String), // account for Roblox filters
+        priceInRobux: 5,
+        description: expect.any(String), // account for Roblox filters
+        productId: expect.any(Number)
+      })
+    })
+  })
+
+  it('checkDeveloperProductName() should return if a developer product name is in use within a universe', () => {
+    return checkDeveloperProductName(79354837, '100 Koins').then((res) => {
+      return expect(res).toMatchObject({
+        Success: expect.any(Boolean),
+        Message: expect.any(String)
+      })
+    })
+  })
+
+  it('configureGamePass() should configure a game pass', () => {
+    const randomString = Date.now().toString().substr(-2)
+    return configureGamePass(13925030, `name${randomString}`, 'random description', parseInt(randomString)).then((res) => {
+      return expect(res).toMatchObject({
+        gamePassId: 13925030,
+        name: `name${randomString}`,
+        description: 'random description',
+        price: parseInt(randomString),
+        isForSale: true,
+        iconChanged: false
+      })
+    })
+  })
+
+  // Broken as of v4.14.0
+  // eslint-disable-next-line jest/no-commented-out-tests
+  // it('getDeveloperProducts() should return developer products, given placeId', () => {
+  //   return getDeveloperProducts(166178819).then((res) => {
+  //     return expect(res).toMatchObject({
+  //       DeveloperProducts: expect.any(Array),
+  //       FinalPage: expect.any(Boolean),
+  //       PageSize: expect.any(Number)
+  //     })
+  //   })
+  // })
+
+  it('getGameInstances() should return instances of a game, given placeId', () => {
+    return getGameInstances(142823291, 'Public', 'Asc', 100).then((res) => {
+      return expect(res).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: expect.any(String),
+            maxPlayers: expect.any(Number),
+            playing: expect.any(Number),
+            playerTokens: expect.arrayContaining([
+              expect.any(String)
+            ]),
+            fps: expect.any(Number),
+            ping: expect.any(Number)
+          })
+        ])
+      )
+    })
+  })
+
+  it('getGamePasses() should return an array of game passes, given universeId', () => {
+    return getGamePasses(2615802125).then((res) => {
+      return expect(res).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: expect.any(Number),
+            name: expect.any(String),
+            displayName: expect.any(String),
+            productId: expect.any(Number),
+            price: expect.any(Number)
+          })
+        ])
+      )
+    })
+  })
+
+  it('getGameSocialLinks() should return social link information of a game, given universeId', () => {
+    return getGameSocialLinks(2615802125).then((res) => {
+      return expect(res).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: expect.any(Number),
+            title: expect.any(String),
+            type: expect.any(String),
+            url: expect.any(String)
+          })
+        ])
+      )
+    })
+  })
+
+  it('getGroupGames() returns an array of group games', () => {
+    return getGroupGames({ groupId: 9997719, limit: 1 }).then((res) => {
+      return expect(res[0]).toMatchObject({
+        id: expect.any(Number),
+        name: expect.any(String),
+        description: expect.toBeOneOf([expect.any(String), null]),
+        creator: {
+          id: expect.any(Number),
+          type: expect.any(String)
+        },
+        rootPlace: {
+          id: expect.any(Number),
+          type: expect.any(String)
+        },
+        created: expect.any(Date),
+        updated: expect.any(Date),
+        placeVisits: expect.any(Number)
+      })
+    })
+  })
+
+  it('getUniverseInfo() should return information about universes', () => {
+    return getUniverseInfo(2152417643).then((res) => {
+      return expect(res).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: expect.any(Number),
+            rootPlaceId: expect.any(Number),
+            name: expect.any(String),
+            description: expect.any(String),
+            creator: expect.objectContaining({
+              id: expect.any(Number),
+              name: expect.any(String),
+              type: expect.any(String),
+              isRNVAccount: expect.any(Boolean)
+            }),
+            allowedGearGenres: expect.any(Array),
+            allowedGearCategories: expect.any(Array),
+            isGenreEnforced: expect.any(Boolean),
+            copyingAllowed: expect.any(Boolean),
+            playing: expect.any(Number),
+            visits: expect.any(Number),
+            maxPlayers: expect.any(Number),
+            created: expect.any(Date),
+            updated: expect.any(Date),
+            studioAccessToApisAllowed: expect.any(Boolean),
+            createVipServersAllowed: expect.any(Boolean),
+            universeAvatarType: expect.any(String),
+            genre: expect.any(String),
+            isAllGenre: expect.any(Boolean),
+            isFavoritedByUser: expect.any(Boolean),
+            favoritedCount: expect.any(Number)
+          })
+        ])
+      )
+    })
+  })
+  
+it('getPlaceInfo() should return an array of information about places', () => {
+    return getPlaceInfo(10905034443).then((res) => {
+      return expect(res).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            placeId: expect.any(Number),
+            name: expect.any(String),
+            sourceName: expect.any(String),
+            sourceDescription: expect.any(String),
+            url: expect.any(String),
+            builder: expect.any(String),
+            builderId: expect.any(Number),
+            hasVerifiedBadge: expect.any(Boolean),
+            isPlayable: expect.any(Boolean),
+            reasonProhibited: expect.any(String),
+            universeId: expect.any(Number),
+            universeRootPlaceId: expect.any(Number),
+            price: expect.any(Number),
+            imageToken: expect.any(String)
+          })
+        ])
+      )
+    })
+  })
+
+  // Dependency on getDeveloperProducts() which is broken as of 4.14.0
+  // eslint-disable-next-line jest/no-commented-out-tests
+  // it('updateDeveloperProduct() should update a developer product with new information', () => {
+  //   return getDeveloperProducts(166178819).then((productsData) => {
+  //     const developerProduct = productsData.DeveloperProducts.filter((product) => product.ProductId === newProductId)[0]
+  //     return updateDeveloperProduct(79354837, developerProduct.DeveloperProductId, `Test${Date.now().toString().slice(-6)}`, 104, 'Currently unit testing.').then((res) => {
+  //       return expect(res).toMatchObject({
+  //         universeId: 79354837,
+  //         name: expect.any(String), // account for Roblox filters
+  //         priceInRobux: 104,
+  //         description: expect.any(String), // account for Roblox filters
+  //         developerProductId: developerProduct.DeveloperProductId
+  //       })
+  //     })
+  //   })
+  // })
+})