Create scheduled post api integration

app/actions/remote/scheduled_post.test.ts

@@ -0,0 +1,72 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+import DatabaseManager from '@database/manager';
+import NetworkManager from '@managers/network_manager';
+
+import {createScheduledPost} from './scheduled_post';
+
+import type ServerDataOperator from '@database/operator/server_data_operator';
+
+const serverUrl = 'baseHandler.test.com';
+let operator: ServerDataOperator;
+
+const user1 = {id: 'userid1', username: 'user1', email: '[email protected]', roles: ''} as UserProfile;
+const scheduledPost = {
+    id: 'scheduledPostId1',
+    root_id: '',
+    update_at: 0,
+    channel_id: 'channelid1',
+    message: 'Test message',
+    scheduled_at: Date.now() + 10000,
+} as ScheduledPost;
+
+const throwFunc = () => {
+    throw Error('error');
+};
+
+const mockClient = {
+    createScheduledPost: jest.fn(() => ({...scheduledPost})),
+};
+
+beforeAll(() => {
+    // eslint-disable-next-line
+    // @ts-ignore
+    NetworkManager.getClient = () => mockClient;
+});
+
+beforeEach(async () => {
+    await DatabaseManager.init([serverUrl]);
+    operator = DatabaseManager.serverDatabases[serverUrl]!.operator;
+});
+
+afterEach(async () => {
+    await DatabaseManager.destroyServerDatabase(serverUrl);
+});
+
+describe('scheduled_post', () => {
+    it('createScheduledPost - handle not found database', async () => {
+        const result = await createScheduledPost('foo', scheduledPost);
+        expect(result).toBeDefined();
+        expect(result.error).toBeDefined();
+    });
+
+    it('createScheduledPost - base case', async () => {
+        await operator.handleUsers({users: [user1], prepareRecordsOnly: false});
+        const result = await createScheduledPost(serverUrl, scheduledPost);
+        expect(result).toBeDefined();
+        expect(result.error).toBeUndefined();
+        expect(result.data).toBe(true);
+        expect(result.response).toBeDefined();
+        if (result.response) {
+            expect(result.response.id).toBe(scheduledPost.id);
+        }
+    });
+
+    it('createScheduledPost - request error', async () => {
+        mockClient.createScheduledPost.mockImplementationOnce(jest.fn(throwFunc));
+        const result = await createScheduledPost(serverUrl, scheduledPost);
+        expect(result).toBeDefined();
+        expect(result.error).toBeDefined();
+    });
+});

app/actions/remote/scheduled_post.ts

@@ -2,26 +2,28 @@
 // See LICENSE.txt for license information.
 
 import {forceLogoutIfNecessary} from '@actions/remote/session';
+import DatabaseManager from '@database/manager';
 import NetworkManager from '@managers/network_manager';
-import websocketManager from '@managers/websocket_manager';
 import {getFullErrorMessage} from '@utils/errors';
 import {logError} from '@utils/log';
 
-export async function createScheduledPost(serverUrl: string, schedulePost: ScheduledPost, connectionId?: string, fetchOnly = false) {
+import type {CreateResponse} from '@hooks/handle_send_message';
+
+export async function createScheduledPost(serverUrl: string, schedulePost: ScheduledPost, connectionId?: string): Promise<CreateResponse> {
+    const operator = DatabaseManager.serverDatabases[serverUrl]?.operator;
+    if (!operator) {
+        return {error: `${serverUrl} database not found`};
+    }
+
     try {
         const client = NetworkManager.getClient(serverUrl);
-        const ws = websocketManager.getClient(serverUrl);
-
-        const created = await client.createScheduledPost(schedulePost, ws?.getConnectionId());
+        const response = await client.createScheduledPost(schedulePost, connectionId);
 
-        if (!fetchOnly) {
-            // TODO - to be implemented later once DB tables are ready
-            // await operator.handleScheduledPost({scheduledPosts: [created], prepareRecordsOnly: false});
-        }
-        return {scheduledPost: created};
+        // TODO - record scheduled post in database here
+        return {data: true, response};
     } catch (error) {
         logError('error on createScheduledPost', getFullErrorMessage(error));
         forceLogoutIfNecessary(serverUrl, error);
-        return {error};
+        return {error: getFullErrorMessage(error)};
     }
 }

app/components/post_draft/draft_input/draft_input.test.tsx

@@ -0,0 +1,166 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+import {fireEvent} from '@testing-library/react-native';
+import React from 'react';
+
+import {Screens} from '@constants';
+import {PostPriorityType} from '@constants/post';
+import NetworkManager from '@managers/network_manager';
+import {openAsBottomSheet} from '@screens/navigation';
+import {renderWithEverything} from '@test/intl-test-helper';
+import TestHelper from '@test/test_helper';
+import {persistentNotificationsConfirmation} from '@utils/post';
+
+import DraftInput from './draft_input';
+
+import type ServerDataOperator from '@database/operator/server_data_operator';
+import type {Database} from '@nozbe/watermelondb';
+
+const SERVER_URL = 'https://appv1.mattermost.com';
+
+// this is needed to when using the useServerUrl hook
+jest.mock('@context/server', () => ({
+    useServerUrl: jest.fn(() => SERVER_URL),
+}));
+
+jest.mock('@screens/navigation', () => ({
+    openAsBottomSheet: jest.fn(),
+}));
+
+jest.mock('@utils/post', () => ({
+    persistentNotificationsConfirmation: jest.fn(),
+}));
+
+describe('DraftInput', () => {
+    const baseProps = {
+        testID: 'draft_input',
+        channelId: 'channelId',
+        channelType: 'O' as ChannelType,
+        currentUserId: 'currentUserId',
+        postPriority: {priority: ''} as PostPriority,
+        updatePostPriority: jest.fn(),
+        persistentNotificationInterval: 0,
+        persistentNotificationMaxRecipients: 0,
+        updateCursorPosition: jest.fn(),
+        cursorPosition: 0,
+        sendMessage: jest.fn(),
+        canSend: true,
+        maxMessageLength: 4000,
+        files: [],
+        value: '',
+        uploadFileError: null,
+        updateValue: jest.fn(),
+        addFiles: jest.fn(),
+        updatePostInputTop: jest.fn(),
+        setIsFocused: jest.fn(),
+        scheduledPostsEnabled: true,
+    };
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    let database: Database;
+    let operator: ServerDataOperator;
+
+    beforeEach(async () => {
+        const server = await TestHelper.setupServerDatabase(SERVER_URL);
+        database = server.database;
+        operator = server.operator;
+    });
+
+    afterEach(async () => {
+        await TestHelper.tearDown();
+        NetworkManager.invalidateClient(SERVER_URL);
+    });
+
+    describe('Rendering', () => {
+        it('renders base components', async () => {
+            const {getByTestId} = renderWithEverything(<DraftInput {...baseProps}/>, {database});
+            expect(getByTestId('draft_input')).toBeTruthy();
+            expect(getByTestId('draft_input.post.input')).toBeTruthy();
+            expect(getByTestId('draft_input.quick_actions')).toBeTruthy();
+            expect(getByTestId('draft_input.send_action.send.button')).toBeTruthy();
+        });
+
+        it('shows upload error when present', () => {
+            const props = {...baseProps, uploadFileError: 'Error message'};
+            const {getByText} = renderWithEverything(<DraftInput {...props}/>, {database});
+            expect(getByText('Error message')).toBeTruthy();
+        });
+    });
+
+    describe('Message Actions', () => {
+        it('sends message on press', () => {
+            const {getByTestId} = renderWithEverything(<DraftInput {...baseProps}/>, {database});
+            fireEvent.press(getByTestId('draft_input.send_action.send.button'));
+            expect(baseProps.sendMessage).toHaveBeenCalled();
+        });
+
+        it('opens scheduled post options on long press', async () => {
+            // make this a re-usable function
+            await operator.handleConfigs({
+                configs: [
+                    {id: 'ScheduledPosts', value: 'true'},
+                ],
+                configsToDelete: [],
+                prepareRecordsOnly: false,
+            });
+
+            const {getByTestId} = renderWithEverything(<DraftInput {...baseProps}/>, {database});
+            fireEvent(getByTestId('draft_input.send_action.send.button'), 'longPress');
+            expect(openAsBottomSheet).toHaveBeenCalledWith(expect.objectContaining({
+                screen: Screens.SCHEDULED_POST_OPTIONS,
+            }));
+        });
+
+        it('handles persistent notifications', async () => {
+            jest.mocked(persistentNotificationsConfirmation).mockResolvedValueOnce();
+            const props = {
+                ...baseProps,
+                postPriority: {
+                    persistent_notifications: true,
+                    priority: PostPriorityType.URGENT,
+                } as PostPriority,
+                value: '@user1 @user2 message',
+            };
+
+            const {getByTestId} = renderWithEverything(<DraftInput {...props}/>, {database});
+            fireEvent.press(getByTestId('draft_input.send_action.send.button'));
+            expect(persistentNotificationsConfirmation).toHaveBeenCalled();
+        });
+    });
+
+    describe('Input Handling', () => {
+        it('updates text value', () => {
+            const {getByTestId} = renderWithEverything(<DraftInput {...baseProps}/>, {database});
+            fireEvent.changeText(getByTestId('draft_input.post.input'), 'new message');
+            expect(baseProps.updateValue).toHaveBeenCalledWith('new message');
+        });
+
+        it('handles cursor position', () => {
+            const {getByTestId} = renderWithEverything(<DraftInput {...baseProps}/>, {database});
+            fireEvent(getByTestId('draft_input.post.input'), 'selectionChange', {
+                nativeEvent: {selection: {start: 5, end: 5}},
+            });
+            expect(baseProps.updateCursorPosition).toHaveBeenCalledWith(5);
+        });
+
+        it('updates focus state', () => {
+            const {getByTestId} = renderWithEverything(<DraftInput {...baseProps}/>, {database});
+            fireEvent(getByTestId('draft_input.post.input'), 'focus');
+            expect(baseProps.setIsFocused).toHaveBeenCalledWith(true);
+        });
+    });
+
+    describe('Validation', () => {
+        it('disables send when canSend is false', () => {
+            const props = {...baseProps, canSend: false};
+            const {getByTestId} = renderWithEverything(<DraftInput {...props}/>, {database});
+            const sendButton = getByTestId('draft_input.send_action.send.button.disabled');
+            expect(sendButton).toBeTruthy();
+            expect(sendButton).toBeDisabled();
+        });
+    });
+});

app/components/post_draft/draft_input/draft_input.tsx

@@ -28,7 +28,7 @@ import Header from './header';
 import type {PasteInputRef} from '@mattermost/react-native-paste-input';
 import type {WithDatabaseArgs} from '@typings/database/database';
 
-type Props = {
+export type Props = {
     testID?: string;
     channelId: string;
     channelType?: ChannelType;
@@ -48,7 +48,7 @@ type Props = {
     cursorPosition: number;
 
     // Send Handler
-    sendMessage: () => void;
+    sendMessage: (schedulingInfo?: SchedulingInfo) => Promise<void | {data?: boolean; error?: unknown}>;
     canSend: boolean;
     maxMessageLength: number;
 
@@ -164,13 +164,16 @@ function DraftInput({
         postPriority,
     });
 
-    const handleSendMessage = useCallback(async () => {
+    const handleSendMessage = useCallback(async (schedulingInfoParam?: SchedulingInfo) => {
+        const schedulingInfo = (schedulingInfoParam && 'scheduled_at' in schedulingInfoParam) ? schedulingInfoParam : undefined;
+
         if (persistentNotificationsEnabled) {
-            persistentNotificationsConfirmation(serverUrl, value, mentionsList, intl, sendMessage, persistentNotificationMaxRecipients, persistentNotificationInterval, currentUserId, channelName, channelType);
-        } else {
-            sendMessage();
+            const sendMessageWithScheduledPost = () => sendMessage(schedulingInfo);
+            await persistentNotificationsConfirmation(serverUrl, value, mentionsList, intl, sendMessageWithScheduledPost, persistentNotificationMaxRecipients, persistentNotificationInterval, currentUserId, channelName, channelType);
+            return Promise.resolve();
         }
-    }, [serverUrl, mentionsList, persistentNotificationsEnabled, persistentNotificationMaxRecipients, sendMessage, value, channelType]);
+        return sendMessage(schedulingInfo);
+    }, [persistentNotificationsEnabled, serverUrl, value, mentionsList, intl, sendMessage, persistentNotificationMaxRecipients, persistentNotificationInterval, currentUserId, channelName, channelType]);
 
     const handleShowScheduledPostOptions = useCallback(() => {
         if (!scheduledPostsEnabled) {
@@ -187,9 +190,10 @@ function DraftInput({
             title,
             props: {
                 closeButtonId: SCHEDULED_POST_PICKER_BUTTON,
+                onSchedule: handleSendMessage,
             },
         });
-    }, [intl, isTablet, scheduledPostsEnabled, theme]);
+    }, [handleSendMessage, intl, isTablet, scheduledPostsEnabled, theme]);
 
     const sendActionDisabled = !canSend || noMentionsError;
 

app/components/post_draft/send_action/__snapshots__/send_action.test.tsx.snap

@@ -0,0 +1,60 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`components/post_draft/send_action should match snapshot 1`] = `
+<View
+  accessibilityState={
+    {
+      "busy": undefined,
+      "checked": undefined,
+      "disabled": false,
+      "expanded": undefined,
+      "selected": undefined,
+    }
+  }
+  accessibilityValue={
+    {
+      "max": undefined,
+      "min": undefined,
+      "now": undefined,
+      "text": undefined,
+    }
+  }
+  accessible={true}
+  collapsable={false}
+  focusable={true}
+  onClick={[Function]}
+  onResponderGrant={[Function]}
+  onResponderMove={[Function]}
+  onResponderRelease={[Function]}
+  onResponderTerminate={[Function]}
+  onResponderTerminationRequest={[Function]}
+  onStartShouldSetResponder={[Function]}
+  style={
+    {
+      "justifyContent": "flex-end",
+      "opacity": 1,
+      "paddingRight": 8,
+    }
+  }
+  testID="test_id.send.button"
+>
+  <View
+    style={
+      {
+        "alignItems": "center",
+        "backgroundColor": "#1c58d9",
+        "borderRadius": 4,
+        "height": 32,
+        "justifyContent": "center",
+        "width": 80,
+      }
+    }
+  >
+    <Icon
+      color="#ffffff"
+      name="send"
+      size={24}
+    />
+  </View>
+</View>
+`;