@friggframework/api-module-hubspot 1.2.0-canary.293.5731c31.0 → 2.0.0-next.0

package/tests/api.test.js

@@ -1,17 +1,49 @@
-const { Authenticator } = require('@friggframework/devtools');
+const {Authenticator} = require('@friggframework/test');
 const {Api} = require('../api');
 const config = require('../defaultConfig.json');
+const {promises: fs} = require("fs");
+
+const mockDir = `./mocks${Date.now()}`
+const parsedBody = async function async(resp) {
+    const contentType = resp.headers.get('Content-Type') || '';
+    let body;
+    if (
+        contentType.match(/^application\/json/) ||
+        contentType.match(/^application\/vnd.api\+json/) ||
+        contentType.match(/^application\/hal\+json/)
+    ) {
+        body = await resp.json();
+    } else {
+        body = await resp.text();
+    }
+    await fs.writeFile(`./${mockDir}/${this.lastCalled}.json`, JSON.stringify(body));
+    return body;
+}
 
 describe(`${config.label} API tests`, () => {
-
-
     const apiParams = {
         client_id: process.env.HUBSPOT_CLIENT_ID,
         client_secret: process.env.HUBSPOT_CLIENT_SECRET,
         redirect_uri: `${process.env.REDIRECT_URI}/hubspot`,
         scope: process.env.HUBSPOT_SCOPE
     };
+    Object.getOwnPropertyNames(Api.prototype).forEach(f => {
+        if (f !== 'constructor' &&
+            typeof Api.prototype[f] === 'function' &&
+            f !== 'addJsonHeaders' &&
+            !f.startsWith('_')) {
+            const old = Api.prototype[f];
+            Api.prototype[f] = function (...args) {
+                this.lastCalled = f;
+                return old.apply(this, args);
+            }
+        }
+    })
     const api = new Api(apiParams);
+    api.parsedBody = parsedBody;
+    beforeAll(async () => {
+        await fs.mkdir(mockDir, {recursive: true});
+    });
 
     beforeAll(async () => {
         const url = await api.getAuthUri();
@@ -23,6 +55,8 @@ describe(`${config.label} API tests`, () => {
         await api.getTokenFromCode(response.data.code);
     });
 
+    const testObjType = 'tests';
+
     describe('HS User Info', () => {
         it('should return the user details', async () => {
             const response = await api.getUserDetails();
@@ -327,34 +361,34 @@ describe(`${config.label} API tests`, () => {
             expect(allLandingPages.total).toBe(primaryLandingPages.total + variationLandingPages.total)
         });
 
-        it('get Landing Page by Id' , async () => {
+        it('get Landing Page by Id', async () => {
             const response = await api.getLandingPage(sampleLandingPage.id);
             expect(response).toBeDefined();
         });
-        it('update a Landing page (maximal patch)' , async () => {
+        it('update a Landing page (maximal patch)', async () => {
             delete sampleLandingPage['archivedAt'];
             const response = await api.updateLandingPage(
                 sampleLandingPage.id,
                 sampleLandingPage,
-                true );
+                true);
             expect(response).toBeDefined();
         });
-        it('update a Landing page (minimal patch)' , async () => {
+        it('update a Landing page (minimal patch)', async () => {
             const response = await api.updateLandingPage(
                 sampleLandingPage.id,
                 {htmlTitle: `test Landing page ${Date.now()}`},
-                true );
+                true);
             expect(response).toBeDefined();
         });
-        it('publish a Landing Page' , async () => {
-            const now = new Date(Date.now()+5000);
+        it('publish a Landing Page', async () => {
+            const now = new Date(Date.now() + 5000);
             const response = await api.publishLandingPage(
                 sampleLandingPage.id,
                 now.toISOString(),
             );
             expect(response).toBeDefined();
         });
-        it('push a Landing page draft to live' , async () => {
+        it('push a Landing page draft to live', async () => {
 
             const response = await api.pushLandingPageDraftToLive(sampleLandingPage.id);
             expect(response).toBeDefined();
@@ -380,17 +414,17 @@ describe(`${config.label} API tests`, () => {
         it('confirm total Site pages', async () => {
             expect(allSitePages.total).toBe(primarySitePages.total + variationSitePages.total)
         });
-        it('get Site Page by Id' , async () => {
+        it('get Site Page by Id', async () => {
             const pageToGet = primarySitePages.results.slice(-1)[0];
             const response = await api.getSitePage(pageToGet.id);
             expect(response).toBeDefined();
         });
-        it('update a Site page' , async () => {
+        it('update a Site page', async () => {
             const pageToUpdate = variationSitePages.results.slice(-1)[0];
             const response = await api.updateSitePage(
                 pageToUpdate.id,
                 {htmlTitle: `test site page ${Date.now()}`},
-                true );
+                true);
             expect(response).toBeDefined();
         });
     });
@@ -414,17 +448,17 @@ describe(`${config.label} API tests`, () => {
         it('confirm total Blog Posts', async () => {
             expect(allBlogPosts.total).toBe(primaryBlogPosts.total + variationBlogPosts.total)
         });
-        it('get Blog Post by Id' , async () => {
+        it('get Blog Post by Id', async () => {
             const postToGet = primaryBlogPosts.results.slice(-1)[0];
             const response = await api.getBlogPost(postToGet.id);
             expect(response).toBeDefined();
         });
-        it('update a Blog Post' , async () => {
+        it('update a Blog Post', async () => {
             const postToUpdate = primaryBlogPosts.results[0];
             const response = await api.updateBlogPost(
                 postToUpdate.id,
                 {htmlTitle: `test blog post ${Date.now()}`},
-                true );
+                true);
             expect(response).toBeDefined();
         });
     });
@@ -436,36 +470,84 @@ describe(`${config.label} API tests`, () => {
             expect(allEmailTemplates).toBeDefined();
             expect(allEmailTemplates).toHaveProperty('objects')
         });
-        it('get Email Template by Id' , async () => {
+        it('get Email Template by Id', async () => {
             const templateToGet = allEmailTemplates.objects.slice(-1)[0];
             const response = await api.getEmailTemplate(templateToGet.id);
             expect(response).toBeDefined();
         });
-        it('update a Email Template' , async () => {
+        it('update a Email Template', async () => {
             const postToUpdate = allEmailTemplates.objects.slice(-1)[0];
             const response = await api.updateEmailTemplate(
                 postToUpdate.id,
                 {label: `test email template ${Date.now()}`},
-                 );
+            );
             expect(response).toBeDefined();
         });
         let createdId;
-        it('create an Email Template' , async () => {
+        it('create an Email Template', async () => {
             const response = await api.createEmailTemplate(
                 allEmailTemplates.objects.slice(-1)[0]
             );
             expect(response).toBeDefined();
             createdId = response.id;
         });
-        it('Delete an Email Template' , async () => {
+        it('Delete an Email Template', async () => {
             const response = await api.deleteEmailTemplate(createdId)
             expect(response.status).toBe(204);
         });
     });
 
-    describe.only('HS Custom Objects', () => {
+    describe('Custom Object Schemas', () => {
+        const testSchema = {
+            "labels": {"singular": "Test Object", "plural": "Test Objects"},
+            "requiredProperties": ["word"],
+            "searchableProperties": ["word"],
+            "primaryDisplayProperty": "word",
+            "secondaryDisplayProperties": [],
+            "description": null,
+            "properties": [{
+                "name": "word",
+                "label": "Word",
+                "type": "string",
+                "fieldType": "text",
+                "description": "",
+                "hasUniqueValue": false
+            }],
+            "associatedObjects": [
+                "COMPANY"
+            ],
+            "name": "test_object"
+        }
+
+        it('should return the Custom Object Schemas', async () => {
+            const response = await api.listCustomObjectSchemas();
+            expect(response).toBeDefined();
+            expect(response).toHaveProperty('results');
+            expect(response.results.length).toBeGreaterThan(0);
+            expect(response.results.filter(s => s.name === testSchema.name).length).toBe(0);
+        });
+
+        it('should create a Custom Object Schema', async () => {
+            const response = await api.createCustomObjectSchema(testSchema);
+            expect(response).toBeDefined();
+            expect(response).toHaveProperty('id');
+        });
+
+        it('Should get association labels', async () => {
+            const labels = await api.getAssociationLabels('COMPANY', testSchema.name);
+            expect(labels).toBeDefined();
+            expect(labels.results).toHaveProperty('length');
+            expect(labels.results.find(label => label.label === 'Primary')).toBeTruthy();
+        })
+
+        it('should delete a Custom Object Schema', async () => {
+            const response = await api.deleteCustomObjectSchema(testSchema.name);
+            expect(response.status).toBe(204);
+        })
+    })
+
+    describe('HS Custom Objects', () => {
         let allCustomObjects;
-        const testObjType = 'tests';
         let oneWord;
         const createWord = 'Test Custom Object Create';
         const updateWord = 'Test Custom Object Update';
@@ -478,13 +560,13 @@ describe(`${config.label} API tests`, () => {
             expect(allCustomObjects).toHaveProperty('results')
             oneWord = allCustomObjects.results.find(o => o.properties.word === 'One');
         });
-        it('get Custom Object by Id' , async () => {
+        it('get Custom Object by Id', async () => {
             const objectToGet = allCustomObjects.results.slice(-1)[0];
             const response = await api.getCustomObject(testObjType, objectToGet.id);
             expect(response).toBeDefined();
         });
         let createdObject;
-        it('create a Custom Object' , async () => {
+        it('create a Custom Object', async () => {
             createdObject = await api.createCustomObject(
                 testObjType,
                 {
@@ -492,10 +574,10 @@ describe(`${config.label} API tests`, () => {
                         word: createWord
                     }
                 },
-             );
+            );
             expect(createdObject).toBeDefined();
         })
-        it('update a Custom Object' , async () => {
+        it('update a Custom Object', async () => {
             const response = await api.updateCustomObject(
                 testObjType,
                 createdObject.id,
@@ -504,10 +586,10 @@ describe(`${config.label} API tests`, () => {
                         word: updateWord
                     }
                 },
-             );
+            );
             expect(response).toBeDefined();
         });
-        it('Search for custom object' , async () => {
+        it('Search for custom object', async () => {
             // Search doesn't work on objects that were very recently created
             const response = await api.searchCustomObjects(
                 testObjType,
@@ -525,12 +607,12 @@ describe(`${config.label} API tests`, () => {
                         }
                     ]
                 }
-             );
+            );
             expect(response).toBeDefined();
             expect(response.results).toHaveProperty('length');
             expect(response.results[0].id).toBe(oneWord.id);
         });
-        it('delete a Custom Object' , async () => {
+        it('delete a Custom Object', async () => {
             const response = await api.deleteCustomObject(testObjType, createdObject.id);
             expect(response.status).toBe(204);
         })
@@ -539,7 +621,7 @@ describe(`${config.label} API tests`, () => {
         const batchSize = 100;
         let createdBatch;
         it('Should bulk create a batch of objects', async () => {
-            const range = Array.from({ length: batchSize }, (_, i) => i);
+            const range = Array.from({length: batchSize}, (_, i) => i);
             const objectsToCreate = range.map(i => ({
                 properties: {
                     word: `Test Bulk Create ${i}`
@@ -554,7 +636,9 @@ describe(`${config.label} API tests`, () => {
             createdBatch = response.results;
         })
         it('Should read a batch of objects', async () => {
-            const inputs = createdBatch.map(o => {return {id: o.id}});
+            const inputs = createdBatch.map(o => {
+                return {id: o.id}
+            });
             const response = await api.bulkReadCustomObjects(
                 testObjType,
                 {
@@ -585,7 +669,9 @@ describe(`${config.label} API tests`, () => {
             expect(response.results.length).toBe(batchSize);
         });
         it('Should delete a batch of objects', async () => {
-            const inputs = createdBatch.map(o => {return {id: o.id}});
+            const inputs = createdBatch.map(o => {
+                return {id: o.id}
+            });
             const response = await api.bulkArchiveCustomObjects(
                 testObjType,
                 {
@@ -615,8 +701,251 @@ describe(`${config.label} API tests`, () => {
                     ]
                 }
             );
-            const inputs = response.results.map(o => {return {id: o.id}});
+            const inputs = response.results.map(o => {
+                return {id: o.id}
+            });
             await api.bulkArchiveCustomObjects(testObjType, {inputs});
         })
     })
+
+    describe('HS List Requests', () => {
+        it('Should get a list of lists', async () => {
+            const response = await api.searchLists();
+            expect(response).toBeDefined();
+            expect(response.lists).toHaveProperty('length');
+        });
+        let createdListId;
+        it('Should create a list', async () => {
+            const {list} = await api.createList('Test List', '0-2');
+            createdListId = list.listId;
+        });
+        it('Should get a list', async () => {
+            const response = await api.getListById(createdListId);
+            expect(response).toBeDefined();
+            expect(response.list.listId).toBe(createdListId);
+        })
+        it('Should add a record to list', async () => {
+            const companyResponse = await api.listCompanies();
+            const someCompanyId = companyResponse.results[0].id;
+            const response = await api.addToList(createdListId, [someCompanyId]);
+            expect(response).toBeDefined();
+            // HS has a typo in the response "recordsIds" instead of "recordIds"
+            expect(response.recordsIdsAdded).toHaveLength(1);
+        })
+        it('Should remove all records from list', async () => {
+            const response = await api.removeAllListMembers(createdListId);
+            expect(response.status).toBe(204);
+        })
+        it('Should delete a list', async () => {
+            const response = await api.deleteList(createdListId);
+            expect(response).toBeDefined();
+            expect(response.status).toBe(204);
+        })
+    });
+
+    describe('Association Labels', () => {
+        it('Should get association labels', async () => {
+            const labels = await api.getAssociationLabels('COMPANY', 'CONTACT');
+            expect(labels).toBeDefined();
+            expect(labels.results).toHaveProperty('length');
+            expect(labels.results.find(label => label.label && label.label.includes('Primary'))).toBeTruthy();
+        })
+
+        let createdBatch;
+        let toCompany;
+        beforeAll(async () => {
+            const batchSize = 20;
+            const range = Array.from({length: batchSize}, (_, i) => i);
+            const objectsToCreate = range.map(i => ({
+                properties: {
+                    word: `Test Bulk Create ${Date.now()}${i}`
+                },
+            }))
+            const response = await api.bulkCreateCustomObjects(
+                testObjType,
+                {inputs: objectsToCreate}
+            );
+            expect(response.results).toHaveProperty('length');
+            expect(response.results.length).toBe(batchSize);
+            createdBatch = response.results;
+
+            const companyResponse = await api.listCompanies();
+            toCompany = companyResponse.results[0].id;
+        })
+
+        it('Should create batch default associations', async () => {
+            const inputs = createdBatch.map(o => {
+                return {
+                    from: {id: o.id},
+                    to: {id: toCompany}
+                }
+            });
+            const response = await api.createBatchAssociationsDefault(
+                testObjType,
+                'COMPANY',
+                inputs
+            );
+            expect(response).toBeDefined();
+            expect(response).toHaveProperty('length');
+            expect(response.length).toBe(createdBatch.length * 2);
+        })
+
+        let createdLabel;
+        it('Should create a test association label', async () => {
+            const response = await api.createAssociationLabel(testObjType, 'COMPANY', {
+                inverseLabel: 'ooF',
+                name: 'Foo',
+                label: 'Foo',
+            });
+            expect(response).toBeDefined();
+            const {results} = response;
+            expect(results).toHaveProperty('length');
+            expect(results.length).toBe(2);
+            expect(results.find(label => label.label && label.label === 'Foo')).toBeTruthy();
+            createdLabel = results.find(label => label.label && label.label === 'Foo');
+        })
+
+        it('Should get association labels', async () => {
+            const labels = await api.getAssociationLabels(testObjType, 'COMPANY');
+            expect(labels).toBeDefined();
+            expect(labels.results).toHaveProperty('length');
+            expect(labels.results.find(label => label.label && label.label === 'Foo')).toBeTruthy();
+            const created = labels.results.find(label => label.label && label.label === 'Foo');
+            expect(created).toEqual(createdLabel);
+        })
+
+        it('Should associate a batch of objects', async () => {
+            const inputs = createdBatch.map(o => {
+                return {
+                    types: [{
+                        associationCategory: createdLabel.category,
+                        associationTypeId: createdLabel.typeId
+                    }],
+                    from: {id: o.id},
+                    to: {id: toCompany}
+                }
+            });
+            const response = await api.createBatchAssociations(
+                testObjType,
+                'COMPANY',
+                inputs
+            );
+            expect(response).toBeDefined();
+            expect(response).toHaveProperty('length');
+            expect(response.length).toBe(createdBatch.length);
+        });
+
+        it('Should read the associations of a batch of objects', async () => {
+            const inputs = createdBatch.map(o => ({id: o.id}));
+            const response = await api.getBatchAssociations(
+                testObjType,
+                'COMPANY',
+                inputs
+            )
+            expect(response).toBeDefined();
+            expect(response).toHaveProperty('length');
+            expect(response.length).toBe(createdBatch.length);
+            for (const a of response) {
+                expect(a).toHaveProperty('to');
+                expect(a.to[0].associationTypes).toHaveProperty('length');
+                expect(a.to[0].associationTypes.some(t => t.typeId === createdLabel.typeId)).toBe(true);
+            }
+        })
+
+        it('Should remove the specific labelled associations of a batch of objects', async () => {
+            const inputs = createdBatch.map(o => {
+                return {
+                    types: [{
+                        associationCategory: createdLabel.category,
+                        associationTypeId: createdLabel.typeId
+                    }],
+                    from: {id: o.id},
+                    to: {id: toCompany}
+                }
+            });
+            const response = await api.deleteBatchAssociationLabels(
+                testObjType,
+                'COMPANY',
+                inputs
+            );
+            expect(response).toBeDefined();
+            expect(response.status).toBe(204);
+        })
+
+        it('Should delete an association label', async () => {
+            const response = await api.deleteAssociationLabel(testObjType, 'COMPANY', createdLabel.typeId);
+            expect(response).toBeDefined();
+            expect(response.status).toBe(204);
+        })
+
+        afterAll(async () => {
+            const inputs = createdBatch.map(o => {
+                return {id: o.id}
+            });
+            const response = await api.bulkArchiveCustomObjects(
+                testObjType,
+                {
+                    inputs
+                }
+            );
+            expect(response).toBeDefined();
+            expect(response).toBe("");
+        });
+    });
+
+    describe('Properties requests', () => {
+        let groupeName;
+        it('Should retrieve a property', async () => {
+            const response = await api.getPropertyByName('tests', 'word');
+            expect(response).toBeDefined();
+            expect(response).toHaveProperty('label');
+            expect(response.label).toBe('Word');
+            groupeName = response.groupName;
+        });
+
+        it('Should create a property', async () => {
+            const response = await api.createProperty('tests', {
+                "name": "test_field",
+                "label": "Test Field",
+                "type": "enumeration",
+                "fieldType": "select",
+                "groupName": groupeName,
+                "description": "A test of enumerated fields",
+                "options": [
+                    {
+                        "label": "Item One",
+                        "value": "item_one"
+                    },
+                    {
+                        "label": "Item Two",
+                        "value": "item_two"
+                    }
+                ]
+            });
+            expect(response).toBeDefined();
+            expect(response).toHaveProperty('label');
+            expect(response.name).toBe('test_field');
+        });
+
+        it('Should update a property', async () => {
+            const existing = await api.getPropertyByName('tests', 'test_field');
+            existing.options.push(
+                {
+                    "label": "Item Three",
+                    "value": "item_three",
+                }
+            )
+            const response = await api.updateProperty('tests', 'test_field', existing);
+            expect(response).toBeDefined();
+            expect(response).toHaveProperty('options');
+            expect(response.options.some(o => o.label === 'Item Three')).toBeTruthy();
+        });
+
+        it('Should delete a property', async () => {
+            const response = await api.deleteProperty('tests', 'test_field');
+            expect(response).toBeDefined();
+            expect(response.status).toBe(204);
+        })
+
+    })
 });

package/tests/auther.test.js

@@ -1,6 +1,6 @@
-const { connectToDatabase, disconnectFromDatabase, createObjectId, Auther} = require('@friggframework/core');
-const { Authenticator, testAutherDefinition } = require('@friggframework/devtools');
-const { Definition} = require('../definition');
+const {connectToDatabase, disconnectFromDatabase, createObjectId, Auther} = require('@friggframework/core');
+const {Authenticator, testAutherDefinition} = require('@friggframework/devtools');
+const {Definition} = require('../definition');
 
 const authorizeResponse = {
     "base": "/redirect/hubspot",
@@ -100,7 +100,7 @@ describe.skip('HubSpot Module Live Tests', () => {
             expect(firstRes.entity_id).toBeDefined();
             expect(firstRes.credential_id).toBeDefined();
         });
-        it.skip('retrieves existing entity on subsequent calls', async () =>{
+        it.skip('retrieves existing entity on subsequent calls', async () => {
             const response = await Authenticator.oauth2(authUrl);
             const res = await module.processAuthorizationCallback({
                 data: {