tfv 5.0.1 → 6.1.0

package/lib/utils/postInstall.js

@@ -1,15 +1,39 @@
-const {P_END, P_OK} = require('./colors');
-
-const message = `\n\
-         _        ________        __\n\
-       _| |__   / _____|\\ \\      / /\n\
-      |_  ___\\ | |___    \\ \\    / /\n\
-        | |    |  ___|    \\ \\  / /\n\
-        | |___ | |         \\ \\/ /\n\
-        \\______\\_|          \\__/\n\
-      \n\
-        ${P_OK}Happy terraforming!${P_END} 😍🥂\n\
-    ---------------------------------\n\
+const { platform } = require('os');
+const { initDirs, getPaths, fixPathConflict } = require('./paths');
+const { P_END, P_OK, P_WARN, P_INFO } = require('./colors');
+
+const banner = `
+         _        ________        __
+       _| |__   / _____|\\ \\      / /
+      |_  ___\\ | |___    \\ \\    / /
+        | |    |  ___|    \\ \\  / /
+        | |___ | |         \\ \\/ /
+        \\______\\_|          \\__/
+
+        ${P_OK}Happy terraforming!${P_END} 😍🥂
+    ---------------------------------
 `;
 
-console.log(message);
+try {
+  initDirs();
+  console.log(banner);
+
+  const { home } = getPaths();
+  console.log(`${P_INFO}tfv store: ${home}${P_END}`);
+
+  // Ensure ~/.tfv/bin is on PATH and positioned AFTER any system-level tool managers
+  // (brew, apt, etc.) so tfv always takes precedence. Safe to re-run on upgrade.
+  fixPathConflict();
+
+  if (platform() !== 'win32') {
+    console.log(`${P_OK}~/.tfv/bin added to PATH in your shell config files.${P_END}`);
+    console.log(`${P_WARN}Restart your terminal or run: source ~/.zshrc${P_END}`);
+  } else {
+    console.log(`${P_OK}~/.tfv/bin added to your User PATH.${P_END}`);
+    console.log(`${P_WARN}Restart your terminal for the change to take effect.${P_END}`);
+  }
+
+  console.log(`\n${P_OK}Run ${P_END}${P_INFO}tfv install latest${P_END}${P_OK} to get started.${P_END}\n`);
+} catch (err) {
+  console.log('postInstall error (non-fatal):', err.message);
+}

package/lib/utils/store.js

@@ -1,10 +1,21 @@
-const fs = require('fs');
-const {P_END, P_OK, P_ERROR} = require('./colors');
+const { existsSync, readdirSync } = require('fs');
+const { getProviderStore, initDirs } = require('./paths');
+const { P_END, P_OK, P_ERROR } = require('./colors');
 
-exports.checkStore = (store) => {
-  if (fs.readdirSync(store).length === 1) {
-    console.log(`${P_ERROR}You're yet to install terraform with tfv${P_END}`);
+exports.checkStore = (provider = 'terraform') => {
+  initDirs();
+  const store = getProviderStore(provider);
+
+  if (!existsSync(store)) {
+    console.log(`${P_ERROR}Store not found for provider: ${provider}${P_END}`);
+    console.log(`For guidance, run ${P_OK}tfv -h${P_END}`);
+    process.exit(1);
+  }
+
+  const files = readdirSync(store).filter(f => f !== 'arch.json');
+  if (files.length === 0) {
+    console.log(`${P_ERROR}You're yet to install ${provider} with tfv${P_END}`);
     console.log(`For guidance, run ${P_OK}tfv -h${P_END}`);
     process.exit(1);
   }
-}
+};

package/package.json

@@ -1,25 +1,24 @@
 {
   "name": "tfv",
-  "version": "5.0.1",
+  "version": "6.1.0",
   "publishConfig": {
     "access": "public",
     "provenance": true
   },
-  "description": "Terraform version manager",
+  "description": "Terraform & OpenTofu version manager",
   "main": "index.js",
-  "directories": {
-    "lib": "lib",
-    "store": "store"
-  },
   "scripts": {
-    "postinstall": "node lib/utils/postInstall.js"
+    "postinstall": "node lib/utils/postInstall.js",
+    "test": "jest --testPathPatterns=test/"
   },
   "bin": {
     "tfv": "index.js"
   },
   "keywords": [
     "Terraform",
-    "version"
+    "OpenTofu",
+    "version",
+    "manager"
   ],
   "author": "Marcus Chukwuoma <marcus2cu@gmail.com> (https://github.com/marcdomain)",
   "license": "MIT",
@@ -28,7 +27,10 @@
     "url": "https://github.com/marcdomain/tfv.git"
   },
   "dependencies": {
-    "decompress": "^4.2.1",
+    "adm-zip": "^0.5.10",
     "yargs": "^17.2.1"
+  },
+  "devDependencies": {
+    "jest": "^30.4.2"
   }
 }

package/test/extractTargets.test.js

@@ -0,0 +1,75 @@
+const { extractTargets, removeComments } = require('../lib/modules/terraform-command');
+
+describe('removeComments', () => {
+  test('removes # single-line comments', () => {
+    const result = removeComments('resource "aws_instance" "web" { # this is a comment\n}');
+    expect(result).not.toContain('this is a comment');
+    expect(result).toContain('resource "aws_instance" "web"');
+  });
+
+  test('removes // single-line comments', () => {
+    const result = removeComments('// this is a comment\nresource "aws_s3_bucket" "bucket" {}');
+    expect(result).not.toContain('this is a comment');
+    expect(result).toContain('resource "aws_s3_bucket" "bucket"');
+  });
+
+  test('removes /* */ block comments', () => {
+    const content = '/* block\ncomment */\nresource "aws_vpc" "main" {}';
+    const result = removeComments(content);
+    expect(result).not.toContain('block');
+    expect(result).toContain('resource "aws_vpc" "main"');
+  });
+
+  test('does not remove # inside strings', () => {
+    const content = 'tags = { name = "web#1" } # this is a comment';
+    const result = removeComments(content);
+    expect(result).toContain('"web#1"');
+    expect(result).not.toContain('this is a comment');
+  });
+});
+
+describe('extractTargets', () => {
+  const tfContent = `
+resource "aws_instance" "web" {
+  ami = "ami-12345"
+}
+
+resource "aws_s3_bucket" "logs" {}
+
+data "aws_ami" "ubuntu" {}
+
+module "vpc" {
+  source = "./modules/vpc"
+}
+  `;
+
+  test('extracts resource targets', () => {
+    const targets = extractTargets(tfContent);
+    expect(targets).toContain('aws_instance.web');
+    expect(targets).toContain('aws_s3_bucket.logs');
+  });
+
+  test('extracts data source targets', () => {
+    const targets = extractTargets(tfContent);
+    expect(targets).toContain('data.aws_ami.ubuntu');
+  });
+
+  test('extracts module targets', () => {
+    const targets = extractTargets(tfContent);
+    expect(targets).toContain('module.vpc');
+  });
+
+  test('returns empty array for empty content', () => {
+    expect(extractTargets('')).toEqual([]);
+  });
+
+  test('ignores commented-out resources', () => {
+    const commented = `
+# resource "aws_instance" "commented" {}
+resource "aws_instance" "real" {}
+    `;
+    const targets = extractTargets(commented);
+    expect(targets).not.toContain('aws_instance.commented');
+    expect(targets).toContain('aws_instance.real');
+  });
+});

package/test/formatVersions.test.js

@@ -0,0 +1,126 @@
+const {
+  formatVersions, formatAllVersions,
+  formatOpenTofuVersions, formatAllOpenTofuVersions,
+  semverDesc,
+} = require('../lib/utils/formatVersions');
+
+describe('formatVersions (Terraform JSON API)', () => {
+  const mockApiResponse = {
+    versions: {
+      '1.7.3': { name: 'terraform', version: '1.7.3' },
+      '1.7.0': { name: 'terraform', version: '1.7.0' },
+      '1.6.6': { name: 'terraform', version: '1.6.6' },
+      '1.8.0-beta1': { name: 'terraform', version: '1.8.0-beta1' },
+      '0.14.0': { name: 'terraform', version: '0.14.0' },
+    }
+  };
+
+  test('parses versions from JSON object', () => {
+    const result = formatVersions(mockApiResponse);
+    expect(result).toContain('1.7.3');
+    expect(result).toContain('1.6.6');
+    expect(result).toContain('0.14.0');
+  });
+
+  test('excludes pre-release versions', () => {
+    const result = formatVersions(mockApiResponse);
+    expect(result).not.toContain('1.8.0-beta1');
+  });
+
+  test('sorts versions descending', () => {
+    const result = formatVersions(mockApiResponse);
+    expect(result[0]).toBe('1.7.3');
+    expect(result[1]).toBe('1.7.0');
+    expect(result[2]).toBe('1.6.6');
+  });
+
+  test('accepts a JSON string', () => {
+    const result = formatVersions(JSON.stringify(mockApiResponse));
+    expect(result).toContain('1.7.3');
+  });
+});
+
+describe('formatAllVersions (Terraform — includes pre-releases)', () => {
+  const mockApiResponse = {
+    versions: {
+      '1.8.0-beta1': {},
+      '1.7.3': {},
+      '1.7.0-rc1': {},
+      '1.6.6': {},
+    }
+  };
+
+  test('includes pre-release versions', () => {
+    const result = formatAllVersions(mockApiResponse);
+    expect(result).toContain('1.8.0-beta1');
+    expect(result).toContain('1.7.0-rc1');
+  });
+
+  test('still includes stable versions', () => {
+    const result = formatAllVersions(mockApiResponse);
+    expect(result).toContain('1.7.3');
+  });
+
+  test('sorts descending', () => {
+    const result = formatAllVersions(mockApiResponse);
+    expect(result[0]).toBe('1.8.0-beta1');
+  });
+});
+
+describe('formatOpenTofuVersions (GitHub Releases API)', () => {
+  const mockReleases = [
+    { tag_name: 'v1.7.3', prerelease: false, draft: false },
+    { tag_name: 'v1.7.0', prerelease: false, draft: false },
+    { tag_name: 'v1.8.0-alpha1', prerelease: true, draft: false },
+    { tag_name: 'v1.6.5', prerelease: false, draft: true },
+  ];
+
+  test('strips v prefix from versions', () => {
+    const result = formatOpenTofuVersions(mockReleases);
+    result.forEach(v => expect(v).not.toMatch(/^v/));
+  });
+
+  test('excludes pre-releases and drafts', () => {
+    const result = formatOpenTofuVersions(mockReleases);
+    expect(result).not.toContain('1.8.0-alpha1');
+    expect(result).not.toContain('1.6.5');
+  });
+
+  test('sorts versions descending', () => {
+    const result = formatOpenTofuVersions(mockReleases);
+    expect(result[0]).toBe('1.7.3');
+    expect(result[1]).toBe('1.7.0');
+  });
+});
+
+describe('formatAllOpenTofuVersions (includes pre-releases)', () => {
+  const mockReleases = [
+    { tag_name: 'v1.8.0-alpha1', prerelease: true, draft: false },
+    { tag_name: 'v1.7.3', prerelease: false, draft: false },
+    { tag_name: 'v1.6.5', prerelease: false, draft: true },  // drafts still excluded
+  ];
+
+  test('includes pre-release builds', () => {
+    const result = formatAllOpenTofuVersions(mockReleases);
+    expect(result).toContain('1.8.0-alpha1');
+  });
+
+  test('excludes draft releases', () => {
+    const result = formatAllOpenTofuVersions(mockReleases);
+    expect(result).not.toContain('1.6.5');
+  });
+});
+
+describe('semverDesc', () => {
+  test('sorts major versions correctly', () => {
+    expect(['1.0.0', '2.0.0', '0.9.0'].sort(semverDesc)).toEqual(['2.0.0', '1.0.0', '0.9.0']);
+  });
+
+  test('sorts minor versions correctly', () => {
+    expect(['1.3.0', '1.10.0', '1.2.0'].sort(semverDesc)).toEqual(['1.10.0', '1.3.0', '1.2.0']);
+  });
+
+  test('sorts patch versions correctly', () => {
+    expect(['1.7.1', '1.7.3', '1.7.2'].sort(semverDesc)).toEqual(['1.7.3', '1.7.2', '1.7.1']);
+  });
+});

package/test/moduleImports.test.js

@@ -0,0 +1,45 @@
+'use strict';
+
+/**
+ * Smoke-import tests — verifies every module loads without ReferenceErrors,
+ * missing requires, or other module-level exceptions.
+ */
+
+const modules = [
+  '../lib/modules/install',
+  '../lib/modules/use',
+  '../lib/modules/list',
+  '../lib/modules/remote',
+  '../lib/modules/remove',
+  '../lib/modules/switch',
+  '../lib/modules/current',
+  '../lib/modules/pin',
+  '../lib/modules/upgrade',
+  '../lib/modules/shell-init',
+  '../lib/modules/terraform-command',
+  '../lib/utils/paths',
+  '../lib/utils/store',
+  '../lib/utils/formatVersions',
+  '../lib/utils/colors',
+  '../lib/commands/install',
+  '../lib/commands/use',
+  '../lib/commands/list',
+  '../lib/commands/remove',
+  '../lib/commands/switch',
+  '../lib/commands/current',
+  '../lib/commands/pin',
+  '../lib/commands/upgrade',
+  '../lib/commands/shell-init',
+  '../lib/commands/plan',
+  '../lib/commands/apply',
+  '../lib/commands/destroy',
+  '../lib/commands/init',
+  '../lib/commands/validate',
+  '../lib/commands/fmt',
+];
+
+describe('module imports', () => {
+  test.each(modules)('%s loads without error', (mod) => {
+    expect(() => require(mod)).not.toThrow();
+  });
+});

package/test/paths.test.js

@@ -0,0 +1,69 @@
+const { join } = require('path');
+const { homedir } = require('os');
+const {
+  TFV_HOME,
+  getPaths,
+  normalizeProvider,
+  getCliName,
+  getProviderStore,
+} = require('../lib/utils/paths');
+
+describe('TFV_HOME', () => {
+  test('is under the user home directory', () => {
+    expect(TFV_HOME).toBe(join(homedir(), '.tfv'));
+  });
+});
+
+describe('getPaths', () => {
+  const paths = getPaths();
+
+  test('bin is inside TFV_HOME', () => {
+    expect(paths.bin).toBe(join(TFV_HOME, 'bin'));
+  });
+
+  test('store is inside TFV_HOME', () => {
+    expect(paths.store).toBe(join(TFV_HOME, 'store'));
+  });
+
+  test('terraform store is correct', () => {
+    expect(paths.terraform).toBe(join(TFV_HOME, 'store', 'terraform'));
+  });
+
+  test('opentofu store is correct', () => {
+    expect(paths.opentofu).toBe(join(TFV_HOME, 'store', 'opentofu'));
+  });
+
+  test('active.json is in TFV_HOME', () => {
+    expect(paths.active).toBe(join(TFV_HOME, 'active.json'));
+  });
+});
+
+describe('normalizeProvider', () => {
+  test('terraform → terraform', () => expect(normalizeProvider('terraform')).toBe('terraform'));
+  test('tf → terraform', () => expect(normalizeProvider('tf')).toBe('terraform'));
+  test('tofu → opentofu', () => expect(normalizeProvider('tofu')).toBe('opentofu'));
+  test('opentofu → opentofu', () => expect(normalizeProvider('opentofu')).toBe('opentofu'));
+  test('default (undefined) → terraform', () => expect(normalizeProvider()).toBe('terraform'));
+  test('unknown → terraform', () => expect(normalizeProvider('unknown')).toBe('terraform'));
+});
+
+describe('getCliName', () => {
+  test('terraform → terraform', () => expect(getCliName('terraform')).toBe('terraform'));
+  test('tf → terraform', () => expect(getCliName('tf')).toBe('terraform'));
+  test('tofu → tofu', () => expect(getCliName('tofu')).toBe('tofu'));
+  test('opentofu → tofu', () => expect(getCliName('opentofu')).toBe('tofu'));
+});
+
+describe('getProviderStore', () => {
+  test('returns terraform store by default', () => {
+    expect(getProviderStore()).toBe(join(TFV_HOME, 'store', 'terraform'));
+  });
+
+  test('returns opentofu store for tofu alias', () => {
+    expect(getProviderStore('tofu')).toBe(join(TFV_HOME, 'store', 'opentofu'));
+  });
+
+  test('returns opentofu store', () => {
+    expect(getProviderStore('opentofu')).toBe(join(TFV_HOME, 'store', 'opentofu'));
+  });
+});

package/test/versionResolution.test.js

@@ -0,0 +1,92 @@
+// Test the resolveConstraint logic from switch.js by extracting it
+
+// Inline the function for isolated testing
+const resolveConstraint = (constraint, versions) => {
+  const parts = constraint.split(',').map(s => s.trim());
+
+  return versions.find(v => {
+    return parts.every(part => {
+      const m = part.match(/^(~>|>=|<=|!=|>|<|=)?\s*(\d+(?:\.\d+)*)/);
+      if (!m) return false;
+      const [, op = '=', req] = m;
+
+      const vParts = v.split('.').map(n => parseInt(n, 10) || 0);
+      const rParts = req.split('.').map(n => parseInt(n, 10) || 0);
+
+      const cmp = () => {
+        for (let i = 0; i < 3; i++) {
+          const diff = (vParts[i] || 0) - (rParts[i] || 0);
+          if (diff !== 0) return diff;
+        }
+        return 0;
+      };
+
+      switch (op) {
+        case '~>': {
+          const segCount = rParts.length;
+          for (let i = 0; i < segCount - 1; i++) {
+            if ((vParts[i] || 0) !== (rParts[i] || 0)) return false;
+          }
+          return (vParts[segCount - 1] || 0) >= (rParts[segCount - 1] || 0);
+        }
+        case '>=': return cmp() >= 0;
+        case '>':  return cmp() > 0;
+        case '<=': return cmp() <= 0;
+        case '<':  return cmp() < 0;
+        case '!=': return cmp() !== 0;
+        default:   return cmp() === 0;
+      }
+    });
+  }) || null;
+};
+
+const versions = ['1.9.0', '1.8.5', '1.8.0', '1.7.3', '1.7.0', '1.6.6', '1.5.7', '0.15.0'];
+
+describe('resolveConstraint', () => {
+  test('exact match =', () => {
+    expect(resolveConstraint('= 1.7.3', versions)).toBe('1.7.3');
+  });
+
+  test('exact match (no operator)', () => {
+    expect(resolveConstraint('1.7.3', versions)).toBe('1.7.3');
+  });
+
+  test('>= returns highest satisfying version', () => {
+    expect(resolveConstraint('>= 1.8.0', versions)).toBe('1.9.0');
+  });
+
+  test('> strictly greater', () => {
+    expect(resolveConstraint('> 1.8.0', versions)).toBe('1.9.0');
+  });
+
+  test('<= returns highest satisfying version', () => {
+    expect(resolveConstraint('<= 1.7.3', versions)).toBe('1.7.3');
+  });
+
+  test('!= excludes version', () => {
+    expect(resolveConstraint('!= 1.9.0', versions)).toBe('1.8.5');
+  });
+
+  test('~> 1.7 allows patch bumps only', () => {
+    // ~> 1.7 means >= 1.7, < 2.0 effectively
+    const result = resolveConstraint('~> 1.7', versions);
+    expect(result).toBe('1.9.0'); // highest with major=1
+  });
+
+  test('~> 1.7.0 allows patch bumps in 1.7.x', () => {
+    const result = resolveConstraint('~> 1.7.0', versions);
+    expect(['1.7.3', '1.7.0']).toContain(result);
+    // Should be 1.7.3 (highest 1.7.x)
+    expect(result).toBe('1.7.3');
+  });
+
+  test('compound constraint >= X, < Y', () => {
+    // >= 1.7.0, < 1.9.0
+    const result = resolveConstraint('>= 1.7.0, < 1.9.0', versions);
+    expect(result).toBe('1.8.5');
+  });
+
+  test('returns null when no version satisfies', () => {
+    expect(resolveConstraint('>= 2.0.0', versions)).toBeNull();
+  });
+});