confctl 2.2.2 → 3.0.0

data/spec/confctl/cli/inputs_set_output_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'confctl'
+require 'confctl/cli'
+
+RSpec.describe 'flake input set output' do
+  let(:gopts) { { color: 'never' } }
+  let(:common_opts) { { commit: false, changelog: true, downgrade: false, editor: false } }
+  let(:lock) { instance_double(ConfCtl::FlakeLock) }
+  let(:resolved_info) { { short_rev: '5361648e', rev: '5361648e4a29f58b5c208d3f185d95cd0a43fe54' } }
+
+  around do |example|
+    old_tty = ENV.fetch('CONFCTL_TTY', nil)
+    ENV['CONFCTL_TTY'] = '0'
+    example.run
+  ensure
+    ENV['CONFCTL_TTY'] = old_tty
+  end
+
+  before do
+    allow(ConfCtl::ConfDir).to receive(:path).and_return('/conf')
+    allow(ConfCtl::ConfigType).to receive(:flake?).with('/conf').and_return(true)
+    allow(ConfCtl::Inputs::Setter).to receive(:run!).and_return(changed: true, changes: [])
+    allow(ConfCtl::FlakeLock).to receive(:load).with('/conf/flake.lock').and_return(lock)
+    allow(lock).to receive(:input_info).with('vpsadmin-input').and_return(resolved_info)
+  end
+
+  it 'prints the resolved locked revision for channel set' do
+    command = ConfCtl::Cli::Inputs::Channels.new(
+      gopts,
+      common_opts.merge(allow_shared: false),
+      %w[vpsadmin vpsadmin devel]
+    )
+
+    allow(command).to receive(:eval_channels).and_return(
+      'vpsadmin' => { 'vpsadmin' => 'vpsadmin-input' }
+    )
+
+    expect do
+      command.set
+    end.to output("Configuring vpsadmin in vpsadmin -> 5361648e\n").to_stdout
+
+    expect(ConfCtl::Inputs::Setter).to have_received(:run!).with(
+      hash_including(conf_dir: '/conf', inputs: ['vpsadmin-input'], rev: 'devel')
+    )
+  end
+
+  it 'prints the resolved locked revision for machine set' do
+    nix = instance_double(ConfCtl::Nix)
+    allow(ConfCtl::Nix).to receive(:new).and_return(nix)
+    allow(nix).to receive(:eval_inputs_info).with('build.vpsfree.cz').and_return(
+      'vpsadmin' => { 'input' => 'vpsadmin-input' }
+    )
+
+    command = ConfCtl::Cli::Inputs::Machines.new(
+      gopts,
+      common_opts,
+      %w[build.vpsfree.cz vpsadmin devel]
+    )
+
+    expect do
+      command.set
+    end.to output("Configuring vpsadmin in build.vpsfree.cz -> 5361648e\n").to_stdout
+
+    expect(ConfCtl::Inputs::Setter).to have_received(:run!).with(
+      hash_including(conf_dir: '/conf', inputs: ['vpsadmin-input'], rev: 'devel')
+    )
+  end
+end

data/spec/confctl/configuration_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+
+RSpec.describe 'configuration commands' do
+  include CliHelper
+
+  it 'initializes a flake configuration directory' do
+    Dir.mktmpdir('confctl-config-init-') do |dir|
+      result = run_confctl('init', chdir: dir)
+      flake = File.read(File.join(dir, 'flake.nix'))
+
+      expect(result.success?).to be(true), result.err
+      expect(File).to exist(File.join(dir, 'flake.nix'))
+      expect(File).to exist(File.join(dir, 'cluster', 'cluster.nix'))
+      expect(File).to exist(File.join(dir, 'configs', 'confctl.nix'))
+      expect(File).to exist(File.join(dir, 'data', 'ssh-keys.nix'))
+      expect(flake).to include('nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";')
+      expect(flake).to include('# vpsadminos.url = "github:vpsfreecz/vpsadminos/staging";')
+      expect(flake).to include('# vpsadminos.inputs.nixpkgs.follows = "nixpkgs";')
+      expect(flake).to include('confctl.lib.mkConfigDevShell')
+      expect(flake).to include('mode = "minimal";')
+    end
+  end
+
+  it 'adds and renames machines and rewrites cluster inventory' do
+    Dir.mktmpdir('confctl-config-add-rename-') do |dir|
+      expect(run_confctl('init', chdir: dir).success?).to be(true)
+
+      add_result = run_confctl('add', 'nested/test-machine', chdir: dir)
+      expect(add_result.success?).to be(true), add_result.err
+      expect(File).to exist(File.join(dir, 'cluster', 'nested', 'test-machine', 'module.nix'))
+      expect(File.read(File.join(dir, 'cluster', 'cluster.nix'))).to include('./nested/test-machine/module.nix')
+
+      rename_result = run_confctl('rename', 'nested/test-machine', 'renamed/machine', chdir: dir)
+      expect(rename_result.success?).to be(true), rename_result.err
+      expect(File).not_to exist(File.join(dir, 'cluster', 'nested', 'test-machine'))
+      expect(File).to exist(File.join(dir, 'cluster', 'renamed', 'machine', 'module.nix'))
+
+      cluster_nix = File.read(File.join(dir, 'cluster', 'cluster.nix'))
+      expect(cluster_nix).to include('./renamed/machine/module.nix')
+      expect(cluster_nix).not_to include('./nested/test-machine/module.nix')
+    end
+  end
+end

data/spec/confctl/inputs_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'tmpdir'
+
+RSpec.describe 'inputs workflows' do
+  include CliHelper
+
+  def create_dummy_repo(path)
+    FileUtils.mkdir_p(path)
+    init_git_repo(path)
+
+    File.write(
+      File.join(path, 'flake.nix'),
+      <<~NIX
+        {
+          description = "dummy flake input for confctl tests";
+          outputs = { self, ... }: {};
+        }
+      NIX
+    )
+    File.write(File.join(path, 'dummy.txt'), "A\n")
+    git_commit_all(path, 'dummy: A')
+    rev_a = run_cmd('git', 'rev-parse', 'HEAD', chdir: path).out.strip
+
+    [rev_a]
+  end
+
+  def commit_dummy(path, label)
+    count = run_cmd('git', 'rev-list', '--count', 'HEAD', chdir: path).out.strip.to_i
+    File.write(File.join(path, 'dummy.txt'), "#{label} #{count + 1}\n")
+    git_commit_all(path, "dummy: #{label}")
+    run_cmd('git', 'rev-parse', 'HEAD', chdir: path).out.strip
+  end
+
+  def locked_rev(lock_path, input)
+    lock = JSON.parse(File.read(lock_path))
+    node_id = lock.fetch('nodes').fetch('root').fetch('inputs').fetch(input)
+    lock.fetch('nodes').fetch(node_id).fetch('locked').fetch('rev')
+  end
+
+  it 'updates and sets local git inputs with and without commits/changelog' do
+    Dir.mktmpdir('confctl-inputs-spec-') do |dir|
+      dummy_repo = File.join(dir, 'dummy-input')
+      rev_a, = create_dummy_repo(dummy_repo)
+
+      conf_dir = File.join(dir, 'conf')
+      FileUtils.mkdir_p(conf_dir)
+      init_git_repo(conf_dir)
+
+      File.write(File.join(conf_dir, 'flake.nix'), <<~NIX)
+        {
+          description = "confctl inputs test";
+
+          inputs = {
+            dummy-input.url = "git+file://#{dummy_repo}";
+          };
+
+          outputs = { self, ... }: {};
+        }
+      NIX
+
+      git_commit_all(conf_dir, 'fixture: initial')
+
+      res = run_confctl('inputs', 'update', 'dummy-input', chdir: conf_dir)
+      expect(res.success?).to be(true), "#{res.out}\n#{res.err}"
+
+      lock_path = File.join(conf_dir, 'flake.lock')
+      expect(File).to exist(lock_path)
+      expect(locked_rev(lock_path, 'dummy-input')).to eq(rev_a)
+
+      log_count = run_cmd('git', 'rev-list', '--count', 'HEAD', chdir: conf_dir).out.strip.to_i
+      expect(log_count).to eq(1)
+
+      rev_b = commit_dummy(dummy_repo, 'B')
+
+      res = run_confctl(
+        'inputs', 'update', '--commit', '--no-changelog', '--no-editor', 'dummy-input',
+        chdir: conf_dir
+      )
+      expect(res.success?).to be(true), "#{res.out}\n#{res.err}"
+      expect(locked_rev(lock_path, 'dummy-input')).to eq(rev_b)
+
+      log_count = run_cmd('git', 'rev-list', '--count', 'HEAD', chdir: conf_dir).out.strip.to_i
+      expect(log_count).to eq(2)
+
+      last_msg = run_cmd('git', 'log', '-1', '--pretty=%s', chdir: conf_dir).out.strip
+      expect(last_msg).to include('inputs: update dummy-input')
+
+      res = run_confctl(
+        'inputs', 'set', '--commit', '--changelog', '--no-editor', 'dummy-input', rev_a,
+        chdir: conf_dir
+      )
+      expect(res.success?).to be(true), "#{res.out}\n#{res.err}"
+      expect(locked_rev(lock_path, 'dummy-input')).to eq(rev_a)
+
+      log_count = run_cmd('git', 'rev-list', '--count', 'HEAD', chdir: conf_dir).out.strip.to_i
+      expect(log_count).to eq(3)
+
+      last_msg = run_cmd('git', 'log', '-1', '--pretty=%s', chdir: conf_dir).out.strip
+      expect(last_msg).to include('inputs: set dummy-input')
+    end
+  end
+end

data/spec/confctl/machine_control_spec.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'confctl'
+require 'shellwords'
+
+RSpec.describe ConfCtl::MachineControl do
+  let(:runner_class) do
+    Class.new do
+      attr_reader :calls, :result
+
+      def initialize
+        @calls = []
+        @result = Object.new
+      end
+
+      def run(*args, **kwargs, &)
+        calls << { method: :run, args:, kwargs:, block: block_given? }
+        result
+      end
+
+      def run!(*args, **kwargs, &)
+        calls << { method: :run!, args:, kwargs:, block: block_given? }
+        result
+      end
+    end
+  end
+
+  let(:runner) { runner_class.new }
+
+  before do
+    allow(ConfCtl::SystemCommand).to receive(:new).and_return(runner)
+    allow(ENV).to receive(:fetch).and_call_original
+    allow(ENV).to receive(:fetch).with('CONFCTL_SSH_CONFIG', nil).and_return(nil)
+  end
+
+  def machine(localhost:, target_host: 'web.int.vpsfree.cz', target_port: 22)
+    instance_double(
+      ConfCtl::Machine,
+      localhost?: localhost,
+      target_host:,
+      target_port:
+    )
+  end
+
+  it 'passes localhost commands as literal argv' do
+    command = %w[printf %s] + ['Host: vpsfree.cz']
+
+    ret = described_class.new(machine(localhost: true)).execute(*command)
+
+    expect(ret).to equal(runner.result)
+    expect(runner.calls).to contain_exactly(
+      method: :run,
+      args: command,
+      kwargs: {},
+      block: false
+    )
+  end
+
+  it 'shell-quotes remote argv into one ssh command argument' do
+    command = [
+      'printf',
+      '%s',
+      'Host: vpsfree.cz',
+      "quote'arg",
+      '',
+      'semi;colon',
+      'dollar$arg'
+    ]
+
+    ret = described_class.new(machine(localhost: false, target_port: 2222)).execute!(
+      *command,
+      input: 'stdin'
+    )
+
+    expect(ret).to equal(runner.result)
+    expect(runner.calls).to contain_exactly(
+      method: :run!,
+      args: [
+        'ssh',
+        '-l',
+        'root',
+        '-p',
+        '2222',
+        'web.int.vpsfree.cz',
+        Shellwords.join(command)
+      ],
+      kwargs: { input: 'stdin' },
+      block: false
+    )
+  end
+
+  it 'keeps extra ssh options before the target host' do
+    mc = described_class.new(machine(localhost: false))
+
+    mc.send(:with_ssh_opts, '-o', 'ConnectTimeout=3') do
+      mc.execute!('true')
+    end
+
+    expect(runner.calls.first[:args]).to eq(
+      [
+        'ssh',
+        '-l',
+        'root',
+        '-o',
+        'ConnectTimeout=3',
+        'web.int.vpsfree.cz',
+        'true'
+      ]
+    )
+  end
+end

data/spec/confctl/machine_list_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'confctl'
+
+RSpec.describe ConfCtl::MachineList do
+  def machine(managed: true, runnable: true, checks: [])
+    instance_double(
+      ConfCtl::Machine,
+      managed:,
+      runnable?: runnable,
+      health_checks: checks
+    )
+  end
+
+  it 'selects only runnable machines' do
+    direct = machine
+    carried = machine(runnable: false)
+    no_target = machine(runnable: false)
+
+    list = described_class.new(
+      machines: {
+        'direct' => direct,
+        'carried' => carried,
+        'no-target' => no_target
+      }
+    )
+
+    expect(list.runnable.to_a).to eq([direct])
+  end
+
+  it 'returns health checks only from runnable machines' do
+    direct_check = instance_double(ConfCtl::HealthChecks::Base)
+    carried_check = instance_double(ConfCtl::HealthChecks::Base)
+    direct = machine(checks: [direct_check])
+    carried = machine(runnable: false, checks: [carried_check])
+
+    list = described_class.new(
+      machines: {
+        'direct' => direct,
+        'carried' => carried
+      }
+    )
+
+    expect(list.health_checks).to eq([direct_check])
+  end
+end

data/spec/confctl/nix_flake_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'confctl'
+require 'tmpdir'
+
+RSpec.describe ConfCtl::NixFlake do
+  it 'loads machine metadata from a built JSON file' do
+    Dir.mktmpdir do |dir|
+      json_path = File.join(dir, 'machine-list.json')
+      File.write(
+        json_path,
+        {
+          'host.example' => {
+            'key' => 'm_host_example',
+            '_module' => {},
+            'metaConfig' => {
+              '_module' => {}
+            }
+          }
+        }.to_json
+      )
+
+      nix = described_class.new(conf_dir: dir, max_jobs: 'auto')
+      allow(nix).to receive(:nix_build_json)
+        .with(['.#confctl.machinesJson'])
+        .and_return([{ 'outputs' => { 'out' => json_path } }])
+      allow(nix).to receive(:nix_eval_json)
+
+      machines = nix.list_machines
+
+      expect(machines).to eq(
+        'host.example' => {
+          'key' => 'm_host_example',
+          'metaConfig' => {}
+        }
+      )
+      expect(nix).not_to have_received(:nix_eval_json)
+    end
+  end
+end

data/spec/confctl/swpins_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'tmpdir'
+
+RSpec.describe 'swpins workflows' do
+  include CliHelper
+
+  def create_repo_with_commit(path, content, message)
+    File.write(File.join(path, 'dummy.txt'), content)
+    git_commit_all(path, message)
+    run_cmd('git', 'rev-parse', 'HEAD', chdir: path).out.strip
+  end
+
+  def channel_rev(conf_dir)
+    json = JSON.parse(File.read(File.join(conf_dir, 'swpins', 'channels', 'nixos-unstable.json')))
+    json.fetch('nixpkgs').fetch('state').fetch('rev')
+  end
+
+  it 'updates and sets swpins from a local git repository with commit variants' do
+    Dir.mktmpdir('confctl-swpins-spec-') do |dir|
+      nixpkgs_path = ENV.fetch('CONFCTL_TEST_NIXPKGS', nil)
+      if nixpkgs_path.nil? || nixpkgs_path.empty?
+        lookup = run_cmd('nix-instantiate', '--find-file', 'nixpkgs', chdir: dir)
+        expect(lookup.success?).to be(true), "#{lookup.out}\n#{lookup.err}"
+        nixpkgs_path = lookup.out.strip
+      end
+
+      dummy_repo = File.join(dir, 'dummy-repo')
+      FileUtils.mkdir_p(dummy_repo)
+      init_git_repo(dummy_repo)
+      rev_a = create_repo_with_commit(dummy_repo, "A\n", 'dummy: A')
+
+      branch = run_cmd('git', 'rev-parse', '--abbrev-ref', 'HEAD', chdir: dummy_repo).out.strip
+
+      conf_dir = File.join(dir, 'conf')
+      FileUtils.mkdir_p(conf_dir)
+      expect(run_confctl('init', '--swpins', chdir: conf_dir).success?).to be(true)
+
+      File.write(File.join(conf_dir, 'configs', 'swpins.nix'), <<~NIX)
+        { config, ... }:
+        {
+          confctl.swpins.core.pins.nixpkgs = {
+            type = "directory";
+            directory.path = "#{nixpkgs_path}";
+          };
+
+          confctl.swpins.channels = {
+            nixos-unstable = {
+              nixpkgs = {
+                type = "git-rev";
+                git-rev = {
+                  url = "file://#{dummy_repo}";
+                  fetchSubmodules = false;
+                  update = {
+                    auto = false;
+                    interval = 0;
+                    ref = "refs/heads/#{branch}";
+                  };
+                };
+              };
+            };
+          };
+        }
+      NIX
+
+      init_git_repo(conf_dir)
+      git_commit_all(conf_dir, 'fixture: initial')
+
+      res =
+        if ENV['CONFCTL_RSPEC_SANDBOX'] == '1'
+          run_confctl('swpins', 'channel', 'update', 'nixos-unstable', 'nixpkgs', chdir: conf_dir)
+        else
+          run_confctl('swpins', 'update', chdir: conf_dir)
+        end
+      expect(res.success?).to be(true), "#{res.out}\n#{res.err}"
+      expect(channel_rev(conf_dir)).to eq(rev_a)
+
+      rev_b = create_repo_with_commit(dummy_repo, "B\n", 'dummy: B')
+
+      res = run_confctl(
+        'swpins', 'channel', 'update',
+        '--commit', '--no-changelog', '--no-editor',
+        'nixos-unstable', 'nixpkgs',
+        chdir: conf_dir
+      )
+      expect(res.success?).to be(true), "#{res.out}\n#{res.err}"
+      expect(channel_rev(conf_dir)).to eq(rev_b)
+
+      log_count = run_cmd('git', 'rev-list', '--count', 'HEAD', chdir: conf_dir).out.strip.to_i
+      expect(log_count).to eq(2)
+
+      res = run_confctl(
+        'swpins', 'channel', 'set',
+        '--commit', '--changelog', '--no-editor',
+        'nixos-unstable', 'nixpkgs', rev_a,
+        chdir: conf_dir
+      )
+      expect(res.success?).to be(true), "#{res.out}\n#{res.err}"
+      expect(channel_rev(conf_dir)).to eq(rev_a)
+
+      log_count = run_cmd('git', 'rev-list', '--count', 'HEAD', chdir: conf_dir).out.strip.to_i
+      expect(log_count).to eq(3)
+    end
+  end
+end

data/spec/generation/build_modes_spec.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'tmpdir'
+require 'fileutils'
+
+RSpec.describe 'generation modes' do
+  it 'preserves swpins and flakes generation modes and metadata' do
+    Dir.mktmpdir('confctl-generation-modes-') do |tmp|
+      Dir.chdir(tmp) do
+        require 'confctl'
+
+        allow(ConfCtl::GCRoot).to receive(:dir).and_return(File.join(ConfCtl::ConfDir.cache_dir, 'gcroots'))
+
+        host = 'example.test'
+        host_dir = File.join(ConfCtl::ConfDir.generation_dir, ConfCtl.safe_host_name(host))
+        FileUtils.mkdir_p(host_dir)
+
+        legacy_name = '2026-02-24--00-00-00'
+        legacy_dir = File.join(host_dir, legacy_name)
+        FileUtils.mkdir_p(legacy_dir)
+
+        legacy_data = {
+          'date' => '2026-02-24T12:34:56Z',
+          'toplevel' => '/nix/store/legacy-system',
+          'auto_rollback' => '/nix/store/legacy-auto-rollback.rb',
+          'swpins' => {
+            'nixpkgs' => {
+              'path' => '/nix/store/legacy-nixpkgs',
+              'spec' => {
+                'type' => 'git-rev',
+                'name' => 'nixpkgs',
+                'nix_options' => {
+                  'url' => 'https://example.com/nixpkgs',
+                  'fetchSubmodules' => false,
+                  'update' => {
+                    'auto' => false,
+                    'interval' => 0,
+                    'ref' => nil
+                  }
+                },
+                'state' => {
+                  'rev' => 'deadbeef'
+                }
+              }
+            }
+          }
+        }
+
+        File.write(File.join(legacy_dir, 'generation.json'), JSON.pretty_generate(legacy_data))
+
+        legacy_gen = ConfCtl::Generation::Build.new(host)
+        legacy_gen.load(legacy_name)
+        expect(legacy_gen.mode).to eq('swpins')
+
+        swpin_spec = ConfCtl::Swpins::Spec.for(:'git-rev').new(
+          'nixpkgs',
+          {
+            'url' => 'https://example.com/nixpkgs',
+            'fetchSubmodules' => false,
+            'update' => {
+              'auto' => false,
+              'interval' => 0,
+              'ref' => nil
+            }
+          },
+          {
+            'type' => 'git-rev',
+            'name' => 'nixpkgs',
+            'nix_options' => {
+              'url' => 'https://example.com/nixpkgs',
+              'fetchSubmodules' => false,
+              'update' => {
+                'auto' => false,
+                'interval' => 0,
+                'ref' => nil
+              }
+            },
+            'state' => {
+              'rev' => 'beadfeed'
+            }
+          }
+        )
+
+        swpins_gen = ConfCtl::Generation::Build.new(host)
+        swpins_gen.create(
+          '/nix/store/new-system',
+          '/nix/store/new-auto-rollback.rb',
+          { 'nixpkgs' => '/nix/store/new-nixpkgs' },
+          { 'nixpkgs' => swpin_spec },
+          date: Time.utc(2026, 2, 24, 13, 0, 0)
+        )
+        swpins_gen.save
+
+        swpins_list = ConfCtl::Generation::BuildList.new(host)
+        swpins_loaded = swpins_list[swpins_gen.name]
+        expect(swpins_loaded.mode).to eq('swpins')
+        expect(swpins_loaded.swpin_paths).to eq(swpins_gen.swpin_paths)
+
+        flakes_gen = ConfCtl::Generation::Build.new(host)
+        flakes_gen.create_flake(
+          '/nix/store/flake-system',
+          '/nix/store/flake-auto-rollback.rb',
+          inputs: { 'nixpkgs' => '/nix/store/flake-nixpkgs' },
+          inputs_info: {
+            'nixpkgs' => {
+              'input' => 'nixpkgs',
+              'url' => 'https://github.com/NixOS/nixpkgs',
+              'rev' => 'cafebabe',
+              'shortRev' => 'cafebabe',
+              'lastModified' => 0
+            }
+          },
+          date: Time.utc(2026, 2, 24, 14, 0, 0)
+        )
+        flakes_gen.save
+
+        flakes_list = ConfCtl::Generation::BuildList.new(host)
+        flakes_loaded = flakes_list[flakes_gen.name]
+        expect(flakes_loaded.mode).to eq('flakes')
+        expect(flakes_loaded.inputs).to eq(flakes_gen.inputs)
+        expect(flakes_loaded.swpin_specs).to be_empty
+
+        flakes_json = JSON.parse(File.read(File.join(flakes_loaded.dir, 'generation.json')))
+        expect(flakes_json).not_to have_key('swpins')
+
+        expect(swpins_list.find(swpins_loaded.toplevel, swpins_loaded.swpin_paths)).to be_truthy
+        expect(flakes_list.find(flakes_loaded.toplevel, flakes_loaded.inputs, mode: 'flakes')).to be_truthy
+      end
+    end
+  end
+end