fig 2.0.0.pre.alpha.4 → 2.0.0.pre.alpha.5

data/spec/repository_spec.rb

@@ -0,0 +1,117 @@
+# coding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'fig/application_configuration'
+require 'fig/command/options'
+require 'fig/file_not_found_error'
+require 'fig/logging'
+require 'fig/package_descriptor'
+require 'fig/repository'
+require 'fig/repository_error'
+require 'fig/statement/configuration'
+require 'fig/statement/path'
+
+def create_local_repository()
+  application_config = Fig::ApplicationConfiguration.new()
+  application_config.base_whitelisted_url = FIG_DOWNLOAD_URL
+  application_config.remote_download_url = FIG_DOWNLOAD_URL
+  application_config.remote_upload_url = FIG_UPLOAD_URL
+
+  parser = Fig::Parser.new(application_config, false)
+
+  repository = Fig::Repository.new(
+    application_config,
+    Fig::Command::Options.new,
+    Fig::OperatingSystem.new(nil),
+    FIG_HOME,
+    FIG_DOWNLOAD_URL,
+    FIG_UPLOAD_URL,
+    parser,
+    [],   # publish listeners
+  )
+  repository.update_if_missing
+
+  return repository
+end
+
+def generate_package_statements
+  parsed_name, parsed_value = Fig::Statement::Path.parse_name_value 'FOO=bar'
+  path_statement            =
+    Fig::Statement::Path.new(nil, nil, parsed_name, parsed_value)
+  configuration_statement   =
+    Fig::Statement::Configuration.new(
+      nil, nil, Fig::Package::DEFAULT_CONFIG, [path_statement]
+    )
+
+  package_statements = [configuration_statement]
+
+  return package_statements
+end
+
+describe 'Repository' do
+  before(:each) do
+    clean_up_test_environment
+    set_up_test_environment
+  end
+
+  it 'cleans a package from the repository' do
+    repository = create_local_repository
+
+    repository.list_packages.include?('foo/1.0.0').should be false
+
+    package_statements = generate_package_statements
+
+    descriptor = Fig::PackageDescriptor.new('foo', '1.0.0', nil)
+    repository.publish_package(package_statements, descriptor, false, nil, false)
+
+    repository.list_packages.include?('foo/1.0.0').should be true
+
+    repository.clean(descriptor)
+
+    repository.list_packages.include?('foo/1.0.0').should be false
+  end
+
+  describe 'handles errors while installing packages' do
+    it %q<that don't exist> do
+      repository = create_local_repository
+
+      repository.stub(:install_package) do
+        raise Fig::FileNotFoundError.new('test FileNotFoundError', 'fake path')
+      end
+      # Evil knowledge of implementation:
+      repository.instance_variable_set(:@updating_package_definition, true)
+
+      Fig::Logging.should_receive(:fatal).with(
+        /package.*package-name.*not found/i
+      )
+
+      descriptor = Fig::PackageDescriptor.new(
+        'package-name', 'package-version', nil
+      )
+      expect {
+        repository.get_package(descriptor)
+      }.to raise_error(Fig::RepositoryError)
+    end
+
+    it 'that have some sort of installation issue' do
+      repository = create_local_repository
+
+      exception_message = 'test StandardError'
+      repository.stub(:install_package) do
+        raise StandardError.new(exception_message)
+      end
+
+      Fig::Logging.should_receive(:fatal).with(
+        %r<install of package-name/package-version failed.*#{exception_message}>i
+      )
+
+      descriptor = Fig::PackageDescriptor.new(
+        'package-name', 'package-version', nil
+      )
+      expect {
+        repository.get_package(descriptor)
+      }.to raise_error(Fig::RepositoryError)
+    end
+  end
+end

data/spec/runtime_environment_spec.rb

@@ -0,0 +1,357 @@
+# coding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'fig/environment_variables/case_sensitive'
+require 'fig/package'
+require 'fig/package_descriptor'
+require 'fig/parser'
+require 'fig/runtime_environment'
+require 'fig/statement/command'
+require 'fig/statement/configuration'
+require 'fig/statement/retrieve'
+require 'fig/statement/set'
+
+DEPENDED_UPON_PACKAGE_NAME = 'depended_upon'
+
+def standard_package_version(name)
+  return "#{name}-version"
+end
+
+def new_example_package(environment, name, extra_statements, variable_value)
+  statements = extra_statements +
+      [
+        Fig::Statement::Configuration.new(
+          nil, nil, Fig::Package::DEFAULT_CONFIG, []
+        )
+      ]
+
+  package =
+    Fig::Package.new(
+      name,
+      standard_package_version(name),
+      nil,
+      nil,
+      "#{name}-directory",
+      "#{name}-directory",
+      statements,
+      false,
+    )
+
+  environment.register_package(package)
+
+  # Kind of a cheat: we're creating a "set" statement that isn't in a "config"
+  # block and then shoving it through the RuntimeEnvironment directly.
+  set_statement = new_example_set_statement(name, variable_value)
+  environment.apply_config_statement(package, set_statement, nil, 0)
+
+  return package
+end
+
+def new_example_environment(variable_value = 'whatever', retrieve_vars = {})
+  maintainer_double = double('working directory maintainer')
+  maintainer_double.stub(:switch_to_package_version)
+  maintainer_double.stub(:retrieve)
+  environment =
+    Fig::RuntimeEnvironment.new(
+      nil,
+      Fig::Parser.new(nil, false),
+      false,
+      Fig::EnvironmentVariables::CaseSensitive.new({'FOO' => 'bar'}),
+      maintainer_double
+    )
+
+  if retrieve_vars
+    retrieve_vars.each do |name, path|
+      tokenized_path = Fig::Statement::Retrieve.tokenize_path path
+      environment.add_retrieve(
+        Fig::Statement::Retrieve.new(nil, nil, name, tokenized_path)
+      )
+    end
+  end
+
+  depended_upon_package_version =
+    standard_package_version(DEPENDED_UPON_PACKAGE_NAME)
+  new_example_package(
+    environment, DEPENDED_UPON_PACKAGE_NAME, [], variable_value
+  )
+
+  %w< one two three >.each do
+    |package_name|
+
+    extra_statements = [
+      Fig::Statement::Include.new(
+        nil,
+        nil,
+        Fig::PackageDescriptor.parse(
+          "#{DEPENDED_UPON_PACKAGE_NAME}/#{depended_upon_package_version}"
+        ),
+        nil,
+        package_name
+      )
+    ]
+    new_example_package(
+      environment, package_name, extra_statements, variable_value
+    )
+  end
+
+  command = Fig::Statement::Command.new(
+    nil,
+    nil,
+    [
+      Fig::Statement::Command.validate_and_process_escapes_in_argument(
+        'echo foo'
+      )
+    ]
+  )
+  environment.register_package(
+    Fig::Package.new(
+      'has_command', 'version', nil, nil, 'directory', 'directory',
+      [
+        Fig::Statement::Configuration.new(
+          nil,
+          nil,
+          Fig::Package::DEFAULT_CONFIG,
+          [command]
+        )
+      ],
+      false,
+    )
+  )
+
+  return environment
+end
+
+def new_example_set_statement(name, value)
+  parsed_name, parsed_value =
+    Fig::Statement::Set.parse_name_value("WHATEVER_#{name.upcase}=#{value}") do
+      |description|
+
+      raise StandardError.new(
+        %Q<Never should have gotten here.  Description: "#{description}">
+      )
+    end
+
+  return Fig::Statement::Set.new(nil, nil, parsed_name, parsed_value)
+end
+
+def substitute_command(command)
+  environment = new_example_environment
+  base_package =
+    Fig::Package.new(
+      'test-package',
+      'test-version',
+      nil,
+      nil,
+      'test-directory',
+      'test-directory',
+      [],
+      false,
+    )
+
+  tokenized_command = command.map {
+    |argument|
+
+    Fig::Statement::Command.validate_and_process_escapes_in_argument(argument) {
+      |error_description| raise error_description
+    }
+  }
+
+  substituted_command = nil
+  environment.expand_command_line(base_package, nil, nil, tokenized_command) {
+    |command_line|
+    substituted_command = command_line
+  }
+
+  return substituted_command
+end
+
+def generate_shell_variable_expansions
+  variable_arguments = %w<WHATEVER_ONE WHATEVER_TWO WHATEVER_THREE>
+  return variable_arguments.map do |var_arg|
+    Fig::OperatingSystem.wrap_variable_name_with_shell_expansion(var_arg)
+  end
+end
+
+def substitute_variable(variable_value, retrieve_vars = {})
+  environment = new_example_environment(variable_value, retrieve_vars)
+  base_package =
+    Fig::Package.new(
+      'test-package',
+      'test-version',
+      nil,
+      nil,
+      'test-directory',
+      'test-directory',
+      [],
+      false,
+    )
+
+  output = nil
+  variables = generate_shell_variable_expansions
+  environment.expand_command_line(base_package, nil, nil, []) {
+    # No space between the closing curly of an interpolation and the double
+    # ampersand due to the way that echo works on MS Windows.
+    output =
+      %x[echo #{variables[0]}&& echo #{variables[1]}&& echo #{variables[2]}]
+  }
+
+  return output
+end
+
+describe 'RuntimeEnvironment' do
+  before(:all) do
+    set_up_test_environment()
+  end
+
+  it 'can hand back a variable' do
+    environment = new_example_environment
+
+    environment['FOO'].should == 'bar'
+  end
+
+  describe 'package name substitution in commands' do
+    it 'can replace bare names' do
+      substituted_command = substitute_command %w< @one >
+
+      substituted_command.should == %w< one-directory >
+    end
+
+    it 'can replace prefixed names' do
+      substituted_command = substitute_command %w< something@one >
+
+      substituted_command.should == %w< somethingone-directory >
+    end
+
+    it 'can replace multiple names in a single argument' do
+      substituted_command = substitute_command %w< @one@two@three >
+
+      substituted_command.should == %w< one-directorytwo-directorythree-directory >
+    end
+
+    it 'can replace names in multiple arguments' do
+      substituted_command = substitute_command %w< @one @two >
+
+      substituted_command.should == %w< one-directory two-directory >
+    end
+
+    it 'can handle simple escaped names' do
+      substituted_command = substitute_command %w< \@one\@two >
+
+      substituted_command.should == %w< @one@two >
+    end
+
+    it 'can replace name after an escaped name' do
+      substituted_command = substitute_command %w< \@one@two >
+
+      substituted_command.should == %w< @onetwo-directory >
+    end
+
+    it 'can handle escaped backslash' do
+      substituted_command = substitute_command %w< bar\\\\foo >
+
+      substituted_command.should == %w< bar\\foo >
+    end
+
+    it 'can handle escaped backslash in front of @' do
+      substituted_command = substitute_command %w< bar\\\\@one >
+
+      substituted_command.should == %w< bar\\one-directory >
+    end
+
+    it 'can handle escaped backslash in front of escaped @' do
+      substituted_command = substitute_command %w< bar\\\\\\@one >
+
+      substituted_command.should == %w< bar\\@one >
+    end
+
+    it 'complains about bad escapes' do
+      expect {
+        # Grrr, Ruby syntax: that's three backslashes followed by "f"
+        substitute_command %w< bar\\\\\\foo >
+      }.to raise_error(/bad escape/i)
+    end
+  end
+
+  describe 'package name substitution in variables' do
+    it 'does basic @ substitution' do
+      output = substitute_variable('@/foobie')
+
+      output.should ==
+        "one-directory/foobie\ntwo-directory/foobie\nthree-directory/foobie\n"
+    end
+
+    it 'does @ escaping' do
+      output = substitute_variable('\\@@/foobie')
+
+      output.should ==
+        "@one-directory/foobie\n@two-directory/foobie\n@three-directory/foobie\n"
+    end
+
+    it 'does retrieve variables [package] substitution' do
+      retrieve_vars = {
+        'WHATEVER_ONE' => 'foo.[package].bar.[package].baz',
+        'WHATEVER_TWO' => 'foo.[package].bar.[package].baz',
+        'WHATEVER_THREE' => 'foo.[package].bar.[package].baz'
+      }
+      output = substitute_variable(FIG_FILE_GUARANTEED_TO_EXIST, retrieve_vars)
+
+      destination = File.basename(FIG_FILE_GUARANTEED_TO_EXIST)
+      output.should ==
+        "foo.one.bar.one.baz/#{destination}\nfoo.two.bar.two.baz/#{destination}\nfoo.three.bar.three.baz/#{destination}\n"
+    end
+
+    it 'truncates before //' do
+      if FIG_FILE_GUARANTEED_TO_EXIST !~
+          %r<
+            \A
+            (.+ [^/]) # Maximally at least two charcters not ending in a slash.
+            (
+              (?: / [^/]+ ){2} # Slash followed by maximally non-slash, twice.
+            )
+            \z
+          >x
+        fail "Test assumes that FIG_FILE_GUARANTEED_TO_EXIST (#{FIG_FILE_GUARANTEED_TO_EXIST}) has at least two parent directories."
+      end
+      base_path = $1
+      to_be_preserved = $2 # Note that this will have a leading slash...
+
+      # ... which means that this will have two slashes in it.
+      mangled_path = "#{base_path}/#{to_be_preserved}"
+
+      retrieve_vars = {
+        # Just checking that double slashes aren't mangled in the retrieves.
+        'WHATEVER_ONE'   => 'foo.[package].//./bar.[package].baz',
+        # No WHATEVER_TWO here means that the value should pass through
+        # unmolested.
+        'WHATEVER_THREE' => 'phoo.//.bhar'
+      }
+      output = substitute_variable(mangled_path, retrieve_vars)
+
+      output.should == \
+        "foo.one.//./bar.one.baz#{to_be_preserved}\n" + # WHATEVER_ONE
+        "#{mangled_path}\n"                           + # WHATEVER_TWO
+        "phoo.//.bhar#{to_be_preserved}\n"              # WHATEVER_THREE
+    end
+  end
+
+  describe 'command expansion' do
+    it 'issues an error when attempting to expand a command statement from a config which contains no command' do
+      environment = new_example_environment(FIG_FILE_GUARANTEED_TO_EXIST)
+      expect {
+        environment.expand_command_statement_from_config(
+          nil, nil, Fig::PackageDescriptor.new('one', nil, nil), nil
+        )
+      }.to raise_error(Fig::UserInputError)
+    end
+
+    it 'expands a command statement successfully' do
+      environment = new_example_environment(FIG_FILE_GUARANTEED_TO_EXIST)
+      received_command = nil
+      environment.expand_command_statement_from_config(
+        nil, nil, Fig::PackageDescriptor.new('has_command', nil, nil), []
+      ) { |command| received_command = command }
+      received_command.should == ['echo foo']
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'fig/spec_utils.rb'

data/spec/split_repo_url_spec.rb

@@ -0,0 +1,190 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'fileutils'
+require 'tmpdir'
+
+require 'fig/command/package_loader'
+require 'fig/operating_system'
+require 'fig/repository'
+
+describe "Split repository URL behavior" do
+  context 'starting with a clean home and remote repository' do
+    before(:each) do
+      clean_up_test_environment
+      set_up_test_environment
+      cleanup_home_and_remote
+    end
+
+    def create_test_repos(unified: false)
+      # Name separate download and upload directories
+      download_dir = File.join(FIG_SPEC_BASE_DIRECTORY, 'download-repo')
+      upload_dir = File.join(FIG_SPEC_BASE_DIRECTORY, 'upload-repo')
+
+      # Clean up any existing directories
+      FileUtils.rm_rf(download_dir)
+      FileUtils.rm_rf(upload_dir)
+
+      # Create the "repositories" based on whether we want unified or not
+      FileUtils.mkdir_p(upload_dir)
+      FileUtils.mkdir_p(File.join(upload_dir, Fig::Repository::METADATA_SUBDIRECTORY))
+
+      if unified
+        FileUtils.ln_s(upload_dir, download_dir)
+      else
+        FileUtils.mkdir_p(download_dir)
+        FileUtils.mkdir_p(File.join(download_dir, Fig::Repository::METADATA_SUBDIRECTORY))
+      end
+
+      return download_dir, upload_dir
+    end
+
+    it "(distinct repos) publishes to upload URL and downloads from download URL" do
+      # Create separate repos
+      download_dir, upload_dir = create_test_repos
+      download_url = "file://#{download_dir}"
+      upload_url = "file://#{upload_dir}"
+
+      # Set up environment for this test
+      ENV['FIG_DOWNLOAD_URL'] = download_url
+      ENV['FIG_UPLOAD_URL'] = upload_url
+
+      # Create a simple package
+      input = <<-END
+        config default
+          set FOO=BAR
+        end
+      END
+
+      # Create a package with publish-only
+      out, err, exit_code = 
+        fig(%w<--publish simple/1.2.3>, input, :no_raise_on_error => true)
+      exit_code.should == 0
+
+      # Check that package exists in upload repo but not in download repo
+      upload_path = File.join(upload_dir, 'simple', '1.2.3', Fig::Repository::PACKAGE_FILE_IN_REPO)
+      download_path = File.join(download_dir, 'simple', '1.2.3', Fig::Repository::PACKAGE_FILE_IN_REPO)
+
+      File.exist?(upload_path).should be true
+      File.exist?(download_path).should be false
+    end
+
+    it "(unified repos) publishes to upload URL and downloads from download URL" do
+      # Create separate repos
+      download_dir, upload_dir = create_test_repos(unified: true)
+      download_url = "file://#{download_dir}"
+      upload_url = "file://#{upload_dir}"
+
+      # Set up environment for this test
+      ENV['FIG_DOWNLOAD_URL'] = download_url
+      ENV['FIG_UPLOAD_URL'] = upload_url
+
+      download_url.should_not == upload_url
+      FileTest.symlink?(download_dir).should be true
+      FileTest.identical?(upload_dir, download_dir)
+
+      # Create a simple package
+      input = <<-END
+        config default
+          set FOO=BAR
+        end
+      END
+
+      # Create a package with publish-only
+      out, err, exit_code = 
+        fig(%w<--publish simple/1.2.3>, input, :no_raise_on_error => true)
+      exit_code.should == 0
+
+      # Check that package exists in upload repo AND in download repo
+      upload_path = File.join(upload_dir, 'simple', '1.2.3', Fig::Repository::PACKAGE_FILE_IN_REPO)
+      download_path = File.join(download_dir, 'simple', '1.2.3', Fig::Repository::PACKAGE_FILE_IN_REPO)
+
+      File.exist?(upload_path).should be true
+      File.exist?(download_path).should be true
+    end
+    it "warns when FIG_REMOTE_URL is set alongside the new URLs" do
+      # Set up conflicting environment
+      ENV['FIG_REMOTE_URL'] = "file:///some/path"
+      ENV['FIG_DOWNLOAD_URL'] = "file:///download/path"
+      ENV['FIG_UPLOAD_URL'] = "file:///upload/path"
+
+      # We need to mock the $stderr output since that's where the warning goes
+      # Capture original stderr and redirect to a StringIO
+      original_stderr = $stderr
+      $stderr = StringIO.new
+
+      # Create a minimal default.fig file for the test to work
+      File.open('default.fig', 'w') { |f| f.puts "config default\nend" }
+
+      # Use Fig::FigRC directly to trigger the warning
+      Fig::FigRC.find(nil, ENV['FIG_DOWNLOAD_URL'], ENV['FIG_UPLOAD_URL'],
+                    Fig::OperatingSystem.new(false), 
+                    FIG_HOME)
+
+      # Get the captured output and restore stderr
+      err_output = $stderr.string
+      $stderr = original_stderr
+
+      # Check that the warning was emitted
+      err_output.should =~ /WARNING: FIG_REMOTE_URL is set but will be ignored/
+
+      # Clean up
+      File.unlink('default.fig') if File.exist?('default.fig')
+    end
+
+    it "fails when FIG_REMOTE_URL is set but new URLs are missing" do
+      # Set up invalid environment
+      ENV['FIG_REMOTE_URL'] = "file:///some/path"
+      ENV.delete('FIG_DOWNLOAD_URL')
+      ENV.delete('FIG_UPLOAD_URL')
+
+      # Create a minimal default.fig file for the test to work
+      File.open('default.fig', 'w') { |f| f.puts "config default\nend" }
+
+      # Try to use fig with remote operation, should get error
+      out, err, exit_code = fig(%w<--update>, :no_raise_on_error => true)
+
+      # Should fail with clear error message
+      exit_code.should_not == 0
+      err.should =~ /FIG_REMOTE_URL is set but FIG_DOWNLOAD_URL and\/or FIG_UPLOAD_URL are missing/
+
+      # Clean up
+      File.unlink('default.fig') if File.exist?('default.fig')
+    end
+
+    it "fails with helpful message when required URL is missing" do
+      # Make sure we have no URLs set
+      ENV.delete('FIG_REMOTE_URL')
+      ENV.delete('FIG_DOWNLOAD_URL')
+      ENV.delete('FIG_UPLOAD_URL')
+
+      # Publishing without upload URL
+      input = <<-END
+        config default
+          set FOO=BAR
+        end
+      END
+
+      out, err, exit_code = fig(%w<--publish simple/1.2.3>, input, :no_raise_on_error => true)
+      exit_code.should_not == 0
+      err.should =~ /Must set FIG_UPLOAD_URL/
+
+      # Consuming without download URL
+      out, err, exit_code = fig(%w<--update>, :no_raise_on_error => true)
+      exit_code.should_not == 0
+      err.should =~ /Must set FIG_DOWNLOAD_URL/
+    end
+  end
+
+  after(:all) do
+    # Clean up and restore environment
+    download_dir = File.join(FIG_SPEC_BASE_DIRECTORY, 'download-repo')
+    upload_dir = File.join(FIG_SPEC_BASE_DIRECTORY, 'upload-repo')
+    FileUtils.rm_rf(download_dir) if Dir.exist?(download_dir)
+    FileUtils.rm_rf(upload_dir) if Dir.exist?(upload_dir)
+
+    # Restore environment variables to default test values
+    ENV['FIG_DOWNLOAD_URL'] = FIG_DOWNLOAD_URL
+    ENV['FIG_UPLOAD_URL'] = FIG_UPLOAD_URL
+    ENV.delete('FIG_REMOTE_URL')
+  end
+end