solvebio 1.6.1 → 1.7.0

data/test/solvebio/test_filter.rb

@@ -0,0 +1,86 @@
+require File.expand_path('../../helper', __FILE__)
+
+module SolveBio
+    class TestFilter < Test::Unit::TestCase
+        def test_filter_errors
+            assert_raises TypeError do
+                SolveBio::Filter.new(:style__gtt => 5)
+            end
+            assert_raises TypeError do
+                SolveBio::Filter.new(:style__range => 'a')
+            end
+            assert_raises TypeError do
+                SolveBio::Filter.new(:style__range => [5,10,15])
+            end
+            assert_raises IndexError do
+                SolveBio::Filter.new(:style__range => [10,5])
+            end
+        end
+
+        def test_filter
+            f = SolveBio::Filter.new
+            assert_equal('<SolveBio::Filter []>', f.inspect, 'empty filter')
+            assert_equal('<SolveBio::Filter []>',
+                         (~f).inspect, '"not" of empty filter')
+            f2 = SolveBio::Filter.new({:style => 'Mexican', :price => 'Free'})
+            assert_equal('<SolveBio::Filter [{:and=>[[:price, "Free"], [:style, "Mexican"]]}]>',
+                         f2.inspect, 'Hash to tuple sorting'
+                         )
+            assert_equal('<SolveBio::Filter [{:not=>{:and=>[[:price, "Free"], [:style, "Mexican"]]}}]>',
+                         (~f2).inspect, '~ of a non-nil filter')
+            assert_equal('<SolveBio::Filter [{:and=>[[:price, "Free"], [:style, "Mexican"]]}]>',
+                         (~~f2).inspect, '~~ has no effect')
+
+            filters3 =
+                SolveBio::Filter.new(:omim_id => 144650) |
+                SolveBio::Filter.new(:omim_id => 144600) |
+                SolveBio::Filter.new(:omim_id => 145300)
+
+            assert_equal('<SolveBio::Filter [{:or=>[[:omim_id, 144650], [:omim_id, 144600], [:omim_id, 145300]]}]>',
+                         filters3.inspect,
+                         'combining more than one of a connector (|)')
+
+            assert_equal('<SolveBio::Filter [[:style__range, [5, 10]]]>',
+                         SolveBio::Filter.new(:style__range => (5...11)).inspect)
+            assert_equal('<SolveBio::Filter [[:style__range, [5, 10]]]>',
+                         SolveBio::Filter.new(:style__range => (5..10)).inspect)
+
+        end
+
+        def test_genomic_filter
+            assert_equal(
+                '<GenomicFilter [{:and=>[["genomic_coordinates.start", 13], ["genomic_coordinates.stop", 32200000], ["chromosome", "hg38"]]}]>',
+                         SolveBio::GenomicFilter.
+                         new("hg38", "13", 32200000, 32500000).inspect)
+        end
+
+        def test_process_filters
+            # FIXME: add more and put in a loop.
+            filters = [[:omid_id, nil]]
+            expect  = filters
+            assert_equal(expect.inspect,
+                         SolveBio::Filter.process_filters(filters).inspect)
+        end
+
+        def test_genomic_single_position
+            f = SolveBio::GenomicFilter.new('chr1', 100)
+            assert_equal(
+                '<GenomicFilter [{:and=>[["genomic_coordinates.start__gte", 100.0], ["genomic_coordinates.start__lte", 100.0], ["chromosome", "1"]]}]>',
+                f.inspect)
+
+            f = SolveBio::GenomicFilter.new('chr1', 100, 100, true)
+            assert_equal(
+                '<GenomicFilter [{:and=>[["genomic_coordinates.start", 100], ["genomic_coordinates.stop", 100], ["chromosome", "1"]]}]>',
+                f.inspect)
+        end
+
+        def test_range
+            f = SolveBio::GenomicFilter.new('chr1', 100, 200)
+            assert_equal('<GenomicFilter [{:and=>[{:or=>[{:and=>[["genomic_coordinates.start__gte", 200.0], ["genomic_coordinates.start__lte", 100.0]]}, ["genomic_coordinates.start__range", [100, 201]], ["genomic_coordinates.stop__range", [100, 201]]]}, ["chromosome", "1"]]}]>',
+                         f.inspect)
+            f = SolveBio::GenomicFilter.new('chr1', 100, 200, true)
+            assert_equal('<GenomicFilter [{:and=>[["genomic_coordinates.start", 100], ["genomic_coordinates.stop", 200], ["chromosome", "1"]]}]>',
+                         f.inspect)
+        end
+    end
+end

data/test/solvebio/test_query.rb

@@ -0,0 +1,282 @@
+require File.expand_path('../../helper', __FILE__)
+
+module SolveBio
+    class TestQuery < Test::Unit::TestCase
+        def setup
+            @dataset = SolveBio::Dataset.retrieve(TEST_DATASET_NAME)
+        end
+
+        def test_basic
+            results = @dataset.query.filter(:omim_ids__in => [123631, 123670, 123690, 306250])
+            assert_equal(results.total, results.size)
+            assert_equal(results.total, results.length)
+            
+            _results = []
+            results.each_with_index.each do |r, i|
+                _results << r
+            end
+            assert_equal(_results.length, results.length)
+        end
+
+        # results.size should return the number of
+        # results retrieved.
+        def test_basic_with_limit
+            limit = 10
+            results = @dataset.query(:limit => limit)
+            assert_equal(results.size, limit)
+            assert_equal(results[results.total + 1], nil)
+            
+            _results = []
+            results.each_with_index.each do |r, i|
+                _results << r
+            end
+            assert_equal(_results.length, limit)
+        end
+
+        def test_count
+            q = @dataset.query
+            total = q.count
+            assert_operator total, :>, 0
+
+            # with a filter
+            q = @dataset.query.filter(:omim_ids => 123631)
+            assert_equal(1, q.count)
+
+            # with a bogus filter
+            q = @dataset.query.filter(:omim_ids => 999999)
+            assert_equal(0, q.count)
+        end
+
+        def test_count_with_limit
+            q = @dataset.query
+            total = q.count
+            assert_operator total, :>, 0
+
+            [0, 10, 1000].each do |limit|
+                # with a filter
+                q = @dataset.query(:limit => limit).filter(:omim_ids => 123631)
+                assert_equal(1, q.count)
+
+                # with a bogus filter
+                q = @dataset.query(:limit => limit).filter(:omim_ids => 999999)
+                assert_equal(0, q.count)
+            end
+        end
+
+        def test_len
+            q = @dataset.query
+            total = q.count
+            assert_operator total, :>, 0
+            assert_equal total, q.size
+
+            # with a filter
+            q = @dataset.query.filter(:omim_ids => 123631)
+            assert_equal 1, q.size
+
+            # with a bogus filter
+            q = @dataset.query.filter(:omim_ids => 999999)
+            assert_equal 0, q.size
+        end
+
+        def test_len_with_limit
+            q = @dataset.query
+            total = q.count
+            assert_operator(total, :>, 0)
+            assert_equal(total, q.size)
+
+            [0, 10, 1000].each do |limit|
+                # with a filter
+                q = @dataset.query(:limit => limit).filter(:omim_ids => 123631)
+                assert_equal(limit > 0 ? 1 : 0, q.size)
+
+                # with a bogus filter
+                q = @dataset.query(:limit => limit).filter(:omim_ids => 999999)
+                assert_equal 0, q.size
+            end
+        end
+
+        # test Query when limit is specified and is GREATER THAN total available
+        # results.
+        def test_empty
+            # bogus filter
+            results = @dataset.query.filter(:omim_ids => 999999)
+            assert_equal(0, results.size)
+            assert_equal(results[0...results.size].to_a, [])
+            assert_equal(results[0], nil)
+        end
+
+        # test Query when limit is specified and is GREATER THAN total available
+        #    results.
+        def test_empty_with_limit
+            limit = 100
+            # bogus filter
+            results = @dataset.query(:limit => limit)
+                        .filter(:omim_ids => 999999)
+            assert_equal(0, results.size)
+            assert_equal(results[0...results.size].to_a, [])
+            assert_equal(results[0], nil)
+        end
+
+        # test Filtered Query in which limit is specified but is GREATER THAN
+        #    the number of total available results
+        def test_filter
+            num_filters = 4
+            filters =
+                SolveBio::Filter.new(:omim_ids => 123631) |
+                SolveBio::Filter.new(:omim_ids => 123670) |
+                SolveBio::Filter.new(:omim_ids => 123690) |
+                SolveBio::Filter.new(:omim_ids => 306250)
+            results = @dataset.query(:filters => filters)
+            assert_equal(num_filters, results.size)
+            assert_equal(results[num_filters], nil)
+        end
+
+        #   test SolveBio::Filtered Query in which limit is specified but is GREATER THAN
+        #    the number of total available results
+        def test_filter_with_limit
+            limit = 10
+            num_filters = 4
+            filters =
+                SolveBio::Filter.new(:omim_ids => 123631) |
+                SolveBio::Filter.new(:omim_ids => 123670) |
+                SolveBio::Filter.new(:omim_ids => 123690) |
+                SolveBio::Filter.new(:omim_ids => 306250)
+            results = @dataset.query :limit => limit, :filters => filters
+            assert_equal(num_filters, results.size)
+            assert_equal(results[num_filters], nil)
+        end
+
+        def test_paging
+            page_size = 10
+            num_pages = 3
+            results = @dataset.query :page_size => page_size
+
+            _results = []
+            results.each_with_index.each do |r, i|
+                # break after fetching num_pages
+                break if i / page_size == num_pages
+                _results << r
+            end
+
+            assert_equal _results.size, num_pages * page_size
+            assert_equal num_pages * page_size, _results.map{|i| i}.size
+        end
+
+        def test_paging_with_limit
+            page_size = 10
+            num_pages = 3
+            limit = num_pages * page_size - 1
+            results = @dataset.query(:limit => limit, :page_size => page_size)
+
+            _results = []
+            results.each_with_index.each do |r, i|
+                _results << r
+            end
+
+            assert_equal limit, _results.size
+            assert_equal limit, _results.map{|i| i}.size
+        end
+
+        def test_slice_ranges
+            limit = 50
+
+            results = @dataset.query(:limit => limit)
+            assert_equal limit, results[0..limit].size
+            assert_equal 0, results[limit..limit].size
+            assert_equal 0, results[limit..-1].size
+
+            r0 = @dataset.query(:limit => limit)[0..limit][limit-1]
+            r1 = @dataset.query(:limit => limit)[limit-1..limit][0]
+            assert_equal(r0[:hgnc_id], r1[:hgnc_id])
+        end
+
+        def test_slice_ranges_with_paging
+            limit = 5
+            page_size = 2
+
+            results = @dataset.query(:limit => limit, :page_size => page_size)[0..limit]
+            assert_equal results.length, limit
+
+            results = @dataset.query(:limit => limit, :page_size => page_size)[limit..limit-1]
+            assert_equal 0, results.length, 0
+
+            r0 = @dataset.query(:limit => limit)[0..limit][limit-1]
+            r1 = @dataset.query(:limit => limit)[limit-1..limit][0]
+            assert_equal(r0[:hgnc_id], r1[:hgnc_id])
+        end
+
+        def test_slice_ranges_with_small_limit
+            # Test slices larger than 'limit'
+            limit = 1
+            results = @dataset.query(:limit => limit)
+                .filter(:hgnc_id__range => [1000, 2000])[0..4]
+            assert_equal limit, results.size
+        end
+
+        def hgnc_id_range_query
+            @dataset.query(:limit => 10)
+                .filter(:hgnc_id__range => [1000, 5000])
+        end
+
+        def test_paging_and_slice_equivalence
+            idx0 = 3
+            idx1 = 5
+
+            results_slice = hgnc_id_range_query()[idx0...idx1]
+            results_paging = []
+
+            hgnc_id_range_query.each_with_index do |r,i|
+                if i == idx1
+                    break
+                elsif i >= idx0
+                    results_paging << r
+                end
+            end
+
+            assert_equal results_paging.size, results_slice.size
+
+            0.upto(results_slice.size-1).each do |i|
+                id_a = results_paging[i]['hgnc_id']
+                id_b = results_slice[i]['hgnc_id']
+                assert_equal(id_a, id_b)
+            end
+        end
+
+        def test_caching
+            idx0 = 60
+            idx1 = 81
+
+            q = @dataset.query(:limit => 100)
+            results_slice = q[idx0...idx1]
+            results_cached = q[idx0...idx1]
+            assert_equal results_cached.size, results_slice.size
+            0.upto(results_slice.size-1).each do |i|
+                id_a = results_slice[i]['chromosome']
+                id_b = results_cached[i]['chromosome']
+                assert_equal(id_a, id_b)
+            end
+        end
+
+        def test_get_by_index
+            limit = 100
+            page_size = 10
+            idxs = [0, 1, 10, 20, 50, 99]
+            q = @dataset.query(:limit => limit, :page_size => page_size)
+            cached = []
+            idxs.each do |idx|
+                cached << q[idx]
+            end
+
+            # forwards
+            idxs.each_with_index do |idx, i|
+                assert_equal(cached[i], q[idx])
+            end
+
+            i = cached.size - 1
+            idxs.reverse.each do |idx|
+                assert_equal(cached[i], q[idx])
+                i -= 1
+            end
+        end
+    end
+end

data/test/solvebio/test_query_batch.rb

@@ -0,0 +1,38 @@
+require File.expand_path('../../helper', __FILE__)
+
+module SolveBio
+    class TestQueryBatch < Test::Unit::TestCase
+        def setup
+            @dataset = SolveBio::Dataset.retrieve(TEST_DATASET_NAME)
+        end
+
+        def test_invalid_batch_query
+            assert_raise SolveBio::SolveError do
+                SolveBio::BatchQuery
+                    .new([
+                          @dataset.query(:limit => 1, :fields => [:bogus_field]),
+                          @dataset.query(:limit => 10).filter(:bogus_id__gt => 100000)
+                         ]).execute
+            end
+
+            results = SolveBio::BatchQuery
+                .new([
+                      @dataset.query(:limit => 10).filter(:hgnc_id__lt => 100),
+                      @dataset.query(:limit => 10).filter(:hgnc_id__gt => 100)
+                     ]).execute
+            assert_equal(2, results.length)
+
+        end
+
+        def test_batch_query
+            queries = [
+                       @dataset.query(:limit => 1),
+                       @dataset.query(:limit => 10).filter(:hgnc_id__gt => 100)
+                      ]
+            results = SolveBio::BatchQuery.new(queries).execute
+            assert_equal(2, results.size)
+            assert_equal(1, results[0][:results].length)
+            assert_equal(10, results[1][:results].size)
+        end
+    end
+end

data/test/solvebio/test_query_init.rb

@@ -0,0 +1,30 @@
+require File.expand_path('../../helper', __FILE__)
+
+module SolveBio
+    class TestQuery < Test::Unit::TestCase
+        def test_query_initialize
+            [SolveBio::Query].each do |klass|
+                assert klass.new(5)
+                assert klass.new('clinvar/1.0.0/clinvar')
+
+                assert_raises TypeError do
+                    klass.new(:limit => 10)
+                end
+                
+                assert_raises TypeError do
+                    klass.new(5.0, :limit => 10.0)
+                end
+
+                assert klass.new(5, :limit => 10)
+                assert_raises TypeError do
+                    # limit should be > 0
+                    assert klass.new(5, :limit => -1)
+                end
+                assert_raises TypeError do
+                    # limit should be a Fixnum
+                    assert klass.new(5, :limit => 'a')
+                end
+            end
+        end
+    end
+end

data/test/solvebio/test_query_tabulate.rb

@@ -0,0 +1,73 @@
+require File.expand_path('../../helper', __FILE__)
+
+module SolveBio
+    class TestQueryTabulate < Test::Unit::TestCase
+        def check_result_fields(expect, got)
+            expect_array = expect.split("\n")
+            got_array = got.split("\n")
+            assert_equal(expect_array[0..2], got_array[0..2], "Header lines")
+            assert_equal(expect_array.size, got_array.size, 'Sizes of results')
+            got_array[3...-1].each_with_index do |line, i|
+                assert_equal(expect_array[i+3][0..33], line[0..33], "line #{i+3}")
+            end
+            assert_match(/^[.]{3} [0-9,]+ more results./, got_array[-1])
+        end
+
+        def test_query_tabulate
+            old_verbose = $VERBOSE
+            $VERBOSE=nil
+            SolveBio::Tabulate.const_set(:TTY_COLS, 66)
+            $VERBOSE=old_verbose
+            dataset = SolveBio::Dataset.retrieve(TEST_DATASET_NAME)
+            results = dataset.query().filter(:hgnc_id => 2396)
+            expected = <<-EOF
+
+|                       Fields | Data                            |
+|------------------------------+---------------------------------|
+|            accession_numbers |                                 |
+|                approved_name | crystallin, beta A4             |
+|              approved_symbol | CRYBA4                          |
+|                     ccds_ids | ["CCDS13841.1"]                 |
+|                   chromosome | 22                              |
+|                date_approved | 1991-07-25                      |
+|                date_modified | 2008-06-10                      |
+|            date_name_changed |                                 |
+|          date_symbol_changed |                                 |
+|              ensembl_gene_id | ENSG00000196431                 |
+|           ensembl_id_ensembl | ENSG00000196431                 |
+|               entrez_gene_id | 1413                            |
+|          entrez_gene_id_ncbi | 1413                            |
+|                   enzyme_ids |                                 |
+|      gene_family_description |                                 |
+|              gene_family_tag |                                 |
+|                      hgnc_id | 2396                            |
+|                        locus | 22q12.1                         |
+|                  locus_group | protein-coding gene             |
+|     locus_specific_databases | ["LOVD - Leiden Open Variat ... |
+|                   locus_type | gene with protein product       |
+|     mouse_genome_database_id | [102716]                        |
+| mouse_genome_database_id_mgi | [102716]                        |
+|                name_synonyms |                                 |
+|                 omim_id_ncbi | 123631                          |
+|                     omim_ids | [123631]                        |
+|               previous_names |                                 |
+|             previous_symbols |                                 |
+|                  primary_ids |                                 |
+|                   pubmed_ids | ["8999933", "960806"]           |
+|   rat_genome_database_id_rgd | 61962                           |
+|                  record_type | Standard                        |
+|               refseq_id_ncbi | NM_001886                       |
+|                   refseq_ids | ["NM_001886"]                   |
+|                secondary_ids |                                 |
+|                       status | Approved                        |
+|                     synonyms |                                 |
+|                 ucsc_id_ucsc | uc003acz.4                      |
+|           uniprot_id_uniprot | P53673                          |
+|                     vega_ids | ["OTTHUMG00000150983"]          |
+
+... No more results.
+EOF
+            check_result_fields(expected, results.to_s)
+        end
+    end
+end