Disable premium content

creator-node/compose/env/base.env

@@ -77,3 +77,6 @@ reconfigSPIdBlacklistString=
 
 entityManagerAddress=0x5b9b42d6e4B2e4Bf8d42Eba32D46918e10899B66
 entityManagerReplicaSetEnabled=true
+
+# Premium content
+premiumContentEnabled=true

creator-node/scripts/run-tests.sh

@@ -29,7 +29,7 @@ if [ "${debug}" ]; then
   UNIT_TIMEOUT=0
   INTEGRATION_TIMEOUT=0
 else
-  UNIT_TIMEOUT=2000
+  UNIT_TIMEOUT=5000
   INTEGRATION_TIMEOUT=30000
 fi
 

creator-node/src/config.js

@@ -482,6 +482,12 @@ const config = convict({
     env: 'entityManagerReplicaSetEnabled',
     default: false
   },
+  premiumContentEnabled: {
+    doc: 'whether or not to enable premium content',
+    format: Boolean,
+    env: 'premiumContentEnabled',
+    default: false
+  },
 
   /** sync / snapback configs */
 

creator-node/src/middlewares/premiumContent/premiumContentMiddleware.test.ts

@@ -1,13 +1,15 @@
-import { premiumContentMiddleware } from './premiumContentMiddleware'
 import assert from 'assert'
 import { resFactory, loggerFactory } from '../../../test/lib/reqMock'
 import { Request, Response } from 'express'
 import Logger from 'bunyan'
 import { Redis } from 'ioredis'
 import { PremiumContentAccessError } from '../../premiumContent/types'
 import { StubPremiumContentAccessChecker } from '../../premiumContent/stubPremiumContentAccessChecker'
+import config from '../../config'
+import proxyquire from 'proxyquire' // eslint-disable-line node/no-unpublished-import
 
-describe('Test premium content middleware', function () {
+describe('Test premium content middleware', () => {
+  let premiumContentMiddlewareProxy: any
   let app: any
   let serviceRegistry: any
   let libs: any
@@ -18,7 +20,7 @@ describe('Test premium content middleware', function () {
   let mockRes: any
   let premiumContentAccessChecker: StubPremiumContentAccessChecker
 
-  beforeEach(function () {
+  beforeEach(() => {
     libs = {
       ethContracts: {
         ServiceProviderFactoryClient: {
@@ -46,109 +48,136 @@ describe('Test premium content middleware', function () {
     mockRes = resFactory()
   })
 
-  it('returns bad request when missing the CID param', async () => {
-    let nextCalled = false
-    await premiumContentMiddleware(
-      { ...mockReq, params: { CID: null } } as unknown as Request,
-      mockRes as unknown as Response,
-      () => {
-        nextCalled = true
+  describe('when premium content is enabled', () => {
+    beforeEach(() => {
+      config.set('premiumContentEnabled', true)
+      premiumContentMiddlewareProxy = proxyquire('./premiumContentMiddleware', {
+        './../../config': config
+      })
+    })
+
+    it('returns bad request when missing the CID param', async () => {
+      let nextCalled = false
+      await premiumContentMiddlewareProxy.premiumContentMiddleware(
+        { ...mockReq, params: { CID: null } } as unknown as Request,
+        mockRes as unknown as Response,
+        () => {
+          nextCalled = true
+        }
+      )
+      assert.deepStrictEqual(mockRes.statusCode, 400)
+      assert.deepStrictEqual(nextCalled, false)
+    })
+
+    it('returns unauthorized when it fails because of missing headers', async () => {
+      premiumContentAccessChecker.accessCheckReturnsWith = {
+        doesUserHaveAccess: false,
+        trackId: 1,
+        isPremium: true,
+        error: PremiumContentAccessError.MISSING_HEADERS
       }
-    )
-    assert.deepStrictEqual(mockRes.statusCode, 400)
-    assert.deepStrictEqual(nextCalled, false)
-  })
+      let nextCalled = false
+      await premiumContentMiddlewareProxy.premiumContentMiddleware(
+        mockReq as unknown as Request,
+        mockRes as unknown as Response,
+        () => {
+          nextCalled = true
+        }
+      )
+      assert.deepStrictEqual(mockRes.statusCode, 401)
+      assert.deepStrictEqual(nextCalled, false)
+    })
 
-  it('returns unauthorized when it fails because of missing headers', async () => {
-    premiumContentAccessChecker.accessCheckReturnsWith = {
-      doesUserHaveAccess: false,
-      trackId: 1,
-      isPremium: true,
-      error: PremiumContentAccessError.MISSING_HEADERS
-    }
-    let nextCalled = false
-    await premiumContentMiddleware(
-      mockReq as unknown as Request,
-      mockRes as unknown as Response,
-      () => {
-        nextCalled = true
+    it('returns forbidden when it fails because of invalid discovery node', async () => {
+      premiumContentAccessChecker.accessCheckReturnsWith = {
+        doesUserHaveAccess: false,
+        trackId: 1,
+        isPremium: true,
+        error: PremiumContentAccessError.INVALID_DISCOVERY_NODE
       }
-    )
-    assert.deepStrictEqual(mockRes.statusCode, 401)
-    assert.deepStrictEqual(nextCalled, false)
-  })
+      let nextCalled = false
+      await premiumContentMiddlewareProxy.premiumContentMiddleware(
+        mockReq as unknown as Request,
+        mockRes as unknown as Response,
+        () => {
+          nextCalled = true
+        }
+      )
+      assert.deepStrictEqual(mockRes.statusCode, 403)
+      assert.deepStrictEqual(nextCalled, false)
+    })
 
-  it('returns forbidden when it fails because of invalid discovery node', async () => {
-    premiumContentAccessChecker.accessCheckReturnsWith = {
-      doesUserHaveAccess: false,
-      trackId: 1,
-      isPremium: true,
-      error: PremiumContentAccessError.INVALID_DISCOVERY_NODE
-    }
-    let nextCalled = false
-    await premiumContentMiddleware(
-      mockReq as unknown as Request,
-      mockRes as unknown as Response,
-      () => {
-        nextCalled = true
+    it('returns forbidden when it fails because of failed verification match', async () => {
+      premiumContentAccessChecker.accessCheckReturnsWith = {
+        doesUserHaveAccess: false,
+        trackId: 1,
+        isPremium: true,
+        error: PremiumContentAccessError.FAILED_MATCH
       }
-    )
-    assert.deepStrictEqual(mockRes.statusCode, 403)
-    assert.deepStrictEqual(nextCalled, false)
-  })
+      let nextCalled = false
+      await premiumContentMiddlewareProxy.premiumContentMiddleware(
+        mockReq as unknown as Request,
+        mockRes as unknown as Response,
+        () => {
+          nextCalled = true
+        }
+      )
+      assert.deepStrictEqual(mockRes.statusCode, 403)
+      assert.deepStrictEqual(nextCalled, false)
+    })
 
-  it('returns forbidden when it fails because of failed verification match', async () => {
-    premiumContentAccessChecker.accessCheckReturnsWith = {
-      doesUserHaveAccess: false,
-      trackId: 1,
-      isPremium: true,
-      error: PremiumContentAccessError.FAILED_MATCH
-    }
-    let nextCalled = false
-    await premiumContentMiddleware(
-      mockReq as unknown as Request,
-      mockRes as unknown as Response,
-      () => {
-        nextCalled = true
+    it('passes and moves to the next middleware when all checks are fine and content is NOT premium', async () => {
+      premiumContentAccessChecker.accessCheckReturnsWith = {
+        doesUserHaveAccess: true,
+        trackId: null,
+        isPremium: false,
+        error: null
       }
-    )
-    assert.deepStrictEqual(mockRes.statusCode, 403)
-    assert.deepStrictEqual(nextCalled, false)
-  })
+      let nextCalled = false
+      await premiumContentMiddlewareProxy.premiumContentMiddleware(
+        mockReq as unknown as Request,
+        mockRes as unknown as Response,
+        () => {
+          nextCalled = true
+        }
+      )
+      assert.deepStrictEqual(nextCalled, true)
+    })
 
-  it('passes and moves to the next middleware when all checks are fine and content is NOT premium', async () => {
-    premiumContentAccessChecker.accessCheckReturnsWith = {
-      doesUserHaveAccess: true,
-      trackId: null,
-      isPremium: false,
-      error: null
-    }
-    let nextCalled = false
-    await premiumContentMiddleware(
-      mockReq as unknown as Request,
-      mockRes as unknown as Response,
-      () => {
-        nextCalled = true
+    it('passes and moves to the next middleware when all checks are fine and content IS premium', async () => {
+      premiumContentAccessChecker.accessCheckReturnsWith = {
+        doesUserHaveAccess: true,
+        trackId: 1,
+        isPremium: true,
+        error: null
       }
-    )
-    assert.deepStrictEqual(nextCalled, true)
+      let nextCalled = false
+      await premiumContentMiddlewareProxy.premiumContentMiddleware(
+        mockReq as unknown as Request,
+        mockRes as unknown as Response,
+        () => {
+          nextCalled = true
+        }
+      )
+      assert.deepStrictEqual(nextCalled, true)
+    })
   })
 
-  it('passes and moves to the next middleware when all checks are fine and content IS premium', async () => {
-    premiumContentAccessChecker.accessCheckReturnsWith = {
-      doesUserHaveAccess: true,
-      trackId: 1,
-      isPremium: true,
-      error: null
-    }
-    let nextCalled = false
-    await premiumContentMiddleware(
-      mockReq as unknown as Request,
-      mockRes as unknown as Response,
-      () => {
-        nextCalled = true
-      }
-    )
-    assert.deepStrictEqual(nextCalled, true)
+  describe('when premium content is disabled', () => {
+    it('moves on to the next middleware', async () => {
+      config.set('premiumContentEnabled', false)
+      premiumContentMiddlewareProxy = proxyquire('./premiumContentMiddleware', {
+        './../../config': config
+      })
+      let nextCalled = false
+      await premiumContentMiddlewareProxy.premiumContentMiddleware(
+        mockReq as unknown as Request,
+        mockRes as unknown as Response,
+        () => {
+          nextCalled = true
+        }
+      )
+      assert.deepStrictEqual(nextCalled, true)
+    })
   })
 })

creator-node/src/middlewares/premiumContent/premiumContentMiddleware.ts

@@ -9,6 +9,7 @@ import { NextFunction, Request, Response } from 'express'
 import { PremiumContentAccessError } from '../../premiumContent/types'
 import type Logger from 'bunyan'
 import { PremiumContentAccessChecker } from '../../premiumContent/premiumContentAccessChecker'
+import config from '../../config'
 
 /**
  * Middleware to validate requests to get premium content.
@@ -28,16 +29,20 @@ export const premiumContentMiddleware = async (
   res: Response,
   next: NextFunction
 ) => {
-  try {
-    const cid = req.params?.CID
-    if (!cid) {
-      return sendResponse(
-        req,
-        res,
-        errorResponseBadRequest(`Invalid request, no CID provided.`)
-      )
-    }
+  const cid = req.params?.CID
+  if (!cid) {
+    return sendResponse(
+      req,
+      res,
+      errorResponseBadRequest(`Invalid request, no CID provided.`)
+    )
+  }
 
+  if (!config.get('premiumContentEnabled')) {
+    return next()
+  }
+
+  try {
     const premiumContentHeaders = req.headers['x-premium-content'] as string
     const serviceRegistry = req.app.get('serviceRegistry')
     const { premiumContentAccessChecker, libs, redis } = serviceRegistry
@@ -63,8 +68,7 @@ export const premiumContentMiddleware = async (
         trackId,
         isPremium
       }
-      next()
-      return
+      return next()
     }
 
     switch (error) {