Merge pull request #39 from SAP/feature/consentAsArgument

Add new methods to consent class

Author: bmmsantos

.gitignore

@@ -112,4 +112,5 @@ typings/
 *.iml
 
 # development time ignore rules
-usageTracking
+usageTracking
+dist/

src/common/consent.test.ts

@@ -0,0 +1,23 @@
+import { describe, test, expect } from 'vitest'
+import WebConsent from '../web/webConsent'
+
+describe('Consent', () => {
+  test('should return the provided question answer false', async () => {
+    let webConsent: WebConsent = new WebConsent()
+    expect(await webConsent.provideConsentQuestionAnswer('no')).toBeFalsy()
+    expect(await webConsent.provideConsentQuestionAnswer('No')).toBeFalsy()
+    expect(await webConsent.provideConsentQuestionAnswer('fAlSe')).toBeFalsy()
+    expect(await webConsent.provideConsentQuestionAnswer('1')).toBeFalsy()
+    expect(await webConsent.provideConsentQuestionAnswer('0')).toBeFalsy()
+    expect(await webConsent.provideConsentQuestionAnswer('')).toBeFalsy()
+    expect(await webConsent.provideConsentQuestionAnswer(undefined)).toBeFalsy()
+  })
+
+  test('should return the provided question answer yes', async () => {
+    let webConsent: WebConsent = new WebConsent()
+    expect(await webConsent.provideConsentQuestionAnswer('yes')).toBeTruthy()
+    expect(await webConsent.provideConsentQuestionAnswer('YeS')).toBeTruthy()
+    expect(await webConsent.provideConsentQuestionAnswer('y')).toBeTruthy()
+    expect(await webConsent.provideConsentQuestionAnswer('Y')).toBeTruthy()
+  })
+})

src/common/consent.ts

@@ -6,4 +6,16 @@ export default abstract class Consent {
 
   abstract askConsentConfirm(): Promise<boolean>
   abstract askConsentQuestion(): Promise<boolean>
+
+  provideConsentConfirmAnswer(consent: string = Consent.message): Promise<boolean> {
+    return new Promise<boolean>((resolve, reject) => {
+      consent?.toUpperCase() === 'Y' || consent?.toUpperCase() === 'YES' ? resolve(true) : reject(false)
+    })
+  }
+
+  provideConsentQuestionAnswer(consent: string = Consent.message): Promise<boolean> {
+    return new Promise<boolean>((resolve, reject) => {
+      resolve(consent?.toUpperCase() === 'Y' || consent?.toUpperCase() === 'YES' ? true : false)
+    })
+  }
 }

src/common/tracker.test.ts

@@ -1,9 +1,11 @@
 import { describe, test, expect, vi, beforeEach } from 'vitest'
 import CliTracker from '../cli/cliTracker'
+import WebTracker from '../web/webTracker'
 import Tracker from '../common/tracker'
 
 vi.mock('./storage')
 vi.mock('../cli/fileStorage')
+vi.mock('../web/webStorage')
 vi.mock('../gigya/account')
 
 beforeEach(() => {
@@ -13,26 +15,27 @@ beforeEach(() => {
 describe('Tracker', () => {
   const apiKey: string = 'apiKey'
   const dataCenter: string = 'eu1'
-  const tracker: Tracker = new CliTracker({ apiKey, dataCenter })
+  const cliTracker: Tracker = new CliTracker({ apiKey, dataCenter })
+  const webTracker: Tracker = new WebTracker({ apiKey, dataCenter })
   const email: string = '[email protected]'
   const toolName: string = 'tool name'
 
-  test('consent is already granted', () => {
+  test.each([cliTracker, webTracker])('consent is already granted', (tracker) => {
     vi.spyOn(tracker.storage, 'isConsentGranted').mockReturnValue(true)
     const spySetConsentGranted = vi.spyOn(tracker.storage, 'setConsentGranted')
     tracker.requestConsentConfirmation({})
     expect(spySetConsentGranted).not.toHaveBeenCalled()
   })
 
-  test('consent confirm is not granted', () => {
+  test.each([cliTracker, webTracker])('consent confirm is not granted', (tracker) => {
     vi.spyOn(tracker.storage, 'isConsentGranted').mockReturnValue(false)
     const spySetConsentGranted = vi.spyOn(tracker.storage, 'setConsentGranted')
     vi.spyOn(tracker.consent, 'askConsentConfirm').mockReturnValue(Promise.reject(false))
     expect(tracker.requestConsentConfirmation({})).rejects.toBeFalsy()
     expect(spySetConsentGranted).not.toHaveBeenCalled()
   })
 
-  test('consent confirm is granted', async () => {
+  test.each([cliTracker, webTracker])('consent confirm is granted', async (tracker) => {
     const consentResponse: boolean = true
     vi.spyOn(tracker.storage, 'isConsentGranted').mockReturnValue(false)
     const spySetConsentGranted = vi.spyOn(tracker.storage, 'setConsentGranted')
@@ -43,15 +46,15 @@ describe('Tracker', () => {
     expect(spyAccount).toHaveBeenCalledWith(consentResponse, email)
   })
 
-  test('consent question is not granted', () => {
+  test.each([cliTracker, webTracker])('consent question is not granted', (tracker) => {
     vi.spyOn(tracker.storage, 'isConsentGranted').mockReturnValue(false)
     const spySetConsentGranted = vi.spyOn(tracker.storage, 'setConsentGranted')
     vi.spyOn(tracker.consent, 'askConsentQuestion').mockReturnValue(Promise.resolve(false))
     expect(tracker.requestConsentQuestion({})).resolves.toBeFalsy()
     expect(spySetConsentGranted).not.toHaveBeenCalled()
   })
 
-  test('consent question is granted', async () => {
+  test.each([cliTracker, webTracker])('consent question is granted', async (tracker) => {
     const consentResponse: boolean = true
     vi.spyOn(tracker.storage, 'isConsentGranted').mockReturnValue(false)
     const spySetConsentGranted = vi.spyOn(tracker.storage, 'setConsentGranted')
@@ -62,14 +65,14 @@ describe('Tracker', () => {
     expect(spyAccount).toHaveBeenCalledWith(consentResponse, expect.stringContaining('@automated-usage-tracking-tool.sap'))
   })
 
-  test('track usage without consent', () => {
+  test.each([cliTracker, webTracker])('track usage without consent', (tracker) => {
     vi.spyOn(tracker.storage, 'isConsentGranted').mockReturnValue(false)
     const spySetLatestUsage = vi.spyOn(tracker.storage, 'setLatestUsage')
     tracker.trackUsage({ toolName })
     expect(spySetLatestUsage).not.toHaveBeenCalled()
   })
 
-  test('track usage with consent', async () => {
+  test.each([cliTracker, webTracker])('track usage with consent', async (tracker) => {
     const featureName: string = 'feature name'
     vi.spyOn(tracker.storage, 'isConsentGranted').mockReturnValue(true)
     const spySetLatestUsage = vi.spyOn(tracker.storage, 'setLatestUsage')
@@ -78,4 +81,44 @@ describe('Tracker', () => {
     expect(spySetLatestUsage).toHaveBeenCalledWith(toolName, featureName)
     expect(spyAccount).toHaveBeenCalled()
   })
+
+  test.each([cliTracker, webTracker])('track usage with provided consent question answer true', async (tracker) => {
+    const featureName: string = 'feature name'
+    vi.spyOn(tracker.storage, 'isConsentGranted').mockReturnValue(false)
+    const spySetConsentGranted = vi.spyOn(tracker.storage, 'setConsentGranted')
+    const spyAccount = vi.spyOn(tracker.account, 'setConsent')
+    await expect(tracker.provideConsentQuestionAnswer({ email, message: 'yes' })).resolves.toBeTruthy()
+    expect(spySetConsentGranted).toHaveBeenCalledWith(true, email)
+    expect(spyAccount).toHaveBeenCalled()
+  })
+
+  test.each([cliTracker, webTracker])('track usage with provided consent question answer false', async (tracker) => {
+    const featureName: string = 'feature name'
+    vi.spyOn(tracker.storage, 'isConsentGranted').mockReturnValue(false)
+    const spySetConsentGranted = vi.spyOn(tracker.storage, 'setConsentGranted')
+    const spyAccount = vi.spyOn(tracker.account, 'setConsent')
+    await expect(tracker.provideConsentQuestionAnswer({ email, message: 'no' })).resolves.toBeFalsy()
+    expect(spySetConsentGranted).not.toHaveBeenCalled()
+    expect(spyAccount).not.toHaveBeenCalled()
+  })
+
+  test.each([cliTracker, webTracker])('track usage with provided consent confirm answer true', async (tracker) => {
+    const featureName: string = 'feature name'
+    vi.spyOn(tracker.storage, 'isConsentGranted').mockReturnValue(false)
+    const spySetConsentGranted = vi.spyOn(tracker.storage, 'setConsentGranted')
+    const spyAccount = vi.spyOn(tracker.account, 'setConsent')
+    await expect(tracker.provideConsentConfirmAnswer({ email, message: 'yes' })).resolves.toBeTruthy()
+    expect(spySetConsentGranted).toHaveBeenCalledWith(true, email)
+    expect(spyAccount).toHaveBeenCalled()
+  })
+
+  test.each([cliTracker, webTracker])('track usage with provided consent confirm answer false', async (tracker) => {
+    const featureName: string = 'feature name'
+    vi.spyOn(tracker.storage, 'isConsentGranted').mockReturnValue(false)
+    const spySetConsentGranted = vi.spyOn(tracker.storage, 'setConsentGranted')
+    const spyAccount = vi.spyOn(tracker.account, 'setConsent')
+    await expect(tracker.provideConsentConfirmAnswer({ email, message: 'no' })).rejects.toBeFalsy()
+    expect(spySetConsentGranted).not.toHaveBeenCalled()
+    expect(spyAccount).not.toHaveBeenCalled()
+  })
 })

src/common/tracker.ts

@@ -25,6 +25,14 @@ export default abstract class Tracker {
     return await this.requestConsent(this.consent.askConsentConfirm.bind(this.consent), consentArguments)
   }
 
+  public async provideConsentQuestionAnswer(consentArguments: ConsentArguments): Promise<boolean> {
+    return await this.requestConsent(this.consent.provideConsentQuestionAnswer.bind(this.consent), consentArguments)
+  }
+
+  public async provideConsentConfirmAnswer(consentArguments: ConsentArguments): Promise<boolean> {
+    return await this.requestConsent(this.consent.provideConsentConfirmAnswer.bind(this.consent), consentArguments)
+  }
+
   async trackUsage(trackUsageArguments: TrackUsageArguments): Promise<void> {
     if (this.storage.isConsentGranted()) {
       this.storage.setLatestUsage(trackUsageArguments.toolName, trackUsageArguments.featureName)

src/web/webConsent.ts

@@ -1,6 +1,6 @@
 import Consent from '../common/consent'
 
-export default class WebConsent implements Consent {
+export default class WebConsent extends Consent {
   #dialogId = 'automated-usage-tracking-tool-dialog'
   #dialogContentId = `${this.#dialogId}-content`
   #dialogFooterId = `${this.#dialogId}-footer`