biopsy 0.1.0.alpha

data/test/helper.rb

@@ -0,0 +1,187 @@
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start
+
+require 'test/unit'
+begin; require 'turn/autorun'; rescue LoadError; end
+require 'shoulda-context'
+require 'biopsy'
+
+Turn.config.format = :pretty
+Turn.config.trace = 10
+
+Biopsy::Settings.instance.set_defaults
+
+# Helper class provides methods for setting up test data.
+class Helper
+
+  require 'fileutils'
+
+  attr_reader :tmp_dir
+  attr_reader :target_dir
+  attr_reader :domain_dir
+  attr_reader :domain_path
+  attr_reader :target_path
+  attr_reader :objective_dir
+  attr_reader :objective_path
+
+  def cleanup
+    self.instance_variables.each do |ivar|
+      if ivar =~ /_dir/
+        dir = self.instance_variable_get(ivar)
+        FileUtils.rm_rf dir if File.exists? dir
+      end
+    end
+  end
+
+  # Create a tmp directory for test data
+  def setup_tmp_dir
+    @tmp_dir = File.expand_path('.tmp')
+    Dir.mkdir @tmp_dir
+  end
+
+  # Return a hash of valid target data
+  def target_data
+    {
+      :input_files => {
+        :in => 'input.txt'
+      },
+      :output_files => {
+        :params => 'output.txt'
+      },
+      :parameter_ranges => {
+        :a => (-40..40).step(2).to_a,
+        :b => (0..100).step(2).to_a,
+        :c => (-50..50).to_a
+      },
+      :constructor_path => 'test_constructor.rb'
+    }
+  end
+
+  # Setup the directory for target
+  def setup_target
+    @target_dir = File.join(@tmp_dir, 'targets')
+    Dir.mkdir @target_dir
+    Biopsy::Settings.instance.target_dir = [@target_dir]
+  end
+
+  # Create a valid target definition in the target dir
+  def create_valid_target
+    data = self.target_data
+    name = 'test_target'
+    @target_path = File.join(@target_dir, name + '.yml')
+    self.yaml_dump data, @target_path
+    File.open(File.join(@target_dir, data[:constructor_path]), 'w') do |f|
+      f.puts %Q{
+class TestConstructor
+
+  require 'yaml'
+
+  def run(params)
+    File.open('output.txt', 'w') do |f|
+      f.puts(params.to_yaml)
+    end
+    { :params => File.expand_path('output.txt') }
+  end
+
+end
+      }
+    end
+    name
+  end
+
+  # Return a hash of valid domain data
+  def domain_data
+    {
+      :input_filetypes => [
+        {
+          :n => 1,
+          :allowed_extensions => [
+            '.txt'
+          ]
+        }
+      ],
+      :output_filetypes => [
+        {
+          :n => 1,
+          :allowed_extensions => [
+            '.txt'
+          ]
+        }
+      ],
+      :objectives => [
+        'test1', 'test2'
+      ]
+    }
+  end
+
+  def setup_domain
+    @domain_dir = File.join(@tmp_dir, 'domains')
+    Dir.mkdir @domain_dir
+    Biopsy::Settings.instance.domain_dir = [@domain_dir]
+  end
+
+  def create_valid_domain
+    data = domain_data
+    name = 'test_domain'
+    @domain_path = File.join(@domain_dir, name + '.yml')
+    self.yaml_dump data, @domain_path
+    name
+  end
+
+  def setup_objective
+    @objective_dir = File.join(@tmp_dir, 'objectives')
+    Dir.mkdir @objective_dir
+    Biopsy::Settings.instance.objectives_dir = [@objective_dir]
+  end
+
+  def create_valid_objective
+    objective = %Q{
+class TestObjective < Biopsy::ObjectiveFunction
+
+  require 'yaml'
+
+  def initialize
+    @optimum = 0
+    @max = 0
+    @weighting = 1
+  end
+
+  def run(input, threads)
+    file = input[:params]
+    input = YAML::load_file(file)
+    a = input[:a].to_i
+    b = input[:b].to_i
+    c = input[:c].to_i
+    value = - Math.sqrt((a-4)**2) - Math.sqrt((b-4)**2) - Math.sqrt((c-4)**2)
+    {
+      :optimum => @optimum,
+      :max => @max,
+      :weighting => @weighting,
+      :result => value
+    }
+  end
+end
+    }
+    @objective_path = File.join(@objective_dir, 'test_objective.rb')
+    self.string_dump objective, @objective_path
+  end
+
+  # Dump +:object+ as YAML to +:file+
+  def yaml_dump object, file
+    self.string_dump object.to_yaml, file
+  end
+
+  # Dump +:string+ to +:file+
+  def string_dump string, file
+    File.open(file, 'w') do |f|
+      f.puts string
+    end
+  end
+
+end

data/test/test_domain.rb

@@ -0,0 +1,61 @@
+require 'helper'
+
+class TestDomain < Test::Unit::TestCase
+
+  require 'fileutils'
+
+  context "Domain" do
+
+    setup do
+      @h = Helper.new
+      @h.setup_tmp_dir
+
+      # we need a domain
+      @h.setup_domain
+      domain_name = @h.create_valid_domain
+      @domain = Biopsy::Domain.new domain_name
+    end
+
+    teardown do
+      @h.cleanup
+    end
+
+    should "be able to find the current domain" do
+      assert_equal 'test_domain', @domain.get_current_domain
+    end
+
+    should "be able to find a definition" do
+      assert_equal @h.domain_path, @domain.locate_definition('test_domain')
+    end
+
+    should "fail to find a non-existent definition" do
+      assert_equal nil, @domain.locate_definition('fake_filename')
+    end
+
+    should "reject any invalid config" do
+      # generate all trivial invalid configs
+      @h.domain_data.keys.each do |key|
+        d = @h.domain_data.clone
+        d.delete key
+        filepath = File.join(@h.domain_dir, 'broken_thing.yml')
+        File.open(filepath, 'w') do |f|
+          f.puts d.to_yaml
+        end
+
+        assert_raise Biopsy::DomainLoadError do
+          @domain.load_by_name 'broken_thing'
+        end
+
+        File.delete filepath if File.exists? filepath
+      end
+    end
+    
+    should "write a template that can be loaded as a valid definition" do
+      @domain.write_template File.join(@h.domain_dir, 'template.yml')
+      @domain.load_by_name 'template'
+      assert_equal ['objective1', 'objective2'], @domain.objectives
+    end
+
+  end # Domain context
+
+end # TestDomain

data/test/test_experiment.rb

@@ -0,0 +1,84 @@
+require 'helper'
+
+class TestExperiment < Test::Unit::TestCase
+
+  context "Experiment" do
+
+    setup do
+      @h = Helper.new
+      @h.setup_tmp_dir
+
+      # we need a domain
+      @h.setup_domain
+      domain_name = @h.create_valid_domain
+      @domain = Biopsy::Domain.new domain_name
+
+      # and a target
+      @h.setup_target
+      target_name = @h.create_valid_target
+      @target = Biopsy::Target.new @domain
+      @target.load_by_name target_name
+
+      # and an objective
+      @h.setup_objective
+      @h.create_valid_objective
+    end
+
+    teardown do
+      @h.cleanup
+    end
+
+    should "fail to init when passed a non existent target" do
+      assert_raise Biopsy::TargetLoadError do
+        Biopsy::Experiment.new('fake_target', 'test_domain')
+      end
+    end
+
+    should "fail to init when passed a non existent domain" do
+      assert_raise Biopsy::DomainLoadError do
+        Biopsy::Experiment.new('test_target', 'fake_domain')
+      end
+    end
+
+    should "be able to select a valid point from the parameter space" do
+      e = Biopsy::Experiment.new('test_target', 'test_domain')
+      start_point = e.random_start_point
+      start_point.each_pair do |param, value|
+        assert @h.target_data[:parameter_ranges][param].include? value
+      end
+    end
+
+    should "be able to select a starting point" do
+      e = Biopsy::Experiment.new('test_target', 'test_domain')
+      start_point = e.start
+      start_point.each_pair do |param, value|
+        assert @h.target_data[:parameter_ranges][param].include? value
+      end
+    end
+
+    should "respect user's choice of starting point" do
+      s = {:a => 2, :b => 4}
+      e = Biopsy::Experiment.new('test_target', 'test_domain', s)
+      assert_equal s, e.start
+    end
+
+    should "automatically select an optimiser if none is specified" do
+      e = Biopsy::Experiment.new('test_target', 'test_domain')
+      assert e.algorithm.kind_of? Biopsy::TabuSearch
+    end
+
+    should "return an optimal set of parameters and score when run" do
+      # Kernel.srand 123
+      e = Biopsy::Experiment.new('test_target', 'test_domain')
+      known_best = {
+        :a => 4,
+        :b => 4,
+        :c => 4
+      }
+      best_found = e.run[:parameters]
+      assert_equal known_best, best_found
+    end
+
+  end # Experiment context
+
+end # TestExperiment

data/test/test_file.rb

@@ -0,0 +1,20 @@
+require 'helper'
+
+class TestFile < Test::Unit::TestCase
+
+  context "File" do
+
+    should "return full path to executable in $PATH" do
+      filename = 'testfile'
+      path = ENV['PATH'].split(File::PATH_SEPARATOR).first
+      filepath = File.join(path, filename)
+      File.open(filepath, 'w') do |f|
+        f.puts 'test'
+      end
+      File.chmod(0777, filepath)
+      assert_equal filepath, File.which(filename)
+    end
+
+  end # File context
+
+end # TestFile

data/test/test_hash.rb

@@ -0,0 +1,55 @@
+require 'helper'
+
+class TestHash < Test::Unit::TestCase
+
+  require 'pp'
+
+  context "Hash" do
+
+    setup do
+      @a = {
+        'a' => {
+          'b' => 1,
+          'c' => {
+            'd' => [2, 3, 4]
+          }
+        }
+      }
+    end
+
+    should "recursively symbolise keys" do
+      b = {
+        :a => {
+          :b => 1,
+          :c => {
+            :d => [2, 3, 4]
+          }
+        }
+      }
+      assert @a != b, "hash with string keys not equal to hash with symbol keys"
+      assert_equal @a.deep_symbolize, b, "symbolized string key hash equals symbol key hash"
+    end
+
+    should "recursively merge hashes" do
+      b = {
+        'a' => {
+          'c' => {
+            'e' => 'new value'
+          }
+        }
+      }
+      c = {
+        'a' => {
+          'b' => 1,
+          'c' => {
+            'd' => [2, 3, 4],
+            'e' => 'new value'
+          }
+        }
+      }
+      assert_equal @a.deep_merge(b), c
+    end
+
+  end # Hash context
+
+end # TestHash

data/test/test_objective_handler.rb

@@ -0,0 +1,99 @@
+require 'helper'
+
+class TestObjectiveHandler < Test::Unit::TestCase
+
+  context "ObjectiveHandler" do
+
+    setup do
+      @h = Helper.new
+      @h.setup_tmp_dir
+
+      # we need a domain
+      @h.setup_domain
+      domain_name = @h.create_valid_domain
+      @domain = Biopsy::Domain.new domain_name
+
+      # and a target
+      @h.setup_target
+      target_name = @h.create_valid_target
+      @target = Biopsy::Target.new @domain
+      @target.load_by_name target_name
+      
+      # and an objective
+      @h.setup_objective
+      objective_name = @h.create_valid_objective
+    end
+
+    teardown do
+      @h.cleanup
+    end
+
+    should "return loaded objectives on init" do
+      oh = Biopsy::ObjectiveHandler.new @domain, @target
+      refute oh.objectives.empty?
+    end
+
+    should "prefer local objective list to full set" do
+      Dir.chdir(@h.objective_dir) do
+        objective = %{
+          class AnotherObjective < Biopsy::ObjectiveFunction
+            def run(input, threads)
+              10
+            end
+          end
+        }
+        File.open('another_objective.rb', 'w') do |f|
+          f.puts objective
+        end
+        File.open('objectives.txt', 'w') do |f|
+          f.puts 'another_objective'
+        end
+      end
+      oh = Biopsy::ObjectiveHandler.new @domain, @target
+      assert_equal 1, oh.objectives.length
+      assert_equal 'AnotherObjective', oh.objectives.keys.first
+    end
+
+    should "run an objective and return the result" do
+      oh = Biopsy::ObjectiveHandler.new @domain, @target
+      values = {
+        :a => 4,
+        :b => 4,
+        :c => 4
+      }
+      file = File.expand_path(File.join(@h.tmp_dir, 'output.txt'))
+      File.open(file, 'w') do |f|
+        f.puts values.to_yaml
+      end
+      result = oh.run_for_output({:params => file}, 0, 1, allresults=true)
+      assert_equal 0, result[:results]["TestObjective"][:result]
+    end
+
+    should "perform euclidean distance dimension reduction" do
+      oh = Biopsy::ObjectiveHandler.new @domain, @target
+      results = {
+        :a => {
+          :optimum => 100,
+          :weighting => 1,
+          :result => 49,
+          :max => 100
+        },
+        :b => {
+          :optimum => 1,
+          :weighting => 1,
+          :result => 62,
+          :max => 100
+        },
+        :c => {
+          :optimum => 0,
+          :weighting => 1,
+          :result => 33,
+          :max => 66
+        }
+      }
+      assert_equal 0.47140452079103173, oh.dimension_reduce(results)
+    end
+
+  end # Experiment context
+
+end # TestExperiment

data/test/test_settings.rb

@@ -0,0 +1,74 @@
+require 'helper'
+
+class TestSettings < Test::Unit::TestCase
+
+  context "Settings" do
+
+    setup do
+      @data = {
+        :domain => 'test_domain',
+        :objectives_dir => './objectives',
+      }
+      @config_file = File.expand_path 'testconfig.yml'
+      @settings = Biopsy::Settings.instance
+      File.open(@config_file, 'w') do |f|
+        f.puts @data.to_yaml
+      end
+      @settings.load @config_file
+    end
+
+    teardown do
+      File.delete @config_file if File.exists? @config_file
+    end
+
+    should "load the specified config file" do
+      assert @settings.domain == @data[:domain]
+      assert @settings.objectives_dir == @data[:objectives_dir]
+    end
+
+    should "complain about malformed config file" do
+      # write non-YAML data to file
+      File.open(@config_file, 'w') do |f|
+        f.puts @test
+      end
+      assert_raise RuntimeError do
+        @settings.load @config_file
+      end
+    end
+
+    should "be able to save settings and load them identically" do
+      @settings.save @config_file
+      @settings.load @config_file
+      @data.each_pair do |key, value|
+        varname = "@#{key.to_s}".to_sym
+        assert_equal value, @settings.instance_variable_get(varname)
+      end
+    end
+
+    should "be a singleton" do
+      assert_equal @settings.object_id, Biopsy::Settings.instance.object_id
+    end
+
+    should "make loaded settings available as methods" do
+      assert @settings.domain == @data[:domain], 'domain key not loaded as method'
+      assert @settings.objectives_dir == @data[:objectives_dir], 'objectives_dir key not loaded as method'
+    end
+
+    should "produce a YAML string representation" do
+      s = @settings.to_s
+      h = YAML.load(s)
+      @data.each_pair do |key, value|
+        varname = "@#{key.to_s}".to_sym
+        assert_equal value, @settings.instance_variable_get(varname)
+      end
+    end
+
+    should "error when a non-existent config is requested" do
+      assert_raise Biopsy::SettingsError do
+        @settings.locate_config :fake_key, 'blah'
+      end
+    end
+
+  end # RunHandler context
+
+end # TestRunHandler

data/test/test_string.rb

@@ -0,0 +1,14 @@
+require 'helper'
+
+class TestString < Test::Unit::TestCase
+
+  context "String" do
+
+    should "return CamelCase version of snake_case" do
+      assert_equal "snake_case".camelize, "SnakeCase"
+      assert_equal "a_b_c_d".camelize, "ABCD"
+    end
+
+  end # String context
+
+end # TestString

data/test/test_target.rb

@@ -0,0 +1,89 @@
+require 'helper'
+
+class TestTarget < Test::Unit::TestCase
+
+  require 'fileutils'
+
+  context "Target" do
+
+    setup do
+      @h = Helper.new
+      @h.setup_tmp_dir
+
+      # we need a domain
+      @h.setup_domain
+      domain_name = @h.create_valid_domain
+      @domain = Biopsy::Domain.new domain_name
+
+      # and a target
+      @h.setup_target
+      target_name = @h.create_valid_target
+      @target = Biopsy::Target.new @domain
+      @target.load_by_name target_name
+    end
+
+    teardown do
+      @h.cleanup
+    end
+
+    should "be able to find an existing definition" do
+      filepath = File.join(@h.target_dir, 'fake_thing.yml')
+      File.open(filepath, 'w') do |f|
+        f.puts "this doesn't matter"
+      end
+
+      assert_equal filepath, @target.locate_definition('fake_thing')
+    end
+
+    should "fail to find a non-existent definition" do
+      assert_equal nil, @target.locate_definition('not_real')
+    end
+
+    should "reject any invalid config" do
+      # generate all trivial invalid configs
+      @h.target_data.keys.each do |key|
+        d = @h.target_data.clone
+        d.delete key
+        filepath = File.join(@h.target_dir, 'broken_thing.yml')
+        File.open(filepath, 'w') do |f|
+          f.puts d.to_yaml
+        end
+
+        assert_raise Biopsy::TargetLoadError do
+          @target.load_by_name 'broken_thing'
+        end
+
+        File.delete filepath if File.exists? filepath
+      end
+    end
+
+    should "reject a config that doesn't match the domain spec" do
+      d = @h.target_data
+      d[:input_files][:fake] = 'another.file'
+      assert @target.validate_config(d).length > 0
+    end
+
+    should "be able to store a loaded config file" do
+      config = YAML::load_file(@h.target_path).deep_symbolize
+      @target.store_config config
+      @h.target_data.each_pair do |key, value|
+        assert_equal value, @target.instance_variable_get('@' + key.to_s)
+      end
+    end
+
+    should "recognise a malformed or missing constructor" do
+      config = YAML::load_file(@h.target_path).deep_symbolize
+      @target.store_config config
+
+      assert !@target.check_constructor, "missing constructor is invalid"
+
+      File.open(@h.target_data[:constructor_path], 'w') do |f|
+        f.puts '[x**2 for x in range(10)]' # python :)
+      end
+      assert !@target.check_constructor, "invalid ruby is invalid"
+      File.delete @h.target_data[:constructor_path]
+    end
+
+  end # Target context
+
+end # TestTarget context