tests

Author: Mariano Goldman

src/client/ContentClient.ts

@@ -1,12 +1,16 @@
 import { hashV0, hashV1 } from '@dcl/hashing'
 import { Entity } from '@dcl/schemas'
-import { IFetchComponent, RequestOptions } from '@well-known-components/interfaces'
+import { IFetchComponent, RequestOptions as OriginalRequestOptions } from '@well-known-components/interfaces'
 import FormData from 'form-data'
 import { ClientOptions, DeploymentData } from './types'
 import { addModelToFormData, isNode, mergeRequestOptions, sanitizeUrl, splitAndFetch } from './utils/Helper'
 import { retry } from './utils/retry'
 import { Response } from '@well-known-components/interfaces/dist/components/fetcher'
 
+export type RequestOptions = OriginalRequestOptions & {
+  deploymentProtocolVersion?: 'v1' | 'v2'
+}
+
 function arrayBufferFrom(value: Buffer | Uint8Array) {
   if (value.buffer) {
     return value.buffer
@@ -70,7 +74,6 @@ async function supportsDeploymentsV2(serverBaseUrl: string): Promise<boolean> {
     const response = await fetch(`${serverBaseUrl}/v2/entities/:entityId/files/:fileHash`, { method: 'OPTIONS' })
     return response.ok // returns true if response status is 200-299
   } catch (error) {
-    console.log(error)
     console.error(`Error: ${error}`)
     return false
   }
@@ -140,19 +143,19 @@ export function createContentClient(options: ClientOptions): ContentClient {
   }
 
   async function deploy(deployData: DeploymentData, options?: RequestOptions): Promise<unknown> {
-    // TODO We could also check the deployment size (if too small, may not be worth to use V2)
-    // One file is always the entity itself, so we check more than one for using v2
-    if (deployData.files.size > 1) {
+    if (options?.deploymentProtocolVersion === 'v2') {
       const supportsV2 = await supportsDeploymentsV2(contentUrl)
       if (supportsV2) {
         return deployV2(deployData, options)
+      } else {
+        throw new Error('The server does not support deployments v2.')
       }
     }
 
-    return deployTraditional(deployData, options)
+    return deployV1(deployData, options)
   }
 
-  async function deployTraditional(deployData: DeploymentData, options?: RequestOptions): Promise<unknown> {
+  async function deployV1(deployData: DeploymentData, options?: RequestOptions): Promise<unknown> {
     const form = await buildEntityFormDataForDeployment(deployData, options)
 
     const requestOptions = mergeRequestOptions(options ? options : {}, {
@@ -164,7 +167,6 @@ export function createContentClient(options: ClientOptions): ContentClient {
   }
 
   async function deployV2(deployData: DeploymentData, options?: RequestOptions): Promise<unknown> {
-    console.log('deployData', deployData)
     const areWeRunningInNode = isNode()
 
     const fileSizesManifest: Record<string, number> = Object.fromEntries(
@@ -183,7 +185,6 @@ export function createContentClient(options: ClientOptions): ContentClient {
     formData.append('fileSizesManifest', JSON.stringify(fileSizesManifest), {
       contentType: 'application/json'
     })
-    console.log('form', formData)
 
     const requestOptions = mergeRequestOptions(options ? options : {}, {
       body: formData as any,
@@ -194,14 +195,11 @@ export function createContentClient(options: ClientOptions): ContentClient {
     if (!response.ok) {
       throw new Error(`Failed to deploy entity with id '${deployData.entityId}'.`)
     }
-    console.log('Deployment started successfully! Uploading files...')
 
     const res = await response.json()
-    console.log('res', res)
 
     const fileUploadRequests = await buildFileUploadRequestsForDeploymentV2(deployData, res.missingFiles)
     await Promise.all(fileUploadRequests.map((request) => request()))
-    console.log('Files uploaded successfully! Finishing deployment...')
 
     const response2 = await fetcher.fetch(`${contentUrl}/v2/entities/${deployData.entityId}`, {
       method: 'PUT',

test/components.ts

@@ -1,15 +1,21 @@
 import { createConfigComponent } from '@well-known-components/env-config-provider'
 import { createServerComponent, Router } from '@well-known-components/http-server'
-import { IConfigComponent, IHttpServerComponent, ILoggerComponent, Lifecycle } from '@well-known-components/interfaces'
+import {
+  IConfigComponent,
+  IHttpServerComponent,
+  ILoggerComponent,
+  IMiddlewareAdapterHandler,
+  Lifecycle
+} from '@well-known-components/interfaces'
 import { createLogComponent } from '@well-known-components/logger'
 import { createRunner, defaultServerConfig } from '@well-known-components/test-helpers'
 import * as util from 'util'
 import DefaultContext = IHttpServerComponent.DefaultContext
 
-const logRequestMiddleware = async function logger(
-  ctx: DefaultContext<AppContext>,
-  next: () => Promise<IHttpServerComponent.IResponse>
-) {
+const logRequestMiddleware: IMiddlewareAdapterHandler<
+  DefaultContext<AppContext>,
+  IHttpServerComponent.IResponse
+> = async function logger(ctx: DefaultContext<AppContext>, next: () => Promise<IHttpServerComponent.IResponse>) {
   const headers: Record<string, string> = {}
 
   for (const [header, value] of ctx.request.headers) {

test/integration/ContentClient.E2E.spec.ts

@@ -52,6 +52,26 @@ runServerBasedE2ETest('test client post', ({ components }) => {
     files.set('QmA', new Uint8Array([111, 112, 113]))
     files.set('QmB', Buffer.from('asd', 'utf-8'))
 
-    await client.deploy({ authChain: [], entityId: 'QmENTITY', files })
+    await client.deploy(
+      { authChain: [], entityId: 'QmENTITY', files },
+      {
+        deploymentProtocolVersion: 'v1'
+      }
+    )
+  })
+
+  it('fails to publish an entity using v2 if the server does not support v2', async () => {
+    const files = new Map<string, Uint8Array>()
+    files.set('QmA', new Uint8Array([111, 112, 113]))
+    files.set('QmB', Buffer.from('asd', 'utf-8'))
+
+    await expect(() =>
+      client.deploy(
+        { authChain: [], entityId: 'QmENTITY', files },
+        {
+          deploymentProtocolVersion: 'v2'
+        }
+      )
+    ).rejects.toThrowError('The server does not support deployments v2.')
   })
 })

test/integration/deployment-v2.spec.ts

@@ -118,10 +118,15 @@ runServerBasedE2ETest('test deployment v2 protocol', ({ components }) => {
   })
 
   test('publishes an entity', async () => {
-    const res = await client.deploy({
-      ...preparationData,
-      authChain: [{ type: AuthLinkType.SIGNER, payload: '0x1', signature: '' }]
-    })
+    const res = await client.deploy(
+      {
+        ...preparationData,
+        authChain: [{ type: AuthLinkType.SIGNER, payload: '0x1', signature: '' }]
+      },
+      {
+        deploymentProtocolVersion: 'v2'
+      }
+    )
 
     expect(res).toBe(true)
     expect(stage).toBe(5)