solvebio 1.5.2 → 1.6.1

data/test/test-auth.rb

@@ -34,14 +34,17 @@ class TestAuth < Test::Unit::TestCase
     def teardown
         # Restore creds to what they were when we started
         save_credentials(*@@creds) if @@creds
-        i_am = run_it @@whoami_cmd
-        assert_equal(@i_was, i_am,
-                     'get_credential and save_creditentials be idempotent')
+        netrc_path = SolveBio::Credentials.netrc_path
+        n = Netrc.read(netrc_path)
+        if n[SolveBio::API_HOST]
+            i_am = run_it @@whoami_cmd
+            assert_equal(@i_was, i_am,
+                         'get_credential and save_creditentials be idempotent')
+        end
     end
 
     # Integration test of logout
     def test_logout
-
         # Dunno if we are logged in or out - log out
         output = run_it @logout_cmd
         # We should be logged out. Try again, and check message.
@@ -51,4 +54,5 @@ class TestAuth < Test::Unit::TestCase
         output = run_it @@whoami_cmd
         assert_equal 'You are not logged-in.', output
     end
+
 end

data/test/test-client.rb

@@ -4,8 +4,6 @@ require 'test/unit'
 require 'fileutils'
 require_relative '../lib/client'
 
-# require 'trepanning'
-
 class TestClient < Test::Unit::TestCase
 
     def test_get
@@ -15,10 +13,12 @@ class TestClient < Test::Unit::TestCase
         # Can we get something from google?
         output = `curl --silent http://www.google.com`
         if $?.success? and output
-            assert(client.request('http', 'http://www.google.com', nil,
-                                  true), 'HTTP GET, google.com')
-            assert(client.request('https', 'https://www.google.com', nil,
-                                  true), 'HTTPS GET google.com')
+            assert(client.request('get', 'http://www.google.com',
+                                  {:raw => true, :redirect => true}),
+                                  'HTTP GET, google.com')
+            assert(client.request('get', 'https://www.google.com',
+                                  {:raw => true}),
+                                  'HTTPS GET google.com')
         else
             skip('Are you connected to the Internet? www.google.com is unavailable')
         end

data/test/test-conversion.rb

@@ -0,0 +1,13 @@
+require 'test/unit'
+require_relative  '../lib/resource/apiresource'
+
+class ConversionTest < Test::Unit::TestCase
+    def test_class_to_api_name
+        ar = SolveBio::APIResource
+        [%w(Annotation annotations),
+         %w(DataField  data_fields),
+         %w(Depository depositories)].each do |class_name, expect|
+            assert_equal(expect, ar.class_to_api_name(class_name))
+        end
+    end
+end

data/test/test-dataset.rb

@@ -0,0 +1,42 @@
+# Test Dataset, DatasetField, and Facets
+require_relative './helper'
+require_relative '../lib/resource/main'
+
+class TestDataset < Test::Unit::TestCase
+    def setup
+        @dataset = SolveBio::Dataset.retrieve(TEST_DATASET_NAME)
+    end
+
+    def test_dataset
+        assert(@dataset.member?('id'),
+               'Should be able to get id in dataset')
+
+        %w(class_name created_at data_url depository depository_id
+           depository_version depository_version_id description
+          fields_url full_name name title updated_at url).each do |field|
+            assert(@dataset.member?(field),
+                   "Should find field #{field} in dataset #{@dataset.id}")
+        end
+
+        fields = @dataset.fields()
+        dataset_field = fields[:data][0]
+        assert(dataset_field.member?('id'),
+               'Should be able to get id in list of dataset fields')
+
+        dataset_field2 = SolveBio::DatasetField.retrieve(dataset_field.id)
+        assert_equal(dataset_field, dataset_field2,
+                     "Retrieving SolveBio::DatasetField id " +
+                     "#{dataset_field[:id]} found by all()")
+
+        %w(class_name created_at dataset dataset_id description facets_url
+          name updated_at url).each do |field|
+            assert(dataset_field.member?(field),
+                   "Should find field #{field} in fields #{dataset_field.id}")
+        end
+        facets = dataset_field.facets()
+
+        # We can get small or large numbers like 0 or 4902851621.0
+        assert(facets['total'] >= 0,
+               'facets should have a numeric total field >= 0')
+    end
+end

data/test/test-depository.rb

@@ -0,0 +1,35 @@
+# Test Depository, DepositoryVersions
+
+require_relative './helper'
+class TestDepository < Test::Unit::TestCase
+
+    def test_depositories
+        depos = SolveBio::Depository.all()
+
+        depo = depos[:data][0]
+        assert(depo.member?('id'),
+               'Should be able to get id in depository')
+
+        depo2 = SolveBio::Depository.retrieve(depo.id)
+        assert_equal(depo, depo2,
+                         "Retrieving dataset id #{depo.id} found by all()")
+
+        %w(class_name created_at description external_resources
+           full_name id is_private is_restricted latest_version
+           latest_version_id name title updated_at url versions_count
+           versions_url).each do |field|
+            assert(depo.member?(field),
+                   "Should find field #{field} in depo #{depo.id}")
+        end
+
+        depo_version_id = depo.versions()[:data][0].id
+        depo_version = SolveBio::DepositoryVersion.retrieve(depo_version_id)
+
+        %w(class_name created_at datasets_url depository depository_id
+           description full_name id latest name released released_at
+           title updated_at url).each do |field|
+            assert(depo_version.member?(field),
+                   "Should find field #{field} in depo version")
+        end
+    end
+end

data/test/test-netrc.rb

@@ -7,15 +7,24 @@ require_relative '../lib/credentials'
 # Does .netrc reading and manipulation work?
 class TestNetrc < Test::Unit::TestCase
 
+
     def setup
         @netrc_path_save = ENV["NETRC_PATH"]
-        path = ENV["NETRC_PATH"] = File.join(File.dirname(__FILE__), 'data')
+        path = ENV['NETRC_PATH'] = File.join(File.dirname(__FILE__), 'data')
         FileUtils.cp(File.join(path, 'netrc-save'), File.join(path, '.netrc'))
         File.chmod(0600, "#{path}/.netrc")
+        @old_warn_level = $VERBOSE
+        @old_api_host = SolveBio::API_HOST
+        $VERBOSE = nil
+        SolveBio.const_set(:API_HOST, 'https://api.solvebio.com')
+        $VERBOSE = @old_warn_level
     end
 
     def teardown
         ENV["NETRC_PATH"] = @netrc_path_save
+        $VERBOSE = nil
+        SolveBio.const_set(:API_HOST, @old_api_host)
+        $VERBOSE = @old_warn_level
     end
 
     include SolveBio::Credentials
@@ -25,13 +34,14 @@ class TestNetrc < Test::Unit::TestCase
     end
 
     def test_get_credentials
-        assert_equal ['rocky@example.com', 'shhhh'], get_credentials
+        assert_equal ['rocky@example.com', 'shhhh'], get_credentials.to_a
     end
 
     def test_save_credentials
         new_values = get_credentials.map{|x| x+"abc"}
         save_credentials(*new_values)
-        assert_equal new_values, get_credentials, 'Should append "abc" to creds'
+        assert_equal(new_values, get_credentials.to_a,
+                     'Should append "abc" to creds')
     end
 
     def test_delete_credentials

data/test/test-query-batch.rb

@@ -1,60 +1,40 @@
 #!/usr/bin/env ruby
 $VERBOSE = true
+require 'socket'
 require_relative 'helper'
+require_relative '../lib/resource/main'
 
 class TestQueryBatch < Test::Unit::TestCase
+    def setup
+        @dataset = SolveBio::Dataset.retrieve(TEST_DATASET_NAME)
+    end
 
-    TEST_DATASET_NAME = 'ClinVar/2.0.0-1/Variants'
-
-    if SolveBio::api_key
-
-        def setup
-            begin
-                @dataset = SolveBio::Dataset.retrieve(TEST_DATASET_NAME)
-            rescue SocketError
-                @dataset = nil
-            end
-        end
-
-        def test_invalid_batch_query
-            skip('Are you connected to the Internet?') unless @dataset
-            assert_raise SolveBio::Error do
-                SolveBio::BatchQuery
-                    .new([
-                          @dataset.query(:limit => 1, :fields => [:bogus_field]),
-                          @dataset.query(:limit => 10).filter(:hg19_start__gt => 100000)
-                         ]).execute
-            end
-
-            dataset2 = SolveBio::Dataset.retrieve('HGNC/1.0.0-1/HGNC')
-            results = SolveBio::BatchQuery
+    def test_invalid_batch_query
+        assert_raise SolveBio::Error do
+            SolveBio::BatchQuery
                 .new([
-                      dataset2.query(:limit => 1),
-                      @dataset.query(:limit => 10).filter(:hg19_start => 100000)
+                      @dataset.query(:limit => 1, :fields => [:bogus_field]),
+                      @dataset.query(:limit => 10).filter(:bogus_id__gt => 100000)
                      ]).execute
-            assert_equal(2, results.length)
-
-
-
-        end
-
-        def test_batch_query
-            skip('Are you connected to the Internet?') unless @dataset
-            queries = [
-                       @dataset.query(:limit => 1),
-                       @dataset.query(:limit => 10).filter(:hg19_start__gt => 100000)
-                      ]
-            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
 
+        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)
 
-    else
-        def test_skip
-            skip 'Please set SolveBio::api_key'
-        end
     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

data/test/test-query-paging.rb

@@ -1,122 +1,101 @@
 #!/usr/bin/env ruby
 $VERBOSE = true
+require 'socket'
 require_relative 'helper'
+require_relative '../lib/resource/main'
 
 class TestQueryPaging < Test::Unit::TestCase
 
-    TEST_DATASET_NAME = 'ClinVar/2.0.0-1/Variants'
-
-    if SolveBio::api_key
-
-        def setup
-            begin
-                @dataset = SolveBio::Dataset.retrieve(TEST_DATASET_NAME)
-            rescue SocketError
-                @dataset = nil
-            end
-        end
-
-        def test_query
-            skip('Are you connected to the Internet?') unless @dataset
-            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
+    def setup
+        @dataset = SolveBio::Dataset.retrieve(TEST_DATASET_NAME)
+    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 revers the order of access, to make sure "warmup" is called.
-        def test_limit
-            skip('Are you connected to the Internet?') unless @dataset
-            limit = 10
-            results = @dataset.query(:paging=>true, :limit => limit)
-            assert_equal(results.total, results.length,
-                         'results.total == results.length, paging = true')
-        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
-            skip('Are you connected to the Internet?') unless @dataset
-            limit = 100
-            total = 7
-            results = @dataset.query(:paging => true, :limit => limit).
-                filter(:hg19_start__range => [140000000, 140050000])
+    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.size)
+        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)
+        # 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)
 
-        def test_range
-            skip('Are you connected to the Internet?') unless @dataset
-            limit = 100
-            results = @dataset.query(:paging => true, :limit => limit).
-                filter(:hg19_start__range => [140000000, 140050000])[2..5]
-            assert_equal(3, results.size)
-
-            results = @dataset.query(:paging => true, :limit => limit).
-                filter(:hg19_start__range => [140000000, 140050000])[0..8]
-            assert_equal(7, results.size)
-        end
+        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
-            skip('Are you connected to the Internet?') unless @dataset
-            idx0 = 3
-            idx1 = 5
-
-            query = proc{
-                @dataset.query( :paging => true, :limit => 20).
-                filter(:hg19_start__range => [140000000, 140060000])[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][:hg19_start]
-                id_b = results_slice[i][:hg19_start]
-                assert_equal(id_a, id_b)
-            end
-        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]
+        }
 
-        def test_caching
-            skip('Are you connected to the Internet?') unless @dataset
-            idx0 = 60
-            idx1 = 81
+        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
 
-            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_paging.size)
 
-            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
+        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
 
-    else
-        def test_skip
-            skip 'Please set SolveBio::api_key'
+    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