OXUI-1345: Reset version info on cache warmup failure

spec/version_mismatches_test.js

@@ -44,8 +44,12 @@ describe('version mismatches', function () {
           new Response('foo1', { headers: { version: '1' } }),
           new Response('foo2', { headers: { version: '2' } })
         ),
-        '/bar.js': () => new Response('bar', { headers: { version: '2' } }),
-        '/whatever.js': () => new Response('whatever', { headers: { version: '2' } }),
+        '/bar.js': td.when(td.func()(td.matchers.anything(), td.matchers.anything())).thenReturn(
+          new Response('bar', { headers: { version: '2' } }),
+          new Response('bar', { headers: { version: '2' } }),
+          new Response('bar', { headers: { version: '3' } })
+        ),
+        '/whatever.js': () => new Response('whatever', { headers: { version: '3' } }),
         '/meta.json': td.when(td.func()(td.matchers.anything(), td.matchers.anything())).thenReturn(
           new Response(JSON.stringify({ }), { headers: { 'Content-Type': 'application/json', version: '1' } }),
           new Response(JSON.stringify({ }), { headers: { 'Content-Type': 'application/json', version: '2' } })
@@ -68,17 +72,24 @@ describe('version mismatches', function () {
   })
 
   it('detects version mismatches when files are fetched', async function () {
-    // get foo.js with initial version
+    // get foo.js with initial version errors, due to the version mismatch
+    // no partially complete state should be active (version 1)
     let response = await app.inject({ url: '/foo.js' })
+    expect(response.statusCode).to.equal(404)
+    await runUpdate(pubClient)
+
+    // update the version (version 2)
+    response = await app.inject({ url: '/foo.js' })
     expect(response.statusCode).to.equal(200)
-    expect(response.body).to.equal('foo1')
-    expect(response.headers.version).to.equal('85101541')
+    expect(response.body).to.equal('foo2')
+    expect(response.headers.version).to.equal('85102502')
 
     // get bar.js. This will cause the server to detect the version mismatch
     response = await app.inject({ url: '/bar.js' })
-    expect(response.statusCode).to.equal(404)
+    expect(response.statusCode).to.equal(200)
+    expect(response.body).to.equal('bar')
 
-    await runUpdate(pubClient)
+    await runUpdate(pubClient) // version 3 not successful but still version 2 in cache
     await runUpdate(pubClient)
 
     // get foo.js again. Since the versions should coincide now, the client should receive the new file
@@ -89,23 +100,23 @@ describe('version mismatches', function () {
   })
 
   it('detects version mismatches in files not referenced in manifest.json when files are fetched', async function () {
-    // get foo.js with initial version
+    // get foo.js with initial version 1
     let response = await app.inject({ url: '/foo.js' })
-    expect(response.statusCode).to.equal(200)
-    expect(response.body).to.equal('foo1')
-    expect(response.headers.version).to.equal('85101541')
+    expect(response.statusCode).to.equal(404)
 
-    // get bar.js. This will cause the server to detect the version mismatch
+    // update the version to 2
+    await runUpdate(pubClient)
+    // get whatever.js. This will cause the server to detect the version mismatch
     response = await app.inject({ url: '/whatever.js' })
     expect(response.statusCode).to.equal(404)
 
-    await runUpdate(pubClient)
+    await runUpdate(pubClient) // version 3 not successful but still version 2 in cache
     await runUpdate(pubClient)
 
-    // get foo.js again. Since the versions should coincide now, the client should receive the new file
-    response = await app.inject({ url: '/foo.js' })
+    // bar should still be version 2
+    response = await app.inject({ url: '/bar.js' })
     expect(response.statusCode).to.equal(200)
-    expect(response.body).to.equal('foo2')
+    expect(response.body).to.equal('bar')
     expect(response.headers.version).to.equal('85102502')
   })
 })

src/version.js

@@ -164,7 +164,7 @@ let prevProcessedVersion = null
 
 export async function updateVersionProcessor (pubClient) {
   try {
-    logger.info('[Version] Check for new version')
+    logger.debug('[Version] Check for new version')
     await configMap.load()
 
     const [storedVersion, fetchedVersionInfo] = await Promise.all([
@@ -175,8 +175,7 @@ export async function updateVersionProcessor (pubClient) {
     if (prevProcessedVersion && storedVersion === fetchedVersionInfo.version) {
       // make sure to limit memory consumption and always check redis
       cache.clear()
-
-      logger.info(`[Version] No new version has been found. No update needed. Current version: ${storedVersion}`)
+      logger.debug(`[Version] No new version has been found. No update needed. Current version: ${storedVersion}`)
       return storedVersion
     }
     logger.info(`[Version] Found new source version. Current version: '${storedVersion}', new version: '${fetchedVersionInfo.version}'`)
@@ -186,6 +185,7 @@ export async function updateVersionProcessor (pubClient) {
       Object.assign(versionInfo, fetchedVersionInfo)
       const stringifiedVersionInfo = JSON.stringify(versionInfo)
       cache.clear()
+
       await warmCache({ version: versionInfo.version, fetchFiles: true })
       await redis.client.set(getRedisKey({ name: 'versionInfo' }), stringifiedVersionInfo)
       await cache.get(getRedisKey({ version: versionInfo.version, name: 'mergedMetadata' }), async () => [await fetchMergedMetadata()])
@@ -197,6 +197,7 @@ export async function updateVersionProcessor (pubClient) {
       prevProcessedVersion = fetchedVersionInfo.version
     }
   } catch (err) {
+    versionInfo.version = null
     logger.error(`[Version] comparing version is not possible. Error: ${err.message}`)
   }
 }