Merge branch 'master' into feature/talk-plugin-toxic-comments

Conflicts:
	graph/resolvers/root_mutation.js
	graph/typeDefs.graphql

test/server/graph/mutations/updateAssetSettings.js

@@ -0,0 +1,73 @@
+const {graphql} = require('graphql');
+
+const schema = require('../../../../graph/schema');
+const Context = require('../../../../graph/context');
+const UserModel = require('../../../../models/user');
+const SettingsService = require('../../../../services/settings');
+const AssetModel = require('../../../../models/asset');
+
+const {expect} = require('chai');
+
+describe('graph.mutations.updateAssetSettings', () => {
+  let asset;
+  beforeEach(async () => {
+    await SettingsService.init();
+    asset = await AssetModel.create({url: 'http://new.test.com/'});
+  });
+
+  const QUERY = `
+  mutation UpdateAssetStatus($id: ID!, $settings: AssetSettingsInput!) {
+    updateAssetSettings(id: $id, input: $settings) {
+      errors {
+        translation_key
+      }
+    }
+  }
+`;
+
+  describe('context with different user roles', () => {
+
+    [
+      {error: 'NOT_AUTHORIZED'},
+      {roles: ['ADMIN', 'MODERATOR']},
+      {roles: ['MODERATOR']},
+    ].forEach(({roles, error}) => {
+      it(roles ? roles.join(', ') : '<None>', async () => {
+        const user = new UserModel({roles});
+        const ctx = new Context({user});
+
+        const settings = {
+          premodLinksEnable: false,
+          moderation: 'POST',
+          questionBoxEnable: true,
+          questionBoxContent: 'Question?',
+          questionBoxIcon: '<Icon>',
+        };
+
+        const res = await graphql(schema, QUERY, {}, ctx, {
+          id: asset.id,
+          settings,
+        });
+        if (res.errors) {
+          console.error(res.errors);
+        }
+        expect(res.errors).to.be.empty;
+
+        if (error) {
+          expect(res.data.updateAssetSettings.errors).to.not.be.empty;
+          expect(res.data.updateAssetSettings.errors[0]).to.have.property('translation_key', error);
+        } else {
+          if (res.data.updateAssetSettings && res.data.updateAssetSettings.errors) {
+            console.error(res.data.updateAssetSettings.errors);
+          }
+          expect(res.data.updateAssetSettings).to.be.null;
+
+          const retrievedAsset = await AssetModel.findOne({id: asset.id});
+          Object.keys(settings).forEach((key) => {
+            expect(retrievedAsset.settings).to.have.property(key, settings[key]);
+          });
+        }
+      });
+    });
+  });
+});

test/server/graph/mutations/updateAssetStatus.js

@@ -0,0 +1,70 @@
+const {graphql} = require('graphql');
+
+const schema = require('../../../../graph/schema');
+const Context = require('../../../../graph/context');
+const UserModel = require('../../../../models/user');
+const SettingsService = require('../../../../services/settings');
+const AssetModel = require('../../../../models/asset');
+
+const {expect} = require('chai');
+
+describe('graph.mutations.updateAssetStatus', () => {
+  let asset;
+  beforeEach(async () => {
+    await SettingsService.init();
+    asset = await AssetModel.create({url: 'http://new.test.com/'});
+  });
+
+  const QUERY = `
+    mutation UpdateAssetStatus($id: ID!, $status: UpdateAssetStatusInput!) {
+      updateAssetStatus(id: $id, input: $status) {
+        errors {
+          translation_key
+        }
+      }
+    }
+  `;
+
+  describe('context with different user roles', () => {
+
+    [
+      {error: 'NOT_AUTHORIZED'},
+      {roles: ['ADMIN', 'MODERATOR']},
+      {roles: ['MODERATOR']},
+    ].forEach(({roles, error}) => {
+      it(roles ? roles.join(', ') : '<None>', async () => {
+        const user = new UserModel({roles});
+        const ctx = new Context({user});
+
+        const closedAt = (new Date()).toISOString();
+        const closedMessage = 'my closed message!';
+
+        const res = await graphql(schema, QUERY, {}, ctx, {
+          id: asset.id,
+          status: {
+            closedAt,
+            closedMessage,
+          },
+        });
+        if (res.errors) {
+          console.error(res.errors);
+        }
+        expect(res.errors).to.be.empty;
+
+        if (error) {
+          expect(res.data.updateAssetStatus.errors).to.not.be.empty;
+          expect(res.data.updateAssetStatus.errors[0]).to.have.property('translation_key', error);
+        } else {
+          if (res.data.updateAssetStatus && res.data.updateAssetStatus.errors) {
+            console.error(res.data.updateAssetStatus.errors);
+          }
+          expect(res.data.updateAssetStatus).to.be.null;
+
+          const retrievedAsset = await AssetModel.findOne({id: asset.id});
+          expect(retrievedAsset.closedAt).to.not.be.null;
+          expect(retrievedAsset).to.have.property('closedMessage', closedMessage);
+        }
+      });
+    });
+  });
+});

test/server/graph/mutations/updateSettings.js

@@ -0,0 +1,74 @@
+const {graphql} = require('graphql');
+
+const schema = require('../../../../graph/schema');
+const Context = require('../../../../graph/context');
+const UserModel = require('../../../../models/user');
+const SettingsService = require('../../../../services/settings');
+
+const {expect} = require('chai');
+
+describe('graph.mutations.updateSettings', () => {
+  beforeEach(async () => {
+    await SettingsService.init();
+  });
+
+  const QUERY = `
+  mutation UpdateSettings($settings: UpdateSettingsInput!) {
+    updateSettings(input: $settings) {
+      errors {
+        translation_key
+      }
+    }
+  }
+`;
+
+  describe('context with different user roles', () => {
+
+    [
+      {error: 'NOT_AUTHORIZED'},
+      {error: 'NOT_AUTHORIZED', roles: []},
+      {roles: ['ADMIN']},
+      {roles: ['ADMIN', 'MODERATOR']},
+      {roles: ['MODERATOR']},
+    ].forEach(({roles, error}) => {
+      it(roles ? roles.join(', ') : '<None>', async () => {
+        let user;
+        if (roles != null) {
+          user = new UserModel({roles});
+        }
+        const ctx = new Context({user});
+
+        const newSettings = {
+          premodLinksEnable: false,
+          moderation: 'POST',
+          questionBoxEnable: true,
+          questionBoxContent: 'Question?',
+          questionBoxIcon: '<Icon>',
+        };
+
+        const res = await graphql(schema, QUERY, {}, ctx, {
+          settings: newSettings,
+        });
+        if (res.errors) {
+          console.error(res.errors);
+        }
+        expect(res.errors).to.be.empty;
+
+        if (error) {
+          expect(res.data.updateSettings.errors).to.not.be.empty;
+          expect(res.data.updateSettings.errors[0]).to.have.property('translation_key', error);
+        } else {
+          if (res.data.updateSettings && res.data.updateSettings.errors) {
+            console.error(res.data.updateSettings.errors);
+          }
+          expect(res.data.updateSettings).to.be.null;
+
+          const retrievedSettings = await SettingsService.retrieve();
+          Object.keys(newSettings).forEach((key) => {
+            expect(retrievedSettings).to.have.property(key, newSettings[key]);
+          });
+        }
+      });
+    });
+  });
+});

test/server/graph/mutations/updateWordlist.js

@@ -0,0 +1,82 @@
+const {graphql} = require('graphql');
+
+const schema = require('../../../../graph/schema');
+const Context = require('../../../../graph/context');
+const UserModel = require('../../../../models/user');
+const SettingsService = require('../../../../services/settings');
+
+const {expect} = require('chai');
+
+describe('graph.mutations.updateWordlist', () => {
+  beforeEach(async () => {
+    await SettingsService.init();
+  });
+
+  const QUERY = `
+  mutation UpdateWordlist($wordlist: UpdateWordlistInput!) {
+    updateWordlist(input: $wordlist) {
+      errors {
+        translation_key
+      }
+    }
+  }
+`;
+
+  describe('context with different user roles', () => {
+
+    [
+      {error: 'NOT_AUTHORIZED'},
+      {error: 'NOT_AUTHORIZED', roles: []},
+      {roles: ['ADMIN']},
+      {roles: ['ADMIN', 'MODERATOR']},
+      {roles: ['MODERATOR']},
+    ].forEach(({roles, error}) => {
+      it(roles && roles.length > 0 ? roles.join(', ') : '<None>', async () => {
+        let user;
+        if (roles != null) {
+          user = new UserModel({roles});
+        }
+        const ctx = new Context({user});
+
+        const wordlist = {
+          banned: [
+            'happy',
+          ],
+          suspect: [
+            'sad',
+          ],
+        };
+
+        const res = await graphql(schema, QUERY, {}, ctx, {
+          wordlist,
+        });
+        if (res.errors) {
+          console.error(res.errors);
+        }
+        expect(res.errors).to.be.empty;
+
+        if (error) {
+          expect(res.data.updateWordlist.errors).to.not.be.empty;
+          expect(res.data.updateWordlist.errors[0]).to.have.property('translation_key', error);
+
+          const {wordlist: retrievedWordlist} = await SettingsService.retrieve();
+          expect(retrievedWordlist).to.have.property('banned');
+          expect(retrievedWordlist.banned).to.have.members([]);
+          expect(retrievedWordlist).to.have.property('suspect');
+          expect(retrievedWordlist.suspect).to.have.members([]);
+        } else {
+          if (res.data.updateWordlist && res.data.updateWordlist.errors) {
+            console.error(res.data.updateWordlist.errors);
+          }
+          expect(res.data.updateWordlist).to.be.null;
+
+          const {wordlist: retrievedWordlist} = await SettingsService.retrieve();
+          expect(retrievedWordlist).to.have.property('banned');
+          expect(retrievedWordlist.banned).to.have.members(wordlist.banned);
+          expect(retrievedWordlist).to.have.property('suspect');
+          expect(retrievedWordlist.suspect).to.have.members(wordlist.suspect);
+        }
+      });
+    });
+  });
+});

test/server/graph/queries/asset.js

@@ -74,12 +74,10 @@ describe('graph.queries.asset', () => {
 
     expect(asset.nodes).to.have.length(2);
     expect(asset.hasNextPage).to.be.false;
-    expect(asset.nodes[0]).to.have.property('id', comments[1].id);
-    expect(asset.nodes[1]).to.have.property('id', comments[0].id);
+    expect(asset.nodes.map(({id}) => id)).to.have.members(comments.slice(0, 2).map(({id}) => id));
     expect(otherAsset.nodes).to.have.length(2);
     expect(otherAsset.hasNextPage).to.be.false;
-    expect(otherAsset.nodes[0]).to.have.property('id', comments[3].id);
-    expect(otherAsset.nodes[1]).to.have.property('id', comments[2].id);
+    expect(otherAsset.nodes.map(({id}) => id)).to.have.members(comments.slice(2, 4).map(({id}) => id));
 
     for (let node of asset.nodes) {
       for (let otherNode of otherAsset.nodes) {

test/server/graph/queries/settings.js

@@ -0,0 +1,97 @@
+const {graphql} = require('graphql');
+
+const schema = require('../../../../graph/schema');
+const Context = require('../../../../graph/context');
+const SettingsService = require('../../../../services/settings');
+const UserModel = require('../../../../models/user');
+
+const {expect} = require('chai');
+
+const defaultSettings = {
+  organizationName: 'The Coral Project'
+};
+
+describe('graph.queries.settings', () => {
+  let settings;
+  beforeEach(async () => {
+    settings = await SettingsService.init(defaultSettings);
+  });
+
+  const QUERY = `
+  {
+    settings {
+      moderation
+      requireEmailConfirmation
+      infoBoxEnable
+      infoBoxContent
+      questionBoxEnable
+      questionBoxContent
+      premodLinksEnable
+      questionBoxIcon
+      autoCloseStream
+      customCssUrl
+      closedTimeout
+      closedMessage
+      charCountEnable
+      charCount
+      organizationName
+      wordlist {
+        banned
+        suspect
+      }
+      domains {
+        whitelist
+      }
+    }
+  }
+  `;
+
+  describe('context with different user roles', () => {
+
+    const BLACKLISTED_PROPERTIES = [
+      'premodLinksEnable',
+      'autoCloseStream',
+      'wordlist',
+      'domains',
+    ];
+
+    [
+      {bl: true},
+      {bl: true, roles: []},
+      {bl: false, roles: ['ADMIN']},
+      {bl: false, roles: ['ADMIN', 'MODERATOR']},
+      {bl: false, roles: ['MODERATOR']},
+    ].forEach(({bl, roles}) => {
+      it(roles && roles.length > 0 ? roles.join(', ') : '<None>', async () => {
+        let user;
+        if (roles != null) {
+          user = new UserModel({roles});
+        }
+
+        const ctx = new Context({user});
+
+        const res = await graphql(schema, QUERY, {}, ctx);
+        if (res.errors) {
+          console.error(res.errors);
+        }
+
+        expect(res.errors).to.be.empty;
+        expect(res.data.settings).to.be.object;
+        Object.keys(res.data.settings).forEach((key) => {
+          if (bl && BLACKLISTED_PROPERTIES.includes(key)) {
+            expect(res.data.settings).to.have.property(key, null);
+            return;
+          }
+
+          if (typeof settings[key] !== 'object') {
+            expect(res.data.settings).to.have.property(key, settings[key]);
+          } else {
+            expect(res.data.settings).to.have.property(key);
+            expect(res.data.settings[key]).to.not.be.null;
+          }
+        });
+      });
+    });
+  });
+
+});