lazar 0.0.1

data/test/data/wrong_dataset.csv

@@ -0,0 +1,8 @@
+SMILES,Wrong Dataset
+Tost,0
+Is,1
+A,0
+Wrong,1
+Dataset,0
+Entry,1
+O[C@@H]8[C@@H](O)[C@@H]1O[C@H](CO)[C@H]8O[C@H]7O[C@H](CO)[C@@H](O[C@H]6O[C@H](CO)[C@@H](O[C@H]5O[C@H](CO)[C@@H](O[C@H]4O[C@H](CO)[C@@H](O[C@H]3O[C@H](CO)[C@@H](O[C@H]2O[C@H](CO)[C@@H](O1)[C@H](O)[C@H]2O)[C@H](O)[C@H]3O)[C@H](O)[C@H]4O)[C@H](O)[C@H]5O)[C, 0

data/test/dataset-long.rb

@@ -0,0 +1,117 @@
+require_relative "setup.rb"
+
+class DatasetLongTest < MiniTest::Test
+
+  def test_01_upload_epafhm
+    f = File.join DATA_DIR, "EPAFHM.csv"
+    d = OpenTox::Dataset.from_csv_file f
+    csv = CSV.read f
+    assert_equal csv.size-1, d.compounds.size
+    assert_equal csv.first.size-1, d.features.size
+    assert_equal csv.size-1, d.data_entries.size
+    d.delete
+  end
+
+=begin
+# TODO catch OpenBabel segfaults and identify/remove cause
+  def test_02_upload_multicell
+    duplicates = [
+      "http://localhost:8082/compound/InChI=1S/C6HCl5O/c7-1-2(8)4(10)6(12)5(11)3(1)9/h12H",
+      "http://localhost:8082/compound/InChI=1S/C12H8Cl6O/c13-8-9(14)11(16)5-3-1-2(6-7(3)19-6)4(5)10(8,15)12(11,17)18/h2-7H,1H2",
+      "http://localhost:8082/compound/InChI=1S/C2HCl3/c3-1-2(4)5/h1H",
+      "http://localhost:8082/compound/InChI=1S/C4H5Cl/c1-3-4(2)5/h3H,1-2H2",
+      "http://localhost:8082/compound/InChI=1S/C4H7Cl/c1-4(2)3-5/h1,3H2,2H3",
+      "http://localhost:8082/compound/InChI=1S/C8H14O4/c1-5-4-8(11-6(2)9)12-7(3)10-5/h5,7-8H,4H2,1-3H3",
+      "http://localhost:8082/compound/InChI=1S/C19H30O5/c1-3-5-7-20-8-9-21-10-11-22-14-17-13-19-18(23-15-24-19)12-16(17)6-4-2/h12-13H,3-11,14-15H2,1-2H3",
+    ]
+    errors = ['O=P(H)(OC)OC', 'C=CCNN.HCl' ]
+    f = File.join DATA_DIR, "multi_cell_call.csv"
+    d = OpenTox::Dataset.from_csv_file f 
+    csv = CSV.read f
+    assert_equal true, d.features.first.nominal
+    assert_nil d["index"]
+    assert_equal csv.size-1-errors.size, d.compounds.size
+    assert_equal csv.first.size-1, d.features.size
+    assert_equal csv.size-1-errors.size, d.data_entries.size
+    p d.warnings
+    (duplicates+errors).each do |uri|
+      assert d.warnings.grep %r{#{uri}}
+    end
+    d.delete
+  end
+=end
+
+  def test_03_upload_isscan
+    f = File.join DATA_DIR, "ISSCAN-multi.csv"
+    d = OpenTox::Dataset.from_csv_file f 
+    csv = CSV.read f
+    assert_equal csv.size-1, d.compounds.size
+    assert_equal csv.first.size-1, d.features.size
+    assert_equal csv.size-1, d.data_entries.size
+    d.delete
+    #assert_equal false, URI.accessible?(d.uri)
+  end
+
+  def test_04_simultanous_upload
+    threads = []
+    3.times do |t|
+      threads << Thread.new(t) do |up|
+        d = OpenTox::Dataset.from_csv_file "#{DATA_DIR}/hamster_carcinogenicity.csv"
+        assert_equal OpenTox::Dataset, d.class
+        assert_equal 1, d.features.size
+        assert_equal 85, d.compounds.size
+        assert_equal 85, d.data_entries.size
+        csv = CSV.read("#{DATA_DIR}/hamster_carcinogenicity.csv")
+        csv.shift
+        assert_equal csv.collect{|r| r[1]}, d.data_entries.flatten
+        d.delete 
+      end
+    end
+    threads.each {|aThread| aThread.join}
+  end
+
+  def test_05_upload_kazius
+    f = File.join DATA_DIR, "kazius.csv"
+    d = OpenTox::Dataset.from_csv_file f 
+    csv = CSV.read f
+    assert_equal csv.size-1, d.compounds.size
+    assert_equal csv.first.size-1, d.features.size
+    assert_equal csv.size-1, d.data_entries.size
+    assert_empty d.warnings
+    #  493 COC1=C(C=C(C(=C1)Cl)OC)Cl,1
+    c = d.compounds[491]
+    assert_equal c.smiles, "COc1cc(Cl)c(cc1Cl)OC"
+    assert_equal d.data_entries[491][0], "1"
+    d.delete
+  end
+
+  def test_upload_feature_dataset
+    t = Time.now
+    f = File.join DATA_DIR, "rat_feature_dataset.csv"
+    d = Dataset.from_csv_file f
+    assert_equal 458, d.features.size
+    d.save
+    p "Upload: #{Time.now-t}"
+    d2 = Dataset.find d.id
+    t = Time.now
+    assert_equal d.features.size, d2.features.size
+    csv = CSV.read f
+    csv.delete_at(248) # remove entry with InChi segfault
+    csv.shift # remove header
+    refute_empty d2.warnings
+    assert_match /249/, d2.warnings.join
+    assert_equal csv.size, d2.compounds.size 
+    assert_equal csv.first.size-1, d2.features.size
+    d2.compounds.each_with_index do |compound,i|
+      row = csv[i]
+      row.shift # remove compound
+      assert_equal row, d2.data_entries[i]
+    end
+    p "Dowload: #{Time.now-t}"
+    d2.delete
+    assert_raises Mongoid::Errors::DocumentNotFound do
+      Dataset.find d.id
+    end
+  end
+
+end

data/test/dataset.rb

@@ -0,0 +1,199 @@
+# TODO; check compound/data_entry sequences with missing and duplicated values
+
+require_relative "setup.rb"
+
+class DatasetTest < MiniTest::Test
+
+  def test_all
+    d1 = Dataset.new 
+    d1.save
+    datasets = Dataset.all 
+    assert_equal Dataset, datasets.first.class
+    d1.delete
+  end
+
+  def test_create_empty
+    d = Dataset.new
+    assert_equal Dataset, d.class
+    refute_nil d.id
+    assert_kind_of BSON::ObjectId, d.id
+  end
+
+  def test_client_create
+    d = Dataset.new
+    assert_equal Dataset, d.class
+    d.name = "Create dataset test"
+
+    # features not set
+    # << operator was removed for efficiency reasons (CH)
+    #assert_raises BadRequestError do
+    #  d << [Compound.from_smiles("c1ccccc1NN"), 1,2]
+    #end
+
+    # add data entries
+    d.features = ["test1", "test2"].collect do |title|
+      f = Feature.new 
+      f.name = title
+      f.numeric = true
+      f.save
+      f
+    end
+
+    # wrong feature size
+    # << operator was removed for efficiency reasons (CH)
+    #assert_raises BadRequestError do
+    #  d << [Compound.from_smiles("c1ccccc1NN"), 1,2,3]
+    #end
+    
+    # manual low-level insertions without consistency checks for runtime efficiency
+    data_entries = []
+    d.compound_ids << Compound.from_smiles("c1ccccc1NN").id
+    data_entries << [1,2]
+    d.compound_ids << Compound.from_smiles("CC(C)N").id
+    data_entries << [4,5]
+    d.compound_ids << Compound.from_smiles("C1C(C)CCCC1").id
+    data_entries << [6,7]
+    d.data_entries = data_entries
+    assert_equal 3, d.compounds.size
+    assert_equal 2, d.features.size
+    assert_equal [[1,2],[4,5],[6,7]], d.data_entries
+    d.save_all
+    # check if dataset has been saved correctly
+    new_dataset = Dataset.find d.id
+    assert_equal 3, new_dataset.compounds.size
+    assert_equal 2, new_dataset.features.size
+    assert_equal [[1,2],[4,5],[6,7]], new_dataset.data_entries
+    d.delete
+    assert_raises Mongoid::Errors::DocumentNotFound do
+      Dataset.find d.id
+    end
+    assert_raises Mongoid::Errors::DocumentNotFound do
+      Dataset.find new_dataset.id
+    end
+  end
+
+  def test_dataset_accessors
+    d = Dataset.from_csv_file "#{DATA_DIR}/multicolumn.csv"
+    # create empty dataset
+    new_dataset = Dataset.find d.id
+    # get metadata
+    assert_match "multicolumn.csv",  new_dataset.source
+    assert_equal "multicolumn.csv",  new_dataset.title
+    # get features
+    assert_equal 6, new_dataset.features.size
+    assert_equal 7, new_dataset.compounds.size
+    assert_equal ["1", nil, "false", nil, nil, 1.0], new_dataset.data_entries.last
+    d.delete
+  end
+
+  def test_create_from_file
+    d = Dataset.from_csv_file File.join(DATA_DIR,"EPAFHM.mini.csv")
+    assert_equal Dataset, d.class
+    refute_nil d.warnings
+    assert_match "EPAFHM.mini.csv",  d.source
+    assert_equal "EPAFHM.mini.csv",  d.name
+    d.delete 
+    #assert_equal false, URI.accessible?(d.uri)
+  end
+
+  def test_create_from_file_with_wrong_smiles_compound_entries
+    d = Dataset.from_csv_file File.join(DATA_DIR,"wrong_dataset.csv")
+    refute_nil d.warnings
+    assert_match /2|3|4|5|6|7|8/, d.warnings.join
+    d.delete
+  end
+
+  def test_multicolumn_csv
+    d = Dataset.from_csv_file "#{DATA_DIR}/multicolumn.csv"
+    refute_nil d.warnings
+    assert d.warnings.grep(/Duplicate compound/)  
+    assert d.warnings.grep(/3, 5/)  
+    assert_equal 6, d.features.size
+    assert_equal 7, d.compounds.size
+    assert_equal 5, d.compounds.collect{|c| c.inchi}.uniq.size
+    assert_equal [["1", "1", "true", "true", "test", 1.1], ["1", "2", "false", "7.5", "test", 0.24], ["1", "3", "true", "5", "test", 3578.239], ["0", "4", "false", "false", "test", -2.35], ["1", "2", "true", "4", "test_2", 1], ["1", "2", "false", "false", "test", -1.5], ["1", nil, "false", nil, nil, 1.0]], d.data_entries
+    assert_equal "c1ccc[nH]1,1,,false,,,1.0", d.to_csv.split("\n")[7]
+    csv = CSV.parse(d.to_csv)
+    original_csv = CSV.read("#{DATA_DIR}/multicolumn.csv")
+    csv.shift
+    original_csv.shift
+    csv.each_with_index do |row,i|
+      compound = Compound.from_smiles row.shift
+      original_compound = Compound.from_smiles original_csv[i].shift
+      assert_equal original_compound.inchi, compound.inchi
+      row.each_with_index do |v,j|
+        if v.numeric?
+          assert_equal original_csv[i][j].strip.to_f, row[j].to_f
+        else
+          assert_equal original_csv[i][j].strip, row[j].to_s
+        end
+      end
+    end
+    d.delete 
+  end
+
+  def test_from_csv
+    d = Dataset.from_csv_file "#{DATA_DIR}/hamster_carcinogenicity.csv"
+    assert_equal Dataset, d.class
+    assert_equal 1, d.features.size
+    assert_equal 85, d.compounds.size
+    assert_equal 85, d.data_entries.size
+    csv = CSV.read("#{DATA_DIR}/hamster_carcinogenicity.csv")
+    csv.shift
+    assert_equal csv.collect{|r| r[1]}, d.data_entries.flatten
+    d.delete 
+    #assert_equal false, URI.accessible?(d.uri)
+  end
+
+  def test_from_csv_classification
+    ["int", "float", "string"].each do |mode|
+      d = Dataset.from_csv_file "#{DATA_DIR}/hamster_carcinogenicity.mini.bool_#{mode}.csv"
+      csv = CSV.read("#{DATA_DIR}/hamster_carcinogenicity.mini.bool_#{mode}.csv")
+      csv.shift
+      entries = d.data_entries.flatten
+      csv.each_with_index do |r, i|
+        assert_equal r[1].to_s, entries[i]
+      end
+      d.delete 
+    end
+  end
+
+  def test_from_csv2
+    File.open("#{DATA_DIR}/temp_test.csv", "w+") { |file| file.write("SMILES,Hamster\nCC=O,true\n ,true\nO=C(N),true") }
+    dataset = Dataset.from_csv_file "#{DATA_DIR}/temp_test.csv"
+    assert_equal "Cannot parse SMILES compound ' ' at position 3, all entries are ignored.",  dataset.warnings.join
+    File.delete "#{DATA_DIR}/temp_test.csv"
+    dataset.features.each{|f| feature = Feature.find f.id; feature.delete}
+    dataset.delete
+  end
+
+  def test_same_feature
+    datasets = []
+    features = []
+    2.times do |i|
+      d = Dataset.from_csv_file "#{DATA_DIR}/hamster_carcinogenicity.mini.csv"
+      features << d.features.first
+      assert features[0].id==features[-1].id,"re-upload should find old feature, but created new one"
+      datasets << d
+    end
+    datasets.each{|d| d.delete}
+  end
+
+  def test_create_from_file
+    d = Dataset.from_csv_file File.join(DATA_DIR,"EPAFHM.mini.csv")
+    assert_equal Dataset, d.class
+    refute_nil d.warnings
+    assert_match /row 13/, d.warnings.join
+    assert_match "EPAFHM.mini.csv",  d.source
+    assert_equal 1, d.features.size
+    feature = d.features.first
+    assert_kind_of NumericBioAssay, feature
+    assert_equal 0.0113, d.data_entries[0][0]
+    assert_equal 0.00323, d.data_entries[5][0]
+    d2 = Dataset.find d.id
+    assert_equal 0.0113, d2.data_entries[0][0]
+    assert_equal 0.00323, d2.data_entries[5][0]
+  end
+
+end
+

data/test/descriptor-long.rb

@@ -0,0 +1,26 @@
+require_relative "setup.rb"
+class DescriptorLongTest < MiniTest::Test
+
+  def test_dataset_all
+    # TODO: improve CDK descriptor calculation speed or add timeout
+    skip "CDK descriptor calculation takes too long for some compounds"
+    dataset = OpenTox::Dataset.from_csv_file File.join(DATA_DIR,"hamster_carcinogenicity.mini.csv")
+    d = OpenTox::Algorithm::Descriptor.physchem dataset
+    assert_equal dataset.compounds, d.compounds
+    assert_equal 332, d.features.size
+    assert_equal 332, d.data_entries.first.size
+    d.delete
+  end
+
+  def test_dataset_openbabel
+    # TODO: improve CDK descriptor calculation speed or add timeout
+    dataset = Dataset.from_csv_file File.join(DATA_DIR,"hamster_carcinogenicity.mini.csv")
+    d = Algorithm::Descriptor.physchem dataset, Algorithm::Descriptor::OBDESCRIPTORS.keys
+    assert_equal dataset.compounds, d.compounds
+    size = Algorithm::Descriptor::OBDESCRIPTORS.keys.size
+    assert_equal size, d.features.size
+    assert_equal size, d.data_entries.first.size
+    d.delete
+  end
+
+end

data/test/descriptor.rb

@@ -0,0 +1,83 @@
+require_relative "setup.rb"
+
+class DescriptorTest < MiniTest::Test
+
+  def test_list
+    # check available descriptors
+    @descriptors = OpenTox::Algorithm::Descriptor::DESCRIPTORS.keys
+    assert_equal 111,@descriptors.size,"wrong num physchem descriptors"
+    @descriptor_values = OpenTox::Algorithm::Descriptor::DESCRIPTOR_VALUES
+    assert_equal 356,@descriptor_values.size,"wrong num physchem descriptors"
+    sum = 0
+    [ @descriptors, @descriptor_values ].each do |desc|
+      {"Openbabel"=>16,"Cdk"=>(desc==@descriptors ? 50 : 295),"Joelib"=>45}.each do |k,v|
+        assert_equal v,desc.select{|x| x=~/^#{k}\./}.size,"wrong num #{k} descriptors"
+        sum += v
+      end
+    end
+    assert_equal (111+356),sum
+  end
+
+  def test_smarts
+    c = OpenTox::Compound.from_smiles "N=C=C1CCC(=F=FO)C1"
+    File.open("tmp.png","w+"){|f| f.puts c.png}
+    s = Smarts.find_or_create_by(:smarts => "F=F")
+    result = OpenTox::Algorithm::Descriptor.smarts_match c, s
+    assert_equal [1], result
+    smarts = ["CC", "C", "C=C", "CO", "F=F", "C1CCCC1", "NN"].collect{|s| Smarts.find_or_create_by(:smarts => s)}
+    result = OpenTox::Algorithm::Descriptor.smarts_match c, smarts
+    assert_equal [1, 1, 1, 0, 1, 1, 0], result
+    smarts_count = [10, 6, 2, 0, 2, 10, 0]
+    result = OpenTox::Algorithm::Descriptor.smarts_count c, smarts
+    assert_equal smarts_count, result
+  end
+
+  def test_compound_openbabel_single
+    c = OpenTox::Compound.from_smiles "CC(=O)CC(C)C#N"
+    result = OpenTox::Algorithm::Descriptor.physchem c, ["Openbabel.logP"]
+    assert_equal 1.12518, result.first
+  end
+
+  def test_compound_cdk_single
+    c = OpenTox::Compound.from_smiles "c1ccccc1"
+    result = OpenTox::Algorithm::Descriptor.physchem c, ["Cdk.AtomCount"]
+    assert_equal [12], result
+    c = OpenTox::Compound.from_smiles "CC(=O)CC(C)C#N"
+    result = OpenTox::Algorithm::Descriptor.physchem c, ["Cdk.AtomCount"]
+    assert_equal [17], result
+    result = OpenTox::Algorithm::Descriptor.physchem c, ["Cdk.CarbonTypes"]
+    c_types = {"Cdk.CarbonTypes.C1SP1"=>1, "Cdk.CarbonTypes.C2SP1"=>0, "Cdk.CarbonTypes.C1SP2"=>0, "Cdk.CarbonTypes.C2SP2"=>1, "Cdk.CarbonTypes.C3SP2"=>0, "Cdk.CarbonTypes.C1SP3"=>2, "Cdk.CarbonTypes.C2SP3"=>1, "Cdk.CarbonTypes.C3SP3"=>1, "Cdk.CarbonTypes.C4SP3"=>0}
+    assert_equal [1, 0, 0, 1, 0, 2, 1, 1, 0], result
+  end
+
+  def test_compound_joelib_single
+    c = OpenTox::Compound.from_smiles "CC(=O)CC(C)C#N"
+    result = OpenTox::Algorithm::Descriptor.physchem c, ["Joelib.LogP"]
+    assert_equal [2.65908], result
+  end
+
+  def test_compound_all
+    c = OpenTox::Compound.from_smiles "CC(=O)CC(C)C#N"
+    result = OpenTox::Algorithm::Descriptor.physchem c
+    assert_equal 332, result.size
+    assert_equal 30.8723, result[2]
+    assert_equal 1.12518, result[328]
+  end
+
+  def test_compound_descriptor_parameters
+    c = OpenTox::Compound.from_smiles "CC(=O)CC(C)C#N"
+    result = OpenTox::Algorithm::Descriptor.physchem c, [ "Openbabel.logP", "Cdk.AtomCount", "Cdk.CarbonTypes", "Joelib.LogP" ]#, true
+    assert_equal 12, result.size
+    assert_equal [1.12518, 17.0, 1, 0, 0, 1, 0, 2, 1, 1, 0, 2.65908], result#.last
+  end
+
+  def test_dataset_descriptor_parameters
+    dataset = OpenTox::Dataset.from_csv_file File.join(DATA_DIR,"hamster_carcinogenicity.mini.csv")
+    d = OpenTox::Algorithm::Descriptor.physchem dataset, [ "Openbabel.logP", "Cdk.AtomCount", "Cdk.CarbonTypes", "Joelib.LogP" ]
+    assert_kind_of Dataset, d
+    assert_equal dataset.compounds, d.compounds
+    assert_equal dataset.compounds.size, d.data_entries.size
+    assert_equal 12, d.data_entries.first.size
+  end
+
+end

data/test/error.rb

@@ -0,0 +1,24 @@
+require_relative "setup.rb"
+
+class ErrorTest < MiniTest::Test
+
+  def test_bad_request
+    object = OpenTox::Feature.new 
+    assert_raises Mongoid::Errors::DocumentNotFound do
+      response = OpenTox::Feature.find(object.id)
+    end
+  end
+
+  def test_error_methods
+    assert_raises OpenTox::ResourceNotFoundError do
+      resource_not_found_error "This is a test"
+    end
+  end
+
+  def test_exception
+    assert_raises Exception do
+      raise Exception.new "Basic Exception"
+    end
+  end
+
+end

data/test/feature.rb

@@ -0,0 +1,65 @@
+require_relative "setup.rb"
+
+class FeatureTest < MiniTest::Test
+
+  def test_opentox_feature
+    @feature = OpenTox::Feature.create(:name => "tost")
+    assert_equal true, OpenTox::Feature.where(name: "tost").exists?, "#{@feature.id} is not accessible."
+    assert_equal true, OpenTox::Feature.where(id: @feature.id).exists?, "#{@feature.id} is not accessible."
+
+    list = OpenTox::Feature.all
+    listsize1 = list.length
+    assert_equal true, list.collect{|f| f.id}.include?(@feature.id)
+    # modify feature
+    @feature2 = OpenTox::Feature.find(@feature.id)
+    assert_equal "tost", @feature2[:name]
+    assert_equal "tost", @feature2.name
+    assert_kind_of Feature, @feature2
+
+    @feature2[:name] = "feature2"
+    @feature2.save
+    list = OpenTox::Feature.all 
+    listsize2 = list.length
+    assert_match "feature2", @feature2.name
+    refute_match "tost", @feature2.name
+    assert_equal listsize1, listsize2
+
+    id = @feature2.id
+    @feature2.delete
+    assert_raises Mongoid::Errors::DocumentNotFound do
+      OpenTox::Feature.find(id)
+    end
+  end
+
+  def test_duplicated_features
+    metadata = {
+      :name => "feature duplication test",
+      :nominal => true,
+      :description => "feature duplication test"
+    }
+    feature = NumericBioAssay.find_or_create_by metadata
+    dup_feature = NumericBioAssay.find_or_create_by metadata
+    assert_kind_of Feature, feature
+    assert !feature.id.nil?, "No Feature ID in #{feature.inspect}"
+    assert !feature.id.nil?, "No Feature ID in #{dup_feature.inspect}"
+    assert_equal feature.id, dup_feature.id
+    feature.delete
+    assert_raises Mongoid::Errors::DocumentNotFound do
+      OpenTox::Feature.find(feature.id)
+    end
+    assert_raises Mongoid::Errors::DocumentNotFound do
+      OpenTox::Feature.find(dup_feature.id)
+    end
+  end
+
+  def test_smarts_feature
+    feature = Smarts.find_or_create_by(:smarts => "CN")
+    assert feature.smarts, "CN"
+    assert_kind_of Smarts, feature
+    feature.smarts = 'cc'
+    assert feature.smarts, "cc"
+    original = Feature.where(:smarts => 'CN').first
+    assert original.smarts, "CN"
+  end
+
+end

data/test/fminer-long.rb

@@ -0,0 +1,38 @@
+require_relative "setup.rb"
+
+class FminerTest < MiniTest::Test
+
+  def test_fminer_multicell
+    #skip "multicell segfaults"
+    # TODO aborts, probably fminer
+    # or OpenBabel segfault
+    dataset = OpenTox::Dataset.from_csv_file File.join(DATA_DIR,"multi_cell_call.csv")
+    feature_dataset = OpenTox::Algorithm::Fminer.bbrc(dataset)#, :min_frequency => 15)
+    p feature_dataset.training_parameters
+    assert_equal dataset.compound_ids, feature_dataset.compound_ids
+    dataset.delete
+    feature_dataset.delete
+  end
+
+  def test_fminer_isscan
+    dataset = OpenTox::Dataset.from_csv_file File.join(DATA_DIR,"ISSCAN-multi.csv")
+    feature_dataset = OpenTox::Algorithm::Fminer.bbrc(dataset)#, :min_frequency => 15)
+    assert_equal feature_dataset.compounds.size, dataset.compounds.size
+    p feature_dataset.features.size
+    p feature_dataset.training_parameters
+    dataset.delete
+    feature_dataset.delete
+  end
+
+  def test_fminer_kazius
+    dataset = OpenTox::Dataset.from_csv_file File.join(DATA_DIR,"kazius.csv")
+    # TODO reactivate default settings
+    feature_dataset = OpenTox::Algorithm::Fminer.bbrc(dataset, :min_frequency => 20)
+    assert_equal feature_dataset.compounds.size, dataset.compounds.size
+    feature_dataset = Dataset.find feature_dataset.id
+    assert feature_dataset.data_entries.size, dataset.compounds.size
+    dataset.delete
+    feature_dataset.delete
+  end
+
+end

data/test/fminer.rb

@@ -0,0 +1,52 @@
+require_relative "setup.rb"
+
+class FminerTest < MiniTest::Test
+
+  def test_fminer_bbrc
+    dataset = OpenTox::Dataset.from_csv_file File.join(DATA_DIR,"hamster_carcinogenicity.csv")
+    refute_nil dataset.id
+    feature_dataset = OpenTox::Algorithm::Fminer.bbrc dataset
+    feature_dataset = Dataset.find feature_dataset.id
+    assert_equal dataset.compounds.size, feature_dataset.compounds.size
+    # TODO: fminer calculates 62 instead of 54 features
+    # it is unclear which commit changed the numbers (occurs with old libraries/mongodb branch too
+    # modification of Compound to use smiles instead of inchis seems to have no effect
+    #assert_equal 54, feature_dataset.features.size
+    #assert_equal "C-C-C=C", feature_dataset.features.first.smarts
+    compounds = feature_dataset.compounds
+    smarts = feature_dataset.features
+    smarts.each do |smart|
+      assert smart.p_value.round(2) >= 0.95
+    end
+    match = OpenTox::Algorithm::Descriptor.smarts_match compounds, smarts
+    feature_dataset.data_entries.each_with_index do |fingerprint,i|
+      assert_equal match[i], fingerprint
+    end
+
+    dataset.delete
+    feature_dataset.delete
+  end
+
+  def test_fminer_last
+    skip "last features have to be activated"
+    dataset = OpenTox::Dataset.new
+    dataset.upload File.join(DATA_DIR,"hamster_carcinogenicity.csv")
+    feature_dataset = OpenTox::Algorithm::Fminer.last :dataset => dataset
+    assert_equal dataset.compounds.size, feature_dataset.compounds.size
+    assert_equal 21, feature_dataset.features.size
+    assert_equal '[#6&A]-[#6&a]:[#6&a]:[#6&a]:[#6&a]:[#6&a]', feature_dataset.features.first.smarts
+
+    compounds = feature_dataset.compounds
+    smarts = feature_dataset.features.collect{|f| f.smarts}
+    match = OpenTox::Algorithm::Descriptor.smarts_match compounds, smarts
+    compounds.each_with_index do |c,i|
+      smarts.each_with_index do |s,j|
+        assert_equal match[i][j], feature_dataset.data_entries[i][j].to_i
+      end
+    end
+
+    dataset.delete
+    feature_dataset.delete
+  end
+
+end

data/test/lazar-fminer.rb

@@ -0,0 +1,50 @@
+require_relative "setup.rb"
+
+class LazarFminerTest < MiniTest::Test
+
+  def test_lazar_fminer
+    training_dataset = Dataset.from_csv_file File.join(DATA_DIR,"hamster_carcinogenicity.csv")
+    model = Model::LazarFminerClassification.create training_dataset#, feature_dataset
+    feature_dataset = Dataset.find model.neighbor_algorithm_parameters[:feature_dataset_id]
+    assert_equal training_dataset.compounds.size, feature_dataset.compounds.size
+    #TODO check fminer features, see fminer.rb
+    #assert_equal 54, feature_dataset.features.size
+    feature_dataset.data_entries.each do |e|
+      assert_equal e.size, feature_dataset.features.size
+    end
+    #assert_equal 'C-C-C=C', feature_dataset.features.first.smarts
+
+    [ {
+      :compound => OpenTox::Compound.from_inchi("InChI=1S/C6H6/c1-2-4-6-5-3-1/h1-6H"),
+      :prediction => "false",
+      :confidence => 0.25281385281385277,
+      :nr_neighbors => 11
+    },{
+      :compound => OpenTox::Compound.from_smiles("c1ccccc1NN"),
+      :prediction => "false",
+      :confidence => 0.3639589577089577,
+      :nr_neighbors => 14
+    }, {
+      :compound => Compound.from_smiles('OCCCCCCCC\C=C/CCCCCCCC'),
+      :prediction => "false",
+      :confidence => 0.5555555555555556,
+      :nr_neighbors => 1
+    }].each do |example|
+      prediction = model.predict example[:compound]
+
+      assert_equal example[:prediction], prediction[:value]
+      #assert_equal example[:confidence], prediction[:confidence]
+      #assert_equal example[:nr_neighbors], prediction[:neighbors].size
+    end
+
+    # make a dataset prediction
+    compound_dataset = OpenTox::Dataset.from_csv_file File.join(DATA_DIR,"EPAFHM.mini.csv")
+    prediction = model.predict compound_dataset
+    assert_equal compound_dataset.compounds, prediction.compounds
+
+    assert_equal "Cound not find similar compounds.", prediction.data_entries[7][2]
+    assert_equal "measured", prediction.data_entries[14][1]
+    # cleanup
+    [training_dataset,model,feature_dataset,compound_dataset].each{|o| o.delete}
+  end
+end