chore: add tests for api semver check

Author: dyladan

packages/opentelemetry-api/src/internal/global-utils.ts

@@ -20,7 +20,7 @@ import type { MeterProvider } from '../metrics/MeterProvider';
 import { _globalThis } from '../platform';
 import type { TracerProvider } from '../trace/tracer_provider';
 import { VERSION } from '../version';
-import { isVersionCompatible } from './semver';
+import { isCompatible } from './semver';
 
 const GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for('io.opentelemetry.js.api');
 
@@ -58,7 +58,7 @@ export function getGlobal<Type extends keyof OTelGlobalAPI>(
   type: Type
 ): OTelGlobalAPI[Type] | undefined {
   const version = _global[GLOBAL_OPENTELEMETRY_API_KEY]?.version;
-  if (!version || !isVersionCompatible(version)) {
+  if (!version || !isCompatible(version)) {
     return;
   }
   return _global[GLOBAL_OPENTELEMETRY_API_KEY]?.[type];

packages/opentelemetry-api/src/internal/semver.ts

@@ -18,79 +18,75 @@ import { VERSION } from '../version';
 
 const re = /^(\d+)\.(\d+)\.(\d+)(?:-(.*))?$/;
 
-const acceptedVersions = new Set<string>([VERSION]);
-const rejectedVersions = new Set<string>();
+export function _makeCompatibilityCheck(
+  myVersion: string
+): (version: string) => boolean {
+  const acceptedVersions = new Set<string>([myVersion]);
+  const rejectedVersions = new Set<string>();
 
-const myVersionMatch = VERSION.match(re);
-if (!myVersionMatch) {
-  throw new Error('Cannot parse own version');
-}
-
-const ownVersion = {
-  major: +myVersionMatch[1],
-  minor: +myVersionMatch[2],
-  patch: +myVersionMatch[3],
-};
-
-/**
- * Test an API version to see if it is compatible with this API.
- *
- * Exact match is always compatible
- * Major versions must always match
- * The minor version of the API module requesting access to the global API must be greater or equal to the minor version of this API
- * Patch and build tag differences are not considered at this time
- *
- * @param version version of the API requesting an instance of the global API
- */
-export function isVersionCompatible(version: string): boolean {
-  if (acceptedVersions.has(version)) {
-    return true;
+  const myVersionMatch = myVersion.match(re);
+  if (!myVersionMatch) {
+    throw new Error('Cannot parse own version');
   }
 
-  if (rejectedVersions.has(version)) {
-    return false;
-  }
+  const ownVersion = {
+    major: +myVersionMatch[1],
+    minor: +myVersionMatch[2],
+    patch: +myVersionMatch[3],
+  };
 
-  const m = version.match(re);
-  if (!m) {
-    // cannot parse other version
-    rejectedVersions.add(version);
-    return false;
-  }
+  return function isCompatible(version: string): boolean {
+    if (acceptedVersions.has(version)) {
+      return true;
+    }
 
-  const other = {
-    major: +m[1],
-    minor: +m[2],
-    patch: +m[3],
-  };
+    if (rejectedVersions.has(version)) {
+      return false;
+    }
 
-  // major versions must match
-  if (ownVersion.major != other.major) {
-    rejectedVersions.add(version);
-    return false;
-  }
+    const m = version.match(re);
+    if (!m) {
+      // cannot parse other version
+      rejectedVersions.add(version);
+      return false;
+    }
+
+    const other = {
+      major: +m[1],
+      minor: +m[2],
+      patch: +m[3],
+    };
 
-  // if major version is 0, minor is treated like major and patch is treated like minor
-  if (ownVersion.major === 0) {
-    if (ownVersion.minor != other.minor) {
+    // major versions must match
+    if (ownVersion.major != other.major) {
       rejectedVersions.add(version);
       return false;
     }
 
-    if (ownVersion.patch < other.patch) {
+    // if major version is 0, minor is treated like major and patch is treated like minor
+    if (ownVersion.major === 0) {
+      if (ownVersion.minor != other.minor) {
+        rejectedVersions.add(version);
+        return false;
+      }
+
+      if (ownVersion.patch < other.patch) {
+        rejectedVersions.add(version);
+        return false;
+      }
+
+      acceptedVersions.add(version);
+      return true;
+    }
+
+    if (ownVersion.minor < other.minor) {
       rejectedVersions.add(version);
       return false;
     }
 
     acceptedVersions.add(version);
     return true;
-  }
-
-  if (ownVersion.minor < other.minor) {
-    rejectedVersions.add(version);
-    return false;
-  }
-
-  acceptedVersions.add(version);
-  return true;
+  };
 }
+
+export const isCompatible = _makeCompatibilityCheck(VERSION);

packages/opentelemetry-api/test/api/global.test.ts renamed to packages/opentelemetry-api/test/internal/global.test.ts

@@ -0,0 +1,101 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed 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
+ *
+ *      https://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 * as assert from 'assert';
+import {
+  isCompatible,
+  _makeCompatibilityCheck,
+} from '../../src/internal/semver';
+import { VERSION } from '../../src/version';
+
+describe('Version Compatibility', () => {
+  it('should be compatible if versions are equal', () => {
+    assert.ok(isCompatible(VERSION));
+  });
+
+  describe('throws if own version cannot be parsed', () => {
+    assert.throws(() => {
+      _makeCompatibilityCheck('this is not semver');
+    });
+  });
+
+  describe('incompatible if other version cannot be parsed', () => {
+    const check = _makeCompatibilityCheck('0.1.2');
+    assert.ok(!check('this is not semver'));
+  });
+
+  describe('>= 1.x', () => {
+    it('should be compatible if major and minor versions are equal', () => {
+      const check = _makeCompatibilityCheck('1.2.3');
+      assert.ok(check('1.2.2'));
+      assert.ok(check('1.2.2-alpha'));
+      assert.ok(check('1.2.4'));
+      assert.ok(check('1.2.4-alpha'));
+    });
+
+    it('should be compatible if major versions are equal and minor version is lesser', () => {
+      const check = _makeCompatibilityCheck('1.2.3');
+      assert.ok(check('1.1.2'));
+      assert.ok(check('1.1.2-alpha'));
+      assert.ok(check('1.1.4'));
+      assert.ok(check('1.1.4-alpha'));
+    });
+
+    it('should be incompatible if major versions do not match', () => {
+      const check = _makeCompatibilityCheck('3.3.3');
+      assert.ok(!check('0.3.3'));
+      assert.ok(!check('0.3.3'));
+    });
+
+    it('should be incompatible if major versions match but other minor version is greater than our minor version', () => {
+      const check = _makeCompatibilityCheck('1.2.3');
+      assert.ok(!check('1.3.3-alpha'));
+      assert.ok(!check('1.3.3'));
+    });
+  });
+
+  describe('0.x', () => {
+    it('should be compatible if minor and patch versions are equal', () => {
+      const check = _makeCompatibilityCheck('0.1.2');
+      assert.ok(check('0.1.2'));
+      assert.ok(check('0.1.2-alpha'));
+    });
+
+    it('should be compatible if minor versions are equal and patch version is lesser', () => {
+      const check = _makeCompatibilityCheck('0.1.2');
+      assert.ok(check('0.1.1'));
+      assert.ok(check('0.1.1-alpha'));
+    });
+
+    it('should be incompatible if minor versions do not match', () => {
+      const check = _makeCompatibilityCheck('0.3.3');
+      assert.ok(!check('0.2.3'));
+      assert.ok(!check('0.4.3'));
+    });
+
+    it('should be incompatible if minor versions do not match', () => {
+      const check = _makeCompatibilityCheck('0.3.3');
+      assert.ok(!check('0.2.3'));
+      assert.ok(!check('0.4.3'));
+    });
+
+    it('should be incompatible if minor versions match but other patch version is greater than our patch version', () => {
+      const check = _makeCompatibilityCheck('0.3.3');
+      assert.ok(!check('0.3.4-alpha'));
+      assert.ok(!check('0.3.4'));
+    });
+  });
+});