fix: Allow shutter in proposal privacy if space is using shutter privacy

src/writer/proposal.ts

@@ -102,7 +102,11 @@ export async function verify(body): Promise<any> {
     if (msg.payload.type !== space.voting.type) return Promise.reject('invalid voting type');
   }
 
-  if (space.voting?.privacy !== 'any' && msg.payload.privacy) {
+  if (
+    space.voting?.privacy !== 'any' &&
+    msg.payload.privacy &&
+    !(space.voting?.privacy === 'shutter' && msg.payload.privacy === 'shutter')
+  ) {
     return Promise.reject('not allowed to set privacy');
   }
 

src/writer/update-proposal.ts

@@ -49,7 +49,11 @@ export async function verify(body): Promise<any> {
 
   if (proposal.author !== body.address) return Promise.reject('Not the author');
 
-  if (space.voting?.privacy !== 'any' && msg.payload.privacy) {
+  if (
+    space.voting?.privacy !== 'any' &&
+    msg.payload.privacy &&
+    !(space.voting.privacy === 'shutter' && msg.payload.privacy === 'shutter')
+  ) {
     return Promise.reject('not allowed to set privacy');
   }
 

test/schema.sql

@@ -58,6 +58,7 @@ CREATE TABLE proposals (
   scores_state VARCHAR(24) NOT NULL,
   scores_total DECIMAL(64,30) NOT NULL,
   scores_updated INT(11) NOT NULL,
+  vp_value_by_strategy JSON DEFAULT NULL,
   votes INT(12) NOT NULL,
   flagged INT NOT NULL DEFAULT 0,
   PRIMARY KEY (id),

test/unit/writer/proposal.test.ts

@@ -1,21 +1,21 @@
 import omit from 'lodash/omit';
-import * as writer from '../../../src/writer/proposal';
-import input from '../../fixtures/writer-payload/proposal.json';
-import { spacesGetSpaceFixtures } from '../../fixtures/space';
 import {
+  ACTIVE_PROPOSAL_BY_AUTHOR_LIMIT,
   ECOSYSTEM_SPACE_PROPOSAL_DAY_LIMIT,
-  FLAGGED_SPACE_PROPOSAL_DAY_LIMIT,
-  SPACE_PROPOSAL_DAY_LIMIT,
-  VERIFIED_SPACE_PROPOSAL_DAY_LIMIT,
   ECOSYSTEM_SPACE_PROPOSAL_MONTH_LIMIT,
+  FLAGGED_SPACE_PROPOSAL_DAY_LIMIT,
   FLAGGED_SPACE_PROPOSAL_MONTH_LIMIT,
-  SPACE_PROPOSAL_MONTH_LIMIT,
-  VERIFIED_SPACE_PROPOSAL_MONTH_LIMIT,
   MAINNET_ECOSYSTEM_SPACES,
-  ACTIVE_PROPOSAL_BY_AUTHOR_LIMIT,
+  SPACE_PROPOSAL_DAY_LIMIT,
+  SPACE_PROPOSAL_MONTH_LIMIT,
   TURBO_SPACE_PROPOSAL_DAY_LIMIT,
-  TURBO_SPACE_PROPOSAL_MONTH_LIMIT
+  TURBO_SPACE_PROPOSAL_MONTH_LIMIT,
+  VERIFIED_SPACE_PROPOSAL_DAY_LIMIT,
+  VERIFIED_SPACE_PROPOSAL_MONTH_LIMIT
 } from '../../../src/helpers/limits';
+import * as writer from '../../../src/writer/proposal';
+import { spacesGetSpaceFixtures } from '../../fixtures/space';
+import input from '../../fixtures/writer-payload/proposal.json';
 
 const FLAGGED_ADDRESSES = ['0x0'];
 
@@ -69,6 +69,12 @@ mockGetProposalsCount.mockResolvedValue([
   }
 ]);
 
+function updateInputPayload(input: any, payload: any) {
+  const msg = JSON.parse(input.msg);
+
+  return { ...input, msg: JSON.stringify({ ...msg, payload: { ...msg.payload, ...payload } }) };
+}
+
 describe('writer/proposal', () => {
   afterEach(jest.clearAllMocks);
 
@@ -294,6 +300,139 @@ describe('writer/proposal', () => {
           expect(mockSnapshotUtilsValidate).toHaveBeenCalledTimes(0);
         });
       });
+
+      describe('when the space is using ANY privacy', () => {
+        beforeEach(() => {
+          mockGetSpace.mockResolvedValueOnce({
+            ...spacesGetSpaceFixtures,
+            voting: { privacy: 'any' }
+          });
+        });
+
+        it('accepts a proposal with shutter privacy', async () => {
+          expect.assertions(2);
+          await expect(
+            writer.verify(updateInputPayload(input, { privacy: 'shutter' }))
+          ).resolves.toBeUndefined();
+          expect(mockGetSpace).toHaveBeenCalledTimes(1);
+        });
+
+        it('accepts a proposal with undefined privacy', async () => {
+          expect.assertions(2);
+          await expect(
+            writer.verify(updateInputPayload(input, { privacy: undefined }))
+          ).resolves.toBeUndefined();
+          expect(mockGetSpace).toHaveBeenCalledTimes(1);
+        });
+
+        it('accepts a proposal with no privacy', async () => {
+          expect.assertions(2);
+          await expect(
+            writer.verify(updateInputPayload(input, { privacy: '' }))
+          ).resolves.toBeUndefined();
+          expect(mockGetSpace).toHaveBeenCalledTimes(1);
+        });
+      });
+
+      // Fallback as if { privacy: '' } (privacy disabled)
+      describe('when the space is missing the privacy settings', () => {
+        beforeEach(() => {
+          mockGetSpace.mockResolvedValueOnce({
+            ...spacesGetSpaceFixtures,
+            voting: undefined
+          });
+        });
+
+        it('rejects a proposal with shutter privacy', async () => {
+          expect.assertions(2);
+          await expect(
+            writer.verify(updateInputPayload(input, { privacy: 'shutter' }))
+          ).rejects.toMatch('not allowed to set privacy');
+          expect(mockGetSpace).toHaveBeenCalledTimes(1);
+        });
+
+        it('accepts a proposal with undefined privacy', async () => {
+          expect.assertions(2);
+          await expect(
+            writer.verify(updateInputPayload(input, { privacy: undefined }))
+          ).resolves.toBeUndefined();
+          expect(mockGetSpace).toHaveBeenCalledTimes(1);
+        });
+
+        it('accepts a proposal with no privacy', async () => {
+          expect.assertions(2);
+          await expect(
+            writer.verify(updateInputPayload(input, { privacy: '' }))
+          ).resolves.toBeUndefined();
+          expect(mockGetSpace).toHaveBeenCalledTimes(1);
+        });
+      });
+
+      describe('when the space is using NO privacy', () => {
+        beforeEach(() => {
+          mockGetSpace.mockResolvedValueOnce({
+            ...spacesGetSpaceFixtures,
+            voting: { privacy: '' }
+          });
+        });
+
+        it('rejects a proposal with shutter privacy', async () => {
+          expect.assertions(2);
+          await expect(
+            writer.verify(updateInputPayload(input, { privacy: 'shutter' }))
+          ).rejects.toMatch('not allowed to set privacy');
+          expect(mockGetSpace).toHaveBeenCalledTimes(1);
+        });
+
+        it('accepts a proposal with undefined privacy', async () => {
+          expect.assertions(2);
+          await expect(
+            writer.verify(updateInputPayload(input, { privacy: undefined }))
+          ).resolves.toBeUndefined();
+          expect(mockGetSpace).toHaveBeenCalledTimes(1);
+        });
+
+        it('accepts a proposal with no privacy', async () => {
+          expect.assertions(2);
+          await expect(
+            writer.verify(updateInputPayload(input, { privacy: '' }))
+          ).resolves.toBeUndefined();
+          expect(mockGetSpace).toHaveBeenCalledTimes(1);
+        });
+      });
+
+      describe('when the space is using SHUTTER privacy', () => {
+        beforeEach(() => {
+          mockGetSpace.mockResolvedValueOnce({
+            ...spacesGetSpaceFixtures,
+            voting: { privacy: 'shutter' }
+          });
+        });
+
+        it('accepts a proposal with shutter privacy', async () => {
+          expect.assertions(2);
+          await expect(
+            writer.verify(updateInputPayload(input, { privacy: 'shutter' }))
+          ).resolves.toBeUndefined();
+          expect(mockGetSpace).toHaveBeenCalledTimes(1);
+        });
+
+        it('accepts a proposal with undefined privacy', async () => {
+          expect.assertions(2);
+          await expect(
+            writer.verify(updateInputPayload(input, { privacy: undefined }))
+          ).resolves.toBeUndefined();
+          expect(mockGetSpace).toHaveBeenCalledTimes(1);
+        });
+
+        it('accepts a proposal with empty string in privacy', async () => {
+          expect.assertions(2);
+          await expect(
+            writer.verify(updateInputPayload(input, { privacy: '' }))
+          ).resolves.toBeUndefined();
+          expect(mockGetSpace).toHaveBeenCalledTimes(1);
+        });
+      });
     });
 
     it('rejects if the snapshot is in the future', async () => {