solvebio 1.6.1 → 1.7.0

data/test/test-query-init.rb

@@ -1,29 +0,0 @@
-$VERBOSE = true
-require 'test/unit'
-require_relative '../lib/query'
-
-class TestQuery < Test::Unit::TestCase
-
-    def test_query_initialize
-        [SolveBio::PagingQuery, SolveBio::Query].each do |klass|
-            assert klass.new(5)
-            assert klass.new('5')
-            assert_raises TypeError do
-                # dataset id should be an Fixnum
-                klass.new(:limit => 10)
-            end
-            assert klass.new(5, :limit => 10)
-            assert klass.new(5.0, :limit => 10.0)
-            assert_raises RangeError 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

data/test/test-query-paging.rb

@@ -1,102 +0,0 @@
-#!/usr/bin/env ruby
-$VERBOSE = true
-require 'socket'
-require_relative 'helper'
-require_relative '../lib/resource/main'
-
-class TestQueryPaging < Test::Unit::TestCase
-
-    def setup
-        @dataset = SolveBio::Dataset.retrieve(TEST_DATASET_NAME)
-    end
-
-    def test_query
-        results = @dataset.query(:paging=>true, :limit => 10)
-        # When paging is on, results.size should return the number
-        # of total number of results.
-        assert_equal(results.size, results.total,
-                     'results.size == results.total, paging=true')
-    end
-
-    # In paging queries, results.size should return the total number of
-    # results that exist. Yes, this is the same as test_query, but
-    # we reverse the order of access, to make sure "warmup" is called.
-    def test_limit
-        limit = 10
-        results = @dataset.query(:paging=>true, :limit => limit)
-        assert_equal(results.total, results.length,
-                     'results.total == results.length, paging = true')
-    end
-
-    def test_paging
-        limit = 100
-        total = 4
-        results = @dataset.query(:paging => true, :limit => limit).
-            filter(:hgnc_id__in => [2396, 2404, 2409, 2411])
-
-        assert_equal(total, results.total)
-
-        # Make sure we can iterate over the entire result set
-        i = 0
-        results.each_with_index do |val, j|
-            assert val, "Can retrieve filter item #{i}"
-            i = j
-        end
-        assert_equal(i, total-1)
-    end
-
-    def test_range
-        limit = 30
-        results = @dataset.query(:paging => true, :limit => limit).
-            filter(:hgnc_id__range => [10, 6000])[2..5]
-        assert_equal(3, results.size)
-
-        results = @dataset.query(:paging => true, :limit => limit).
-            filter(:hgnc_id__range => [10, 6000])[0..7]
-        assert_equal(7, results.size)
-    end
-
-    def test_paging_and_slice_equivalence
-        idx0 = 3
-        idx1 = 5
-
-        query = proc{
-            @dataset.query( :paging => true, :limit => 10).
-            filter(:hgnc_id__range => [1000, 5000])[2..10]
-        }
-
-        results_slice = query.call()[idx0...idx1]
-        results_paging = []
-        query.call.each_with_index do |r, i|
-            break if i == idx1
-            results_paging << r if i >= idx0
-        end
-
-        assert_equal(results_slice.size, results_paging.size)
-
-        results_paging.size.times do |i|
-            id_a = results_paging[i][:hgnic_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(:paging => true, :limit => 100)
-        # q = self.dataset.query(paging=True, limit=100) \
-        #         .filter(omim_id__in=range(100000, 120000))
-        results_slice = q[idx0..idx1]
-        results_cached = q[idx0..idx1]
-
-        assert_equal(results_slice.size, results_cached.size)
-        results_slice.size-1.times do |i|
-            id_a = results_slice[i]['reference_allele']
-            id_b = results_cached[i]['reference_allele']
-            assert_equal(id_b, id_a)
-        end
-    end
-
-end

data/test/test-query.rb

@@ -1,71 +0,0 @@
-$VERBOSE = true
-require 'socket'
-require_relative 'helper'
-require_relative '../lib/resource/main'
-
-class TestQuery < Test::Unit::TestCase
-    def setup
-        @dataset = SolveBio::Dataset.retrieve(TEST_DATASET_NAME)
-    end
-
-    # When paging is off, results.length should return the number of
-    # results retrieved.
-    def test_limit
-        @dataset = SolveBio::Dataset.retrieve(TEST_DATASET_NAME)
-        limit = 10
-        results = @dataset.query :paging=>false, :limit => limit
-        assert_equal(limit, results.length,
-                     'limit == results.size, paging = false')
-
-
-        results.each_with_index do |val, i|
-            assert results[i], "retrieving value at #{i}"
-        end
-
-        assert_raise IndexError do
-            puts results[limit]
-        end
-    end
-
-    # test Query when limit is specified and is GREATER THAN total available
-    #  results
-    def test_limit_empty
-        limit = 100
-        results = @dataset.query(:paging=>false, :limit => limit).
-            filter({:omim_ids => 999999})
-        assert_equal(0, results.size)
-
-        assert_raise IndexError do
-            puts results[0]
-        end
-
-        results = @dataset.query(:paging=>false, :limit => limit).
-            filter :omim_ids => 123631
-        assert_equal(1, results.size)
-    end
-
-    # test Filtered Query in which limit is specified but is GREATER THAN
-    #  the number of total available results
-    def test_limit_filter
-        limit = 10
-        num_filters = 2
-
-        filters =
-            SolveBio::Filter.new(:omim_ids => 123631) |
-            SolveBio::Filter.new(:omim_ids => 123670)
-
-        results = @dataset.query(:paging=>false, :limit => limit,
-                                 :filters => filters)
-
-        num_filters.times do |i|
-            assert results[i]
-        end
-
-        assert_equal(num_filters, results.size)
-
-        assert_raise IndexError do
-            puts results[num_filters]
-        end
-    end
-
-end

data/test/test-resource.rb

@@ -1,40 +0,0 @@
-#!/usr/bin/env ruby
-$VERBOSE = true
-require_relative './helper'
-require_relative '../lib/resource/main'
-
-class TestResource < Test::Unit::TestCase
-
-    # Do the class FULL_NAME_REGEX contants match what the think they
-    # should?
-    def test_full_name_regexp
-        assert('HGNC/1.0.0-1/HGNC' =~
-                SolveBio::Dataset::FULL_NAME_REGEX,
-                'Dataset regexp')
-
-    end
-
-    def test_SolveObject_inspect
-        str = SolveBio::SolveObject.new.inspect
-        assert(str =~ /^<SolveBio::SolveObject:[[:xdigit:]]+> JSON: {}/,
-               'empty SolveObject inspect')
-        str = SolveBio::SolveObject.new(62).inspect
-        assert(str =~ /^<SolveBio::SolveObject id=62:[[:xdigit:]]+> JSON: {"id":62}/,
-               "SolveObject inspect with id #{str}")
-
-    end
-
-    def test_Dataset_from_response
-        resp = {
-            'class_name' => 'Dataset',
-            'depository' => 'HGNC',
-            'depository_version' => 'HGNC/1.0.0-1',
-            'full_name' => 'HGNC/1.0.0-1/HGNC',
-            'name' => 'HGNC',
-            'title' => 'HGNC'
-        }
-        so = resp.to_solvebio
-        assert_equal SolveBio::Dataset, so.class, 'Hash -> SolveObject'
-        resp.keys.each {|k| assert_equal resp[k], so[k]}
-    end
-end

data/test/test-sample-access.rb

@@ -1,59 +0,0 @@
-require_relative './helper'
-
-class TestSampleAccess < Test::Unit::TestCase
-
-    def check_response(response, expect, msg)
-        expect.each do |key, val|
-            assert_equal(val, response[key], msg)
-        end
-    end
-
-    def test_insert_delete
-        if SolveBio::API_HOST == 'https://api.solvebio.com'
-            skip "Testing only on local/dev environments"
-        end
-
-        all = SolveBio::Sample.all
-        total = all.total
-        vcf_url = 'http://downloads.solvebio.com/vcf/small_sample.vcf.gz'
-        expect = {
-            'class_name'        => 'Sample',
-            'annotations_count' => 0,
-            'description'       =>  '',
-            'genome_build'      => 'GRCh37',
-            'vcf_md5'           => 'a03e39e96671a01208cffd234812556d',
-            'vcf_size'          => 12124
-        }
-
-        response = SolveBio::Sample.create('GRCh37', :vcf_url => vcf_url)
-        check_response(response, expect,
-                       'create sample.vcf.gz from url')
-        all = SolveBio::Sample.all
-        assert_equal(all.total, total + 1, "After uploading an url")
-        total = total + 1
-
-        vcf_file = File.join(File.dirname(__FILE__), 'data/sample.vcf.gz')
-        response = SolveBio::Sample.create('GRCh37', {:vcf_file => vcf_file})
-        expect = {
-            'class_name' => 'Sample',
-            'annotations_count' => 0,
-            'description' => '',
-            'genome_build' => 'GRCh37',
-            'vcf_md5' => '83acd96171c72ab2bb35e9c52961afd9',
-            'vcf_size' => 592
-        }
-
-        check_response(response, expect,
-                       'create sample.vcf.gz from a file')
-
-        # assert_equal(all.total, total, "After uploading a file")
-
-        # sample = SolveBio::Sample.retrieve(response.id)
-        # delete_response = sample.delete
-        # assert_equal(delete_response.deleted, true,
-        #                  'response.deleted should be true')
-
-        # all = SolveBio::Sample.all
-        # assert_equal(all.total, total, "After deleting a file")
-    end
-end

data/test/test-sample-download.rb

@@ -1,20 +0,0 @@
-require 'fileutils'
-require_relative './helper'
-
-class TestSampleDownload < Test::Unit::TestCase
-
-    def test_sample_download
-        if SolveBio::API_HOST == 'https://api.solvebio.com'
-            skip "Testing only on local/dev environments"
-        end
-
-        vcf_file = File.join(File.dirname(__FILE__), 'data/sample.vcf.gz')
-        sample = SolveBio::Sample.create('GRCh37', {:vcf_file => vcf_file})
-        response = sample.download()
-        assert_equal(response['code'], 200,
-                     "Download sample file status ok")
-        assert(File.exist?(response['filename']),
-               "Download sample file on filesystem")
-        FileUtils.rm response['filename']
-    end
-end

data/test/test-tabulate.rb

@@ -1,131 +0,0 @@
-#!/usr/bin/env ruby
-# -*- coding: utf-8 -*-
-require_relative '../lib/tabulate'
-$VERBOSE = true
-require 'test/unit'
-
-class TestTabulate < Test::Unit::TestCase
-
-    include SolveBio::Tabulate
-
-    def test_classify
-
-        assert_equal true,  '123.45'.number?
-        assert_equal true,  '123'.number?
-        assert_equal false, 'spam'.number?
-        assert_equal true,  '123'.int?
-        assert_equal false, '123.45'.int?
-
-        assert_equal NilClass, _type(nil)
-        assert_equal String, _type('foo')
-        assert_equal Fixnum, _type('1')
-        assert_equal Fixnum, _type(1)
-        assert_equal Fixnum, _type('\x1b[31m42\x1b[0m')
-    end
-
-    def test_align
-        assert_equal( 2, '123.45'.afterpoint)
-        assert_equal(-1, '1001'.afterpoint)
-        assert_equal(-1, 'eggs'.afterpoint)
-        assert_equal( 2, '123e45'.afterpoint)
-
-        assert_equal("  \u044f\u0439\u0446\u0430",
-                     "\u044f\u0439\u0446\u0430".padleft(6))
-        assert_equal("\u044f\u0439\u0446\u0430  ",
-                     "\u044f\u0439\u0446\u0430".padright(6))
-
-        assert_equal(" \u044f\u0439\u0446\u0430 ",
-                     "\u044f\u0439\u0446\u0430".padboth(6))
-
-        assert_equal(" \u044f\u0439\u0446\u0430  ",
-                     "\u044f\u0439\u0446\u0430".padboth(7))
-
-        assert_equal('abc', 'abc'.padright(2))
-        assert_equal('abc', 'abc'.padleft(2))
-        assert_equal('abc', 'abc'.padboth(2))
-
-
-        assert_equal(['   12.345  ', '-1234.5    ', '    1.23   ',
-                      ' 1234.5    ', '    1e+234 ', '    1.0e234'],
-                     align_column(
-                                  ["12.345", "-1234.5", "1.23", "1234.5",
-                                   "1e+234", "1.0e234"], "decimal"))
-    end
-
-    def test_column_type
-        assert_equal(Fixnum, column_type(["1", "2"]))
-        assert_equal(Float,  column_type(["1", "2.3"]))
-        assert_equal(String, column_type(["1", "2.3", "four"]))
-        assert_equal(String,
-                     column_type(["four", '\u043f\u044f\u0442\u044c']))
-        assert_equal(String, column_type([nil, "brux"]))
-        assert_equal(Fixnum, column_type([1, 2, nil]))
-    end
-
-    def test_tabulate
-        old_verbose = $VERBOSE
-        $VERBOSE=nil
-        SolveBio::Tabulate.const_set(:TTY_COLS, 80)
-        $VERBOSE=old_verbose
-        tsv = simple_separated_format("\t")
-        expected = <<-EOS
-foo    1
-spam  23
-EOS
-        assert_equal(expected.chomp, tabulate([["foo", 1], ["spam", 23]], [], tsv),
-                     'simple separated format table')
-        ####################################################################
-        expected = <<-EOS
-| буква   |   цифра |
-|---------+---------|
-| аз      |       2 |
-| буки    |       4 |
-EOS
-        hrow = ["\u0431\u0443\u043a\u0432\u0430", "\u0446\u0438\u0444\u0440\u0430"]
-        tbl = [["\u0430\u0437", 2], ["\u0431\u0443\u043a\u0438", 4]]
-        assert_equal(expected.chomp, SolveBio::Tabulate.tabulate(tbl, hrow),
-                     'org mode with header and unicode')
-
-        ###################################################################
-        expected = <<-EOS
-| Fields                | Data                        |
-|-----------------------+-----------------------------|
-| alternate_alleles     | T                           |
-| clinical_origin       | somatic                     |
-| clinical_significance | other                       |
-| gene_symbols          | CPB1                        |
-| hg18_chromosome       | 3                           |
-| hg19_chromosome       | 3                           |
-| hg19_start            | 148562304                   |
-| hg38_start            | 148844517                   |
-| hgvs                  | NC_000003.12:g.148844517C>T |
-| rcvaccession          | RCV000060731                |
-| rcvaccession_version  | 2                           |
-| reference_allele      | C                           |
-| rsid                  | rs150241322                 |
-| type                  | SNV                         |
-EOS
-
-         hash = {
-            "alternate_alleles"    => ["T"],
-            "clinical_origin"      => ["somatic"],
-            "clinical_significance"=> "other",
-            "gene_symbols"         => ["CPB1"],
-            "hg18_chromosome"      => "3",
-            "hg19_chromosome"      => "3",
-            "hg19_start"           => 148562304,
-            "hg38_start"           => 148844517,
-            "hgvs"                 => ["NC_000003.12:g.148844517C>T"],
-            "rcvaccession"         => "RCV000060731",
-            "rcvaccession_version" => 2,
-            "reference_allele"     => "C",
-            "rsid"                 => "rs150241322",
-            "type"                 => "SNV"
-        }
-        assert_equal(expected.chomp, tabulate(hash.to_a,
-                                              ['Fields', 'Data'],
-                                              ['right', 'left']),
-                     'mixed data with arrays; close to actual query output')
-    end
-
-end