solvebio 1.5.0

data/solvebio.gemspec

@@ -0,0 +1,75 @@
+## -*- Ruby -*-
+## This is the rakegem gemspec template. Make sure you read and understand
+## all of the comments. Some sections require modification, and others can
+## be deleted if you don't need them. Once you understand the contents of
+## this file, feel free to delete any comments that begin with two hash marks.
+## You can find comprehensive Gem::Specification documentation, at
+## http://docs.rubygems.org/read/chapter/20
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  # s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  # s.rubygems_version = '1.3.5'
+
+  ## Leave these as is they will be modified for you by the rake gemspec task.
+  ## If your rubyforge_project name is different, then edit it and comment out
+  ## the sub! line in the Rakefile
+  s.name              = 'solvebio'
+  s.version           = '1.5.0'
+  s.date              = '2014-08-16'
+
+  ## Make sure your summary is short. The description may be as long
+  ## as you like.
+  s.summary     = "SolveBio Ruby bindings."
+
+  s.description = <<-EOD
+SolveBio is a platform for biomedical datasets. With SolveBio you can
+forget about parsing complex flat files and sifting through cryptic
+datasets. Just use the Ruby Client and API to explore massive
+datasets and automate just about any bioinformatics workflow.
+
+See https://www.solvebio.com/docs/api/ for more information.
+EOD
+
+  ## List the primary authors. If there are a bunch of authors, it's probably
+  ## better to set the email to an email list or something. If you don't have
+  ## a custom homepage, consider using your GitHub URL or the like.
+  s.authors  = ['solvebio.com']
+  s.email    = 'contact@solvebio.com'
+  s.homepage = 'https://www.solvebio.com'
+
+  ## This gets added to the $LOAD_PATH so that 'lib/NAME.rb' can be required as
+  ## require 'NAME.rb' or'/lib/NAME/file.rb' can be as require 'NAME/file.rb'
+  s.require_paths = %w[lib]
+
+  s.required_ruby_version = Gem::Requirement.new(">= 1.9.0")
+
+  ## If your gem includes any executables, list them here.
+  s.executables = ['solvebio.rb']
+  s.default_executable = 'solvebio.rb'
+
+  ## Specify any RDoc options here. You'll want to add your README and
+  ## LICENSE files to the extra_rdoc_files list.
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.extra_rdoc_files = %w[LICENSE]
+
+  ## List your runtime dependencies here. Runtime dependencies are those
+  ## that are needed for an end user to actually USE your code.
+  s.add_dependency('netrc',   '>=0.7.7')
+  # s.add_dependency('openssl', '>=1.1.0')
+
+
+  # There is no way to specify optional dependencies.
+  # s.add_optional_dependency 'launchy' # opens URL in web browser for help
+  # s.add_optional_dependency 'bond'    # better shell command completion
+
+  ## List your development dependencies here. Development dependencies are
+  ## those that are only needed during development
+  # s.add_development_dependency('DEVDEPNAME', [">= 1.1.0", "< 2.0.0"])
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rdoc')
+  s.files = `git ls-files`.split($/)
+
+  ## Test files will be grabbed from the file list. Make sure the path glob
+  ## matches what you actually use.
+  s.test_files = s.files.grep(/^test/)
+end

data/test/data/netrc-save

@@ -0,0 +1,6 @@
+machine foo.bar
+	login a@example.com
+	password secret
+machine api.solvebio.com
+	login rocky@example.com
+	password shhhh

data/test/helper.rb

@@ -0,0 +1,3 @@
+require 'test/unit'
+require_relative '../lib/resource'
+SolveBio.api_key = 'ce68f783a65275d3e81463621d825bad20eb20b0'

data/test/test-auth.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+$VERBOSE = true
+require 'test/unit'
+require 'rbconfig'
+require_relative '../lib/credentials'
+
+class TestAuth < Test::Unit::TestCase
+
+    include SolveBio::Credentials
+
+    def run_it(cmd)
+        output = `#{cmd}`
+        assert_equal 0, $?.to_i, "Should be able to run #{cmd}"
+        output.chomp
+    end
+
+    def setup
+        ruby=RbConfig.ruby
+        @auth_prog = File.join(File.dirname(__FILE__),
+                               '..', 'lib', 'cli', 'auth.rb')
+        @logout_cmd = "#{ruby} #{@auth_prog} logout"
+        @@whoami_cmd = "#{ruby} #{@auth_prog} whoami"
+
+        # Save who I was so we can compare at the end
+        @i_was = run_it @@whoami_cmd
+
+        begin
+            @@creds = get_credentials
+        rescue CredentialsError
+            @@creds = nil
+        end
+    end
+
+    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')
+    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.
+        output = run_it @logout_cmd
+        assert_equal 'You are not logged-in.', output
+        # We should be logged out. Try to get status
+        output = run_it @@whoami_cmd
+        assert_equal 'You are not logged-in.', output
+    end
+end

data/test/test-client.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+$VERBOSE = true
+require 'test/unit'
+require 'fileutils'
+require_relative '../lib/client'
+
+# require 'trepanning'
+
+class TestClient < Test::Unit::TestCase
+
+    def test_get
+        client = SolveBio::Client.new(nil, 'http://google.com')
+        assert client, 'Should be able to create a client'
+
+        # 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')
+        else
+            skip('Are you connected to the Internet? www.google.com is unavailable')
+        end
+    end
+
+end

data/test/test-error.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+$VERBOSE = true
+require 'test/unit'
+require 'net/http'
+require_relative '../lib/errors'
+
+# require 'trepanning'
+
+$errors = []
+
+class FakeLogger
+    def debug(mess)
+        $errors << mess
+    end
+end
+
+class TestError < Test::Unit::TestCase
+
+    def test_error
+        msg = "hi"
+        assert_equal msg, SolveBio::Error.new(nil, msg).to_s, "Error.to_s fn"
+        response = Net::HTTPUnauthorized.new('HTTP 1.1', '404', 'No creds')
+        old_logger = SolveBio.instance_variable_get('@logger')
+        logger = FakeLogger.new
+        SolveBio.instance_variable_set('@logger', logger)
+        old_verbose = $VERBOSE
+        $VERBOSE=false
+        SolveBio::Error.new(response)
+        $VERBOSE=old_verbose
+        assert_equal ["API Response (404): No content."], $errors
+    ensure
+        $VERBOSE = old_verbose if old_verbose
+        SolveBio.instance_variable_set('@logger', old_logger) if old_logger
+
+    end
+end

data/test/test-filter.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+$VERBOSE = true
+require 'test/unit'
+require_relative '../lib/filter'
+
+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__between => 'a')
+        end
+        assert_raises TypeError do
+            SolveBio::Filter.new(:style__between => [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__between, [5, 10]]]>',
+                     SolveBio::Filter.new(:style__between => (5...11)).inspect)
+        assert_equal('<SolveBio::Filter [[:style__between, [5, 10]]]>',
+                     SolveBio::Filter.new(:style__between => (5..10)).inspect)
+
+    end
+
+    def test_range_filter
+        assert_equal('<RangeFilter [{:and=>[["hg38_start__range", ' +
+                     '[32200000, 32500000]], ' +
+                     '["hg38_end__range", [32200000, 32500000]], ' +
+                     '["hg38_chromosome", "13"]]}]>',
+                     SolveBio::RangeFilter.
+                     new("hg38", "13", 32200000, 32500000).inspect)
+    end
+
+    def test_process_filters
+        # FIXME: add more and put in a loop.
+        filters = [[:omid, nil]]
+        expect  = filters
+        assert_equal(expect.inspect,
+                     SolveBio::Filter.process_filters(filters).inspect)
+    end
+
+end

data/test/test-netrc.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+$VERBOSE = true
+require 'test/unit'
+require 'fileutils'
+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')
+        FileUtils.cp(File.join(path, 'netrc-save'), File.join(path, '.netrc'))
+        File.chmod(0600, "#{path}/.netrc")
+    end
+
+    def teardown
+        ENV["NETRC_PATH"] = @netrc_path_save
+    end
+
+    include SolveBio::Credentials
+
+    def test_netrc
+        assert netrc_path, 'Should get a location for .netrc'
+    end
+
+    def test_get_credentials
+        assert_equal ['rocky@example.com', 'shhhh'], get_credentials
+    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'
+    end
+
+    def test_delete_credentials
+        delete_credentials
+        assert_equal nil, get_credentials, 'Should be able to delete credentials'
+    end
+
+end

data/test/test-query-batch.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+$VERBOSE = true
+require_relative 'helper'
+
+class TestQueryBatch < 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_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
+                .new([
+                      dataset2.query(:limit => 1),
+                      @dataset.query(:limit => 10).filter(:hg19_start => 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
+
+
+    else
+        def test_skip
+            skip 'Please set SolveBio::api_key'
+        end
+    end
+
+end

data/test/test-query-init.rb

@@ -0,0 +1,29 @@
+$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

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+$VERBOSE = true
+require_relative 'helper'
+
+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
+
+        # 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_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])
+
+            assert_equal(total, results.size)
+
+            # 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
+            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
+
+        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_caching
+            skip('Are you connected to the Internet?') unless @dataset
+            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
+
+    else
+        def test_skip
+            skip 'Please set SolveBio::api_key'
+        end
+    end
+
+end