Merge pull request #48 from CMU-17313Q/feat/polls-vote-api

Feat/polls vote api issue 4

Author: dkhalifa25

public/openapi/write.yaml

@@ -184,6 +184,8 @@ paths:
     $ref: 'write/posts/pid/move.yaml'
   /posts/{pid}/vote:
     $ref: 'write/posts/pid/vote.yaml'
+  /posts/{pid}/poll/vote:
+    $ref: 'write/posts/pid/poll/vote.yaml'
   /posts/{pid}/voters:
     $ref: 'write/posts/pid/voters.yaml'
   /posts/{pid}/upvoters:

public/openapi/write/posts/pid/poll/vote.yaml

@@ -0,0 +1,62 @@
+post:
+  tags:
+    - posts
+    - polls
+  summary: Submit a vote to a poll
+  description: This operation casts a vote on a poll attached to a post. Users can only vote once per poll.
+  parameters:
+    - in: path
+      name: pid
+      schema:
+        type: string
+      required: true
+      description: a valid post id that has an attached poll
+      example: 2
+  requestBody:
+    required: true
+    content:
+      application/json:
+        schema:
+          type: object
+          properties:
+            optionIndex:
+              type: number
+              description: Zero-based index of the poll option to vote for
+              example: 0
+          required:
+            - optionIndex
+  responses:
+    '200':
+      description: Vote successfully cast
+      content:
+        application/json:
+          schema:
+            type: object
+            properties:
+              status:
+                $ref: ../../../../components/schemas/Status.yaml#/Status
+              response:
+                type: object
+                properties:
+                  pollId:
+                    type: string
+                    description: Unique identifier of the poll
+                  optionIndex:
+                    type: number
+                    description: Index of the voted option
+                  counts:
+                    type: object
+                    description: Updated vote counts for all poll options
+                    additionalProperties:
+                      type: number
+                  voted:
+                    type: boolean
+                    description: Confirmation that the vote was recorded
+    '400':
+      $ref: ../../../../components/responses/400.yaml#/400
+    '401':
+      $ref: ../../../../components/responses/401.yaml#/401
+    '403':
+      $ref: ../../../../components/responses/403.yaml#/403
+    '404':
+      $ref: ../../../../components/responses/404.yaml#/404

src/api/posts.js

@@ -22,6 +22,52 @@ const notifications = require('../notifications');
 
 const postsAPI = module.exports;
 
+postsAPI.submitPollVote = async function (caller, data) {
+	if (!caller.uid) {
+		throw new Error('[[error:not-logged-in]]');
+	}
+	
+	if (!data || !data.pid || typeof data.optionIndex !== 'number') {
+		throw new Error('[[error:invalid-data]]');
+	}
+	
+	const { pid, optionIndex } = data;
+	
+	// Get the poll for this post
+	const Polls = require('../polls/model');
+	const Votes = require('../polls/votes');
+	
+	const poll = await Polls.getPollByPostId(pid);
+	if (!poll) {
+		throw new Error('[[error:no-poll-found]]');
+	}
+	
+	// Check if user already voted
+	const { pollId } = poll;
+	const userId = caller.uid;
+	
+	try {
+		// Record the vote (this will throw if user already voted)
+		await Votes.recordVote({ pollId, userId, optionIndex });
+		
+		// Get updated counts
+		const counts = await Votes.getCounts(pollId);
+		
+		// Return the updated poll information
+		return {
+			pollId,
+			optionIndex,
+			counts,
+			voted: true,
+		};
+	} catch (err) {
+		if (err.code === 'ALREADY_VOTED') {
+			throw new Error('[[error:already-voted]]');
+		}
+		throw err;
+	}
+};
+
 postsAPI.get = async function (caller, data) {
 	const [userPrivileges, post, voted] = await Promise.all([
 		privileges.posts.get([data.pid], caller.uid),

src/controllers/write/posts.js

@@ -209,4 +209,9 @@ Posts.notifyQueuedPostOwner = async (req, res) => {
 	const { id } = req.params;
 	await api.posts.notifyQueuedPostOwner(req, { id, message: req.body.message });
 	helpers.formatApiResponse(200, res);
+};
+
+Posts.submitPollVote = async (req, res) => {
+	const result = await api.posts.submitPollVote(req, { pid: req.params.pid, optionIndex: req.body.optionIndex });
+	helpers.formatApiResponse(200, res, result);
 };

src/polls/model.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const db = require.main.require('./src/database');
+const db = require('../database');
 const { v4: uuid } = require('uuid');
 
 const PollModel = {

src/polls/votes.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const db = require.main.require('./src/database');
+const db = require('../database');
 
 const Votes = {
 	/**

src/routes/write/posts.js

@@ -26,6 +26,7 @@ module.exports = function () {
 
 	setupApiRoute(router, 'put', '/:pid/vote', [...middlewares, middleware.checkRequired.bind(null, ['delta'])], controllers.write.posts.vote);
 	setupApiRoute(router, 'delete', '/:pid/vote', middlewares, controllers.write.posts.unvote);
+	setupApiRoute(router, 'post', '/:pid/poll/vote', [...middlewares, middleware.checkRequired.bind(null, ['optionIndex'])], controllers.write.posts.submitPollVote);
 	setupApiRoute(router, 'get', '/:pid/voters', [middleware.assert.post], controllers.write.posts.getVoters);
 	setupApiRoute(router, 'get', '/:pid/upvoters', [middleware.assert.post], controllers.write.posts.getUpvoters);
 

test/poll-vote-api-direct.js

@@ -0,0 +1,92 @@
+'use strict';
+
+// Prime NodeBB require paths + use the mock DB (so this test doesn't hit real Redis)
+require('../require-main');
+require('./mocks/databasemock');
+
+const assert = require('assert');
+const Polls = require('../src/polls/model');
+const apiPosts = require('../src/api/posts');
+
+describe('Poll Vote API Function (Issue 4)', function () {
+	let pollId;
+	let testPid;
+	const testUid = 123;
+
+	before(async function () {
+		// Create a test poll
+		const poll = await Polls.createPoll({
+			postId: 'post-456',
+			question: 'API Test Poll Question',
+			options: ['Option A', 'Option B', 'Option C'],
+			createdBy: 'admin',
+		});
+		pollId = poll.pollId;
+		testPid = 'post-456';
+	});
+
+	it('should allow a user to vote via the API function', async function () {
+		const caller = {
+			uid: testUid,
+			ip: '127.0.0.1',
+		};
+		
+		const data = {
+			pid: testPid,
+			optionIndex: 1,
+		};
+		
+		const result = await apiPosts.submitPollVote(caller, data);
+		
+		// Check the response
+		assert.ok(result);
+		assert.strictEqual(result.optionIndex, 1);
+		assert.strictEqual(result.voted, true);
+		assert.ok(result.pollId);
+		assert.strictEqual(result.counts['1'], 1);
+	});
+
+	it('should prevent double voting via the API function', async function () {
+		const caller = {
+			uid: testUid,
+			ip: '127.0.0.1',
+		};
+		
+		const data = {
+			pid: testPid,
+			optionIndex: 2, // Try to vote for a different option
+		};
+		
+		let err;
+		try {
+			await apiPosts.submitPollVote(caller, data);
+		} catch (e) {
+			err = e;
+		}
+		
+		assert.ok(err, 'Expected error for double voting');
+		assert.ok(err.message.includes('already-voted'), `Expected "already-voted" error, got: ${err.message}`);
+	});
+	
+	it('should reject unauthenticated users', async function () {
+		const caller = {
+			uid: 0, // Unauthenticated user
+			ip: '127.0.0.1',
+		};
+		
+		const data = {
+			pid: testPid,
+			optionIndex: 0,
+		};
+		
+		let err;
+		try {
+			await apiPosts.submitPollVote(caller, data);
+		} catch (e) {
+			err = e;
+		}
+		
+		assert.ok(err, 'Expected error for unauthenticated user');
+		assert.ok(err.message.includes('not-logged-in'), `Expected "not-logged-in" error, got: ${err.message}`);
+	});
+});

test/poll-vote-api.js

@@ -0,0 +1,100 @@
+'use strict';
+
+// Prime NodeBB require paths + use the mock DB (so this test doesn't hit real Redis)
+require('../require-main');
+require('./mocks/databasemock');
+
+const assert = require('assert');
+const Polls = require('../src/polls/model');
+const Votes = require('../src/polls/votes');
+
+describe('Poll Vote API (Issue 4)', function () {
+	let pollId;
+	const testUid = 'user123';
+	const testPid = 'post456';
+
+	before(async function () {
+		// Create a test poll attached to a post
+		const poll = await Polls.createPoll({
+			postId: testPid,
+			question: 'Test Poll Question',
+			options: ['Option A', 'Option B', 'Option C'],
+			createdBy: 'admin',
+		});
+		pollId = poll.pollId;
+	});
+
+	it('should allow a user to vote on a poll', async function () {
+		// Test the core voting logic
+		const result = await Votes.recordVote({ pollId, userId: testUid, optionIndex: 0 });
+		assert.strictEqual(result, true);
+
+		// Verify the vote was recorded
+		const hasVoted = await Votes.hasUserVoted(pollId, testUid);
+		assert.strictEqual(hasVoted, true);
+
+		// Check the user's choice
+		const choice = await Votes.getUserChoice(pollId, testUid);
+		assert.strictEqual(choice, 0);
+
+		// Check vote counts
+		const counts = await Votes.getCounts(pollId);
+		assert.strictEqual(counts[0], 1);
+		assert.strictEqual(counts[1] || 0, 0);
+		assert.strictEqual(counts[2] || 0, 0);
+	});
+
+	it('should prevent double voting by the same user', async function () {
+		let err;
+		try {
+			await Votes.recordVote({ pollId, userId: testUid, optionIndex: 1 });
+		} catch (e) { err = e; }
+		assert.ok(err, 'Expected an error for double voting');
+		assert.strictEqual(err.code, 'ALREADY_VOTED');
+	});
+
+	it('should handle multiple users voting on different options', async function () {
+		const anotherUser = 'user456';
+		const thirdUser = 'user789';
+
+		// Second user votes for option 1
+		const result1 = await Votes.recordVote({ pollId, userId: anotherUser, optionIndex: 1 });
+		assert.strictEqual(result1, true);
+
+		// Third user votes for option 2
+		const result2 = await Votes.recordVote({ pollId, userId: thirdUser, optionIndex: 2 });
+		assert.strictEqual(result2, true);
+
+		// Check final vote counts
+		const counts = await Votes.getCounts(pollId);
+		assert.strictEqual(counts[0], 1); // First user's vote
+		assert.strictEqual(counts[1], 1); // Second user's vote
+		assert.strictEqual(counts[2], 1); // Third user's vote
+	});
+
+	it('should validate vote parameters', async function () {
+		// Test missing pollId
+		let err;
+		try {
+			await Votes.recordVote({ userId: 'test', optionIndex: 0 });
+		} catch (e) { err = e; }
+		assert.ok(err, 'Expected an error for missing pollId');
+		assert.strictEqual(err.code, 'BAD_INPUT');
+
+		// Test missing userId
+		err = null;
+		try {
+			await Votes.recordVote({ pollId, optionIndex: 0 });
+		} catch (e) { err = e; }
+		assert.ok(err, 'Expected an error for missing userId');
+		assert.strictEqual(err.code, 'BAD_INPUT');
+
+		// Test invalid optionIndex
+		err = null;
+		try {
+			await Votes.recordVote({ pollId, userId: 'newuser', optionIndex: 'invalid' });
+		} catch (e) { err = e; }
+		assert.ok(err, 'Expected an error for invalid optionIndex');
+		assert.strictEqual(err.code, 'BAD_INPUT');
+	});
+});