Adding unit tests

Author: Swapnil Nagar

src/converters/fromRpcTypedData.ts

@@ -7,31 +7,23 @@ import { HttpRequest } from '../http/HttpRequest';
 import { isDefined } from '../utils/nonNull';
 
 export function fromRpcTypedData(data: RpcTypedData | null | undefined): unknown {
-    console.log('fromRpcTypedData input:', data);
-
     if (!data) {
-        console.log('Condition: !data - returning undefined');
         return undefined;
     } else if (isDefined(data.string)) {
         const result = tryJsonParse(data.string);
-        console.log('Condition: data.string - returning:', result);
         return result;
     } else if (isDefined(data.json)) {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const result = JSON.parse(data.json);
-        console.log('Condition: data.json - returning:', result);
         return result;
     } else if (isDefined(data.bytes)) {
         const result = Buffer.from(data.bytes);
-        console.log('Condition: data.bytes - returning Buffer of length:', result.length);
         return result;
     } else if (isDefined(data.stream)) {
         const result = Buffer.from(data.stream);
-        console.log('Condition: data.stream - returning Buffer of length:', result.length);
         return result;
     } else if (isDefined(data.http)) {
         const result = new HttpRequest(data.http);
-        console.log('Condition: data.http - returning HttpRequest');
         return result;
     } else if (isDefined(data.int)) {
         console.log('Condition: data.int - returning:', data.int);
@@ -41,24 +33,18 @@ export function fromRpcTypedData(data: RpcTypedData | null | undefined): unknown
         return data.double;
     } else if (data.collectionBytes && isDefined(data.collectionBytes.bytes)) {
         const result = data.collectionBytes.bytes.map((d) => Buffer.from(d));
-        console.log('Condition: data.collectionBytes - returning array of Buffers, count:', result.length);
         return result;
     } else if (data.collectionString && isDefined(data.collectionString.string)) {
         const result = data.collectionString.string.map(tryJsonParse);
-        console.log('Condition: data.collectionString - returning:', result);
         return result;
     } else if (data.collectionDouble && isDefined(data.collectionDouble.double)) {
-        console.log('Condition: data.collectionDouble - returning:', data.collectionDouble.double);
         return data.collectionDouble.double;
     } else if (data.collectionSint64 && isDefined(data.collectionSint64.sint64)) {
-        console.log('Condition: data.collectionSint64 - returning:', data.collectionSint64.sint64);
         return data.collectionSint64.sint64;
     } else if (data.modelBindingData && isDefined(data.modelBindingData.content)) {
-        console.log('Here at the modelBindinData', data.modelBindingData);
         return AzureStorageBlobClientFactory.buildClientFromModelBindingData(data.modelBindingData);
         //return data.modelBindingData;
     } else {
-        console.log('Condition: none matched - returning undefined');
         return undefined;
     }
 }
@@ -67,10 +53,8 @@ function tryJsonParse(data: string): unknown {
     try {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const parsed = JSON.parse(data);
-        console.log('tryJsonParse: successfully parsed JSON');
         return parsed;
     } catch {
-        console.log('tryJsonParse: failed to parse JSON, returning original string');
         return data;
     }
 }

src/converters/toCoreFunctionMetadata.ts

@@ -12,8 +12,6 @@ export function toCoreFunctionMetadata(name: string, options: GenericFunctionOpt
     const bindings: Record<string, coreTypes.RpcBindingInfo> = {};
     const bindingNames: string[] = [];
     const trigger = options.trigger;
-    console.log('toCoreFunctionMetadata: Handle', JSON.stringify(options));
-    console.log('toCoreFunctionMetadata: deferredBindingType', options.trigger.deferredBindingType);
 
     bindings[trigger.name] = {
         ...trigger,
@@ -80,10 +78,8 @@ export function toCoreFunctionMetadata(name: string, options: GenericFunctionOpt
 }
 
 function addDeferredBindingsFlag(deferredBindingType?: boolean | unknown): { [key: string]: string } {
-    //Ensure that trigger type that is passed is valid and supported, to avoid customer misconfiguration.
-    console.log('Deferred binding flag value is: ', deferredBindingType);
+    //Ensure that trigger type that is passed is valid and supported.
     if (deferredBindingType !== undefined && deferredBindingType === true) {
-        console.log('Adding deferred binding propertyu to trigger type:', deferredBindingType);
         return { supportsDeferredBinding: 'true' };
     }
 

src/converters/toRpcTypedData.ts

@@ -1,39 +1,32 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License.
 
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License.
+
 import { RpcTypedData } from '@azure/functions-core';
 
 export function toRpcTypedData(data: unknown): RpcTypedData | null | undefined {
-    console.log('toRpcTypedData input:', typeof data, data);
-
     if (data === null || data === undefined) {
-        console.log('Condition: null/undefined - returning:', data);
         return data;
     } else if (typeof data === 'string') {
-        console.log('Condition: string - returning:', { string: data });
         return { string: data };
     } else if (Buffer.isBuffer(data)) {
-        console.log('Condition: Buffer - returning bytes of length:', data.length);
         return { bytes: data };
     } else if (ArrayBuffer.isView(data)) {
         const bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-        console.log('Condition: ArrayBufferView - returning Uint8Array of length:', bytes.length);
         return { bytes: bytes };
     } else if (data instanceof ArrayBuffer) {
         const bytes = new Uint8Array(data);
-        console.log('Condition: ArrayBuffer - returning Uint8Array of length:', bytes.length);
         return { bytes: bytes };
     } else if (typeof data === 'number') {
         if (Number.isInteger(data)) {
-            console.log('Condition: integer number - returning:', { int: data });
             return { int: data };
         } else {
-            console.log('Condition: floating-point number - returning:', { double: data });
             return { double: data };
         }
     } else {
         const jsonString = JSON.stringify(data);
-        console.log('Condition: other (converted to JSON) - returning:', { json: jsonString });
         return { json: jsonString };
     }
 }

src/deferred-binding/storage-blob/azureStorageBlobClient.ts

@@ -21,7 +21,7 @@ export class AzureStorageBlobClient {
         blobName?: string,
         options?: StoragePipelineOptions
     ) {
-        const storageBlobServiceClient = strategy.createStroageBlobServiceClient(options);
+        const storageBlobServiceClient = strategy.createStorageBlobServiceClient(options);
         // Initialize container and blob clients if names are provided
         if (containerName) {
             this.containerClient = storageBlobServiceClient.getContainerClient(containerName);

src/deferred-binding/storage-blob/connectionStringStrategy.ts

@@ -13,7 +13,7 @@ export class ConnectionStringStrategy implements StorageBlobServiceClientStrateg
      */
     constructor(private connectionString: string) {}
 
-    createStroageBlobServiceClient(options?: StoragePipelineOptions): BlobServiceClient {
+    createStorageBlobServiceClient(options?: StoragePipelineOptions): BlobServiceClient {
         return BlobServiceClient.fromConnectionString(this.connectionString, options);
     }
 }

src/deferred-binding/storage-blob/managedIdentitySystemStrategy.ts

@@ -11,7 +11,7 @@ export class ManagedIdentitySystemStrategy implements StorageBlobServiceClientSt
      */
     constructor(private accountUrl: string) {}
 
-    createStroageBlobServiceClient(options?: StoragePipelineOptions): BlobServiceClient {
+    createStorageBlobServiceClient(options?: StoragePipelineOptions): BlobServiceClient {
         const credential = new DefaultAzureCredential();
         return new BlobServiceClient(this.accountUrl, credential, options);
     }

src/deferred-binding/storage-blob/managedIdentityUserStartegy.ts

@@ -15,7 +15,7 @@ export class ManagedIdentityUserStrategy implements StorageBlobServiceClientStra
      */
     constructor(private accountUrl: string, private clientId: string) {}
 
-    createStroageBlobServiceClient(options?: StoragePipelineOptions): BlobServiceClient {
+    createStorageBlobServiceClient(options?: StoragePipelineOptions): BlobServiceClient {
         const credential = new ManagedIdentityCredential(this.clientId);
         return new BlobServiceClient(this.accountUrl, credential, options);
     }

src/deferred-binding/storage-blob/storageBlobServiceClientStrategy.ts

@@ -7,5 +7,5 @@ import { BlobServiceClient, StoragePipelineOptions } from '@azure/storage-blob';
  * Strategy interface for creating StorageBlobServiceClient instances
  */
 export interface StorageBlobServiceClientStrategy {
-    createStroageBlobServiceClient(options?: StoragePipelineOptions): BlobServiceClient;
+    createStorageBlobServiceClient(options?: StoragePipelineOptions): BlobServiceClient;
 }

test/converters/fromRpcTypedData.test.ts

@@ -7,6 +7,8 @@ import { fromString } from 'long';
 import { HttpRequest } from '../../src';
 import { fromRpcTypedData } from '../../src/converters/fromRpcTypedData';
 import Long = require('long');
+import { ModelBindingData, RpcTypedData } from '@azure/functions-core';
+import { AzureStorageBlobClientFactory } from '../../src/deferred-binding/storage-blob/azureStorageBlobClientFactory';
 
 describe('fromRpcTypedData', () => {
     it('null', () => {
@@ -110,3 +112,74 @@ describe('fromRpcTypedData', () => {
         expect(result[1].toString()).to.equal('9007199254740992');
     });
 });
+
+describe('modelBindingData scenario', () => {
+    let mockBlobClient: any;
+
+    beforeEach(() => {
+        // Suppress console.log output during tests
+        console.log = () => {};
+
+        // Create mock blob client for testing
+        mockBlobClient = {
+            blobClient: { url: 'https://test.blob.core.windows.net/container/blob' },
+            containerClient: { url: 'https://test.blob.core.windows.net/container' },
+        };
+
+        // Replace the factory method with a mock implementation
+        AzureStorageBlobClientFactory.buildClientFromModelBindingData = () => {
+            return mockBlobClient;
+        };
+    });
+
+    it('should call AzureStorageBlobClientFactory with modelBindingData', () => {
+        let capturedModelBindingData: ModelBindingData | null = null;
+
+        // Override the mock to capture the input parameter
+        AzureStorageBlobClientFactory.buildClientFromModelBindingData = (modelBindingData: ModelBindingData) => {
+            capturedModelBindingData = modelBindingData;
+            return mockBlobClient;
+        };
+
+        const modelBindingData: ModelBindingData = {
+            content: Buffer.from(
+                JSON.stringify({
+                    Connection: 'test-connection',
+                    ContainerName: 'test-container',
+                    BlobName: 'test-blob.txt',
+                })
+            ),
+            contentType: 'application/json',
+            source: 'test-source',
+            version: '1.0',
+        };
+
+        const data: RpcTypedData = { modelBindingData };
+
+        const result = fromRpcTypedData(data);
+
+        // Verify the factory was called with the correct data
+        expect(capturedModelBindingData).to.equal(modelBindingData);
+
+        // Verify the result is what the factory returned
+        expect(result).to.equal(mockBlobClient);
+    });
+
+    it('should handle undefined content in modelBindingData', () => {
+        // Override mock to throw if called with incorrect data
+        AzureStorageBlobClientFactory.buildClientFromModelBindingData = () => {
+            throw new Error('Should not be called with undefined content');
+        };
+
+        const modelBindingData: ModelBindingData = {
+            // content is undefined
+            contentType: 'application/json',
+        };
+
+        const data: RpcTypedData = { modelBindingData };
+
+        // This should not throw because the isDefined check should prevent the factory from being called
+        const result = fromRpcTypedData(data);
+        expect(result).to.be.undefined;
+    });
+});