[ENG-5949] Preprint assertion validation (#2271)

-   Ticket: [ENG-5949]
-   Feature flag: n/a

## Purpose
- Update URL validators used for author assertions to prevent preprint saves from failing

## Summary of Changes
- Add new URL validator that checks for the presence of a protocol
  - Use ember-changeset-validations existing url validations for some false positives
- Remove old validator that is no longer used

Author: futa-ikeda

app/preprints/-components/submit/author-assertions/link-widget/link/component.ts

@@ -3,8 +3,9 @@ import { action } from '@ember/object';
 import { inject as service } from '@ember/service';
 import Intl from 'ember-intl/services/intl';
 import { ValidationObject } from 'ember-changeset-validations';
-import { validateFormat} from 'ember-changeset-validations/validators';
+
 import buildChangeset from 'ember-osf-web/utils/build-changeset';
+import { validateUrlWithProtocols } from 'ember-osf-web/validators/url-with-protocol';
 import { tracked } from '@glimmer/tracking';
 
 
@@ -31,9 +32,7 @@ export default class Link extends Component<LinkArgs>{
     @tracked linkFormChangeset: any = null;
 
     linkFormValidation: ValidationObject<LinkForm> = {
-        value: validateFormat({
-            allowBlank: false,
-            type: 'url',
+        value: validateUrlWithProtocols({
             translationArgs: { description: this.intl.t('validationErrors.description') },
         }),
     };

app/validators/http-url.ts

@@ -0,0 +1,49 @@
+import buildMessage from 'ember-changeset-validations/utils/validation-errors';
+import { validateFormat } from 'ember-changeset-validations/validators';
+
+const Protocols = {
+    http: 'http:',
+    https: 'https:',
+};
+
+interface Options {
+    acceptedProtocols?: string[];
+    translationArgs?: {
+        description: string,
+    };
+}
+
+export function validateUrlWithProtocols(options?: Options) {
+    return (key: string, newValue: string, _: any, __: any, ___: any) => {
+        const acceptedProtocols = options?.acceptedProtocols || [Protocols.http, Protocols.https];
+        const translationArgs = options?.translationArgs || { description: '' };
+
+        let url;
+        try {
+            url = new URL(newValue);
+        } catch (e) {
+            return buildMessage(key, {
+                type: 'url',
+                context: {
+                    type: 'url',
+                    translationArgs,
+                },
+            });
+        }
+
+        if (acceptedProtocols.indexOf(url.protocol) === -1) {
+            return buildMessage(key, {
+                type: 'url',
+                context: {
+                    type: 'url',
+                    translationArgs,
+                },
+            });
+        }
+        return validateFormat({
+            allowBlank: false,
+            type: 'url',
+            translationArgs,
+        })(key, newValue, _, __, ___);
+    };
+}

app/validators/url-with-protocol.ts

@@ -21,6 +21,7 @@ const preprintProviders: Array<Partial<PreprintProvider>> = [
         assets: randomAssets(1),
         footerLinks: 'fake footer links',
         reviewsWorkflow: PreprintProviderReviewsWorkFlow.PRE_MODERATION,
+        assertionsEnabled: true,
         allowCommenting: true,
         allowSubmissions: true,
     },

mirage/fixtures/preprint-providers.ts

@@ -0,0 +1,23 @@
+import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+import { validateUrlWithProtocols } from 'ember-osf-web/validators/url-with-protocol';
+
+module('Unit | Validator | url-with-protocol', function(hooks) {
+    setupTest(hooks);
+
+    test('it works', function(assert) {
+        const baseValidator = validateUrlWithProtocols();
+        assert.ok(baseValidator('http://a.com'), 'http is valid');
+        assert.ok(baseValidator('https://b.com'), 'https is valid');
+        assert.strictEqual(baseValidator('c.com').type, 'url', 'no protocol is invalid');
+        assert.strictEqual(baseValidator('http://d').type, 'url', 'no domain is invalid');
+        assert.strictEqual(baseValidator('ftp://e.com').type, 'url', 'ftp is invalid');
+
+        const customValidator = validateUrlWithProtocols({ acceptedProtocols: ['http'] });
+        assert.ok(customValidator('http://a.com'), 'http is valid');
+        assert.strictEqual(customValidator('https://b.com').type, 'url', 'https is invalid');
+        assert.strictEqual(customValidator('c.com').type, 'url', 'no protocol is invalid');
+        assert.strictEqual(customValidator('http://d').type, 'url', 'no domain is invalid');
+        assert.strictEqual(customValidator('ftp://e.com').type, 'url', 'ftp is invalid');
+    });
+});

tests/unit/validators/url-with-protocol-test.js

@@ -11,4 +11,4 @@ export interface RawValidationResult extends ValidationResult {
     message: string;
 }
 
-export default function buildMessage(key: tring, result: ValidationResult): string | RawValidationResult;
+export default function buildMessage(key: string, result: ValidationResult): string | RawValidationResult;