Back to Repositories

Testing JSON Parsing Utilities in Apache Airflow

This test suite validates JSON parsing functionality in Apache Airflow’s web interface utilities. The tests systematically verify the handling of various data types and formats, ensuring robust JSON parsing capabilities across the application.

Test Coverage Overview

The test suite provides comprehensive coverage of JSON parsing scenarios across different data types.

Key areas tested include:

Primitive data types (null, boolean, numbers, strings)
Complex data structures (arrays, dictionaries)
String-encoded JSON objects
Edge cases and type validation

Implementation Analysis

The implementation utilizes Jest’s parameterized testing approach with test.each() to efficiently test multiple scenarios. The testing pattern systematically validates the jsonParse utility function’s behavior across different input types, ensuring consistent parsing results and proper type detection.

The tests leverage TypeScript’s type system for additional type safety and Jest’s expect assertions for validation.

Technical Details

Testing Infrastructure:

Framework: Jest
Language: TypeScript
Test Runner: Jest CLI
Assertion Style: expect().toEqual()
Test Organization: Parameterized test cases

Best Practices Demonstrated

The test suite exemplifies several testing best practices in modern JavaScript development.

Notable practices include:

Parameterized test cases for consistent validation
Explicit test case naming and organization
Comprehensive type coverage
Clear separation of test inputs and expected outputs
Proper null checking and error handling validation

apache/airflow

airflow/www/static/js/components/utils.test.ts

            
/*!
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import jsonParse from "./utils";

/* global describe, test, expect */

describe("JSON Parsing.", () => {
  test.each([
    {
      testName: "null",
      testContent: null,
      expectedIsJson: false,
    },
    {
      testName: "boolean",
      testContent: true,
      expectedIsJson: false,
    },
    {
      testName: "int",
      testContent: 42,
      expectedIsJson: false,
    },
    {
      testName: "float",
      testContent: 3.1415,
      expectedIsJson: false,
    },
    {
      testName: "string",
      testContent: "hello world",
      expectedIsJson: false,
    },
    {
      testName: "array",
      testContent: ["hello world", 42, 3.1515],
      expectedIsJson: true,
    },
    {
      testName: "array as string",
      testContent: JSON.stringify(["hello world", 42, 3.1515]),
      expectedIsJson: true,
    },
    {
      testName: "dict",
      testContent: { key: 42 },
      expectedIsJson: true,
    },
    {
      testName: "dict as string",
      testContent: JSON.stringify({ key: 42 }),
      expectedIsJson: true,
    },
  ])(
    "Input value is $testName",
    ({ testName, testContent, expectedIsJson }) => {
      const [isJson, contentJson, contentFormatted] = jsonParse(testContent);

      expect(testName).not.toBeNull();
      expect(isJson).toEqual(expectedIsJson);
      if (expectedIsJson) {
        expect(contentJson).not.toBeNull();
        expect(contentFormatted.length).toBeGreaterThan(0);
      }
    }
  );
});