bark 0.0.2

data/lib/bark/version.rb

@@ -0,0 +1,3 @@
+class Bark
+  VERSION = "0.0.2"
+end

data/spec/lib/bark_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Bark do
+
+  # TODO: Check that shared tests were built correctly, and warn if not
+
+  context '.request_class - determing request type from method' do
+    specify 'for tol_' do
+      expect(Bark.request_class('tol_about')).to eq(Bark::Request::TreeOfLife)
+      expect(Bark.request_class(:tol_about)).to eq(Bark::Request::TreeOfLife)
+    end
+
+    specify 'for gol_' do
+      expect(Bark.request_class('gol_about')).to eq(Bark::Request::GraphOfLife)
+      expect(Bark.request_class(:gol_about)).to eq(Bark::Request::GraphOfLife)
+    end
+ 
+    specify 'for tnrs_' do
+      expect(Bark.request_class('tnrs_match_names')).to eq(Bark::Request::Tnrs)
+      expect(Bark.request_class(:tnrs_match_names)).to eq(Bark::Request::Tnrs)
+    end
+
+    specify 'for taxonomy_' do
+      expect(Bark.request_class('taxonomy_about')).to eq(Bark::Request::Taxonomy)
+      expect(Bark.request_class(:taxonomy_about)).to eq(Bark::Request::Taxonomy)
+    end
+ 
+    specify 'for studies_' do
+      expect(Bark.request_class('studies_find_studies')).to eq(Bark::Request::Studies)
+      expect(Bark.request_class(:studies_find_studies)).to eq(Bark::Request::Studies)
+      expect(Bark.request_class('get_study')).to eq(Bark::Request::Studies)
+      expect(Bark.request_class(:get_study)).to eq(Bark::Request::Studies)
+    end
+
+    specify 'for something_not_recognized' do
+      expect(Bark.request_class(:something_not_recognized)).to eq(false)
+      expect(Bark.request_class('something_not_recognized')).to eq(false)
+    end
+  end
+
+  context 'convience wrapping methods' do
+    context 'method_missing' do
+      specify 'methods with indeterminable requests classes raise' do
+        expect {Bark.foo}.to raise_error
+      end
+
+      specify 'methods with determinable request classes do not raise' do
+        expect {Bark.get_study()}.to_not raise_error
+      end
+
+      specify 'methods with params do not raise' do
+        expect { Bark.get_study(params: {'study_id' => 'px3454'})}.to_not raise_error
+      end
+
+      specify 'a GET example returns' do
+        expect( Bark.get_study(params: {:study_id => '2113'})['error']).to be_falsey
+      end
+
+    end
+  end
+
+  context 'shared tests' do
+    specify 'are instantiated from a URL' do
+      expect(SharedTestsHelper::SHARED_TESTS.count).to be > 0 
+    end
+
+    context 'SharedTestsHelper::OtTest' do
+      let(:t) { SharedTestsHelper::OtTest.new  }
+
+      specify 'have a name' do
+        expect(t).to respond_to(:name)
+      end
+
+      specify 'reference a function' do
+        expect(t).to respond_to(:method)
+      end
+
+      specify 'provide an input' do
+        expect(t).to respond_to(:input)
+      end
+
+      specify 'expect multiple tests' do
+        expect(t).to respond_to(:tests)
+      end
+    end
+  end
+end 

data/spec/lib/request/graph_of_life_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Bark::Request::GraphOfLife do
+
+ #context 'Ruby/Bark specific implementation' do
+ #  specify 'is written for an API_VERSION' do
+ #    expect( Bark::Request::TreeOfLife::API_VERSION).to eq('v2')
+ #  end
+
+ #  specify 'has an SEARCH_BASE' do
+ #    expect( Bark::Request::TreeOfLife::SEARCH_BASE).to eq('http://devapi.opentreeoflife.org/v2/tree_of_life')
+ #  end
+
+ #  specify 'reference methods by ot API wrapper shared name in METHODS' do 
+ #    expect( Bark::Request::TreeOfLife::METHODS.keys.sort).to eq(%i{tol_about tol_mrca tol_subtree tol_induced_tree}.sort)
+ #  end
+
+ #  context 'building a request URI' do
+ #    specify 'for find_tree_of_life'  do
+ #      a = Bark::Request::TreeOfLife.new(method: :tol_about)
+ #      expect(a.uri.to_s).to eq('http://devapi.opentreeoflife.org/v2/tree_of_life/about')
+ #    end
+
+ #    specify 'for matched_tree_of_life' do
+ #      a = Bark::Request::TreeOfLife.new(method: :tol_mrca)
+ #      expect(a.uri.to_s).to eq('http://devapi.opentreeoflife.org/v2/tree_of_life/mrca')
+ #    end
+ #  end
+
+ #  context 'basic use, for :about, in a response' do
+ #    specify 'works' do
+ #      a = Bark::Request::TreeOfLife.new(method: :tol_about, params: {})
+ #      b = Bark::Response.new(request: a)
+ #      expect(b.request_succeeded?).to be(true)
+ #      expect(b.json.keys.include?('root_node_id')).to be(true)
+ #    end
+ #  end
+
+    context 'shared tests' do
+      run_tests(Bark::Request::GraphOfLife, SharedTestsHelper::SHARED_TESTS['graph_of_life'])
+    end
+
+ # end
+end 

data/spec/lib/request/studies_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Bark::Request::Studies do
+
+  subject { Bark::Request::Studies }
+
+  context 'Ruby/Bark specific implementation' do
+    specify 'is written for an API_VERSION' do
+      expect( Bark::Request::Studies::API_VERSION).to eq('v2')
+    end
+
+    specify 'has an SEARCH_BASE' do
+      expect( Bark::Request::Studies::SEARCH_BASE).to eq('http://devapi.opentreeoflife.org/v2')
+    end
+
+    specify 'has an default FORMAT' do
+      expect( Bark::Request::Studies::FORMAT).to eq('json')
+    end
+
+    specify 'reference methods by ot API wrapper shared name in METHODS' do 
+      expect( Bark::Request::Studies::METHODS.keys.sort).to eq([:studies_find_studies, :studies_find_trees, :get_study, :get_study_tree, :studies_properties].sort)
+    end
+
+    context 'building a request URI' do
+      specify 'for find_studies'  do
+        a = Bark::Request::Studies.new(method: :studies_find_studies)
+        expect(a.uri.to_s).to eq('http://devapi.opentreeoflife.org/v2/studies/find_studies')
+      end
+
+      specify 'for find_trees' do
+        a = Bark::Request::Studies.new(method: :studies_find_trees)
+        expect(a.uri.to_s).to eq('http://devapi.opentreeoflife.org/v2/studies/find_trees')
+      end
+
+      specify 'for study' do
+        id = 'pg_1144' 
+        a = Bark::Request::Studies.new(method: :get_study, params: {study_id: id})
+        expect(a.uri.to_s).to eq("http://devapi.opentreeoflife.org/v2/study/#{id}")
+      end
+
+      specify 'for study_tree' do
+        id = 'pg_1144' 
+        tree = 'tree2324'
+        a = Bark::Request::Studies.new(method: :get_study_tree, params: {study_id: id, tree_id: tree })
+        expect(a.uri.to_s).to eq("http://devapi.opentreeoflife.org/v2/study/#{id}/tree/#{tree}")
+      end
+    end
+
+    context 'payload' do
+      specify 'params are persisted' do
+        params = {value: 'Garcinia', property: 'ot:ottTaxonName'}
+        a = Bark::Request::Studies.new(method: :studies_find_trees, params: params )
+        expect(a.params).to eq(params)
+        expect(a.json_payload).to eq(params.to_json)
+        expect(a.valid?).to be(true)
+      end
+
+    end
+
+    context 'basic use, for :studies_find_trees, in a response' do
+      specify 'works' do
+        a = Bark::Request::Studies.new(method: :studies_find_trees, params: {value: 'Garcinia', property: 'ot:ottTaxonName'})
+        b = Bark::Response.new(request: a)
+        expect(b.request_succeeded?).to be(true)
+        expect(b.json.keys.include?('matched_studies')).to be(true)
+      end
+    end
+
+    context 'shared tests' do
+      run_tests(Bark::Request::Studies, SharedTestsHelper::SHARED_TESTS['studies'])
+    end
+
+  end
+end 

data/spec/lib/request/taxonomy_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Bark::Request::Taxonomy do
+
+ #context 'Ruby/Bark specific implementation' do
+ #  specify 'is written for an API_VERSION' do
+ #    expect( Bark::Request::TreeOfLife::API_VERSION).to eq('v2')
+ #  end
+
+ #  specify 'has an SEARCH_BASE' do
+ #    expect( Bark::Request::TreeOfLife::SEARCH_BASE).to eq('http://devapi.opentreeoflife.org/v2/tree_of_life')
+ #  end
+
+ #  specify 'reference methods by ot API wrapper shared name in METHODS' do 
+ #    expect( Bark::Request::TreeOfLife::METHODS.keys.sort).to eq(%i{tol_about tol_mrca tol_subtree tol_induced_tree}.sort)
+ #  end
+
+ #  context 'building a request URI' do
+ #    specify 'for find_tree_of_life'  do
+ #      a = Bark::Request::TreeOfLife.new(method: :tol_about)
+ #      expect(a.uri.to_s).to eq('http://devapi.opentreeoflife.org/v2/tree_of_life/about')
+ #    end
+
+ #    specify 'for matched_tree_of_life' do
+ #      a = Bark::Request::TreeOfLife.new(method: :tol_mrca)
+ #      expect(a.uri.to_s).to eq('http://devapi.opentreeoflife.org/v2/tree_of_life/mrca')
+ #    end
+ #  end
+
+ #  context 'basic use, for :about, in a response' do
+ #    specify 'works' do
+ #      a = Bark::Request::TreeOfLife.new(method: :tol_about, params: {})
+ #      b = Bark::Response.new(request: a)
+ #      expect(b.request_succeeded?).to be(true)
+ #      expect(b.json.keys.include?('root_node_id')).to be(true)
+ #    end
+ #  end
+
+    context 'shared tests' do
+      run_tests(Bark::Request::Taxonomy, SharedTestsHelper::SHARED_TESTS['taxonomy'])
+    end
+
+ #  end
+end 

data/spec/lib/request/tnrs_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Bark::Request::Tnrs do
+
+ #context 'Ruby/Bark specific implementation' do
+ #  specify 'is written for an API_VERSION' do
+ #    expect( Bark::Request::TreeOfLife::API_VERSION).to eq('v2')
+ #  end
+
+ #  specify 'has an SEARCH_BASE' do
+ #    expect( Bark::Request::TreeOfLife::SEARCH_BASE).to eq('http://devapi.opentreeoflife.org/v2/tree_of_life')
+ #  end
+
+ #  specify 'reference methods by ot API wrapper shared name in METHODS' do 
+ #    expect( Bark::Request::TreeOfLife::METHODS.keys.sort).to eq(%i{tol_about tol_mrca tol_subtree tol_induced_tree}.sort)
+ #  end
+
+ #  context 'building a request URI' do
+ #    specify 'for find_tree_of_life'  do
+ #      a = Bark::Request::TreeOfLife.new(method: :tol_about)
+ #      expect(a.uri.to_s).to eq('http://devapi.opentreeoflife.org/v2/tree_of_life/about')
+ #    end
+
+ #    specify 'for matched_tree_of_life' do
+ #      a = Bark::Request::TreeOfLife.new(method: :tol_mrca)
+ #      expect(a.uri.to_s).to eq('http://devapi.opentreeoflife.org/v2/tree_of_life/mrca')
+ #    end
+ #  end
+
+ #  context 'basic use, for :about, in a response' do
+ #    specify 'works' do
+ #      a = Bark::Request::TreeOfLife.new(method: :tol_about, params: {})
+ #      b = Bark::Response.new(request: a)
+ #      expect(b.request_succeeded?).to be(true)
+ #      expect(b.json.keys.include?('root_node_id')).to be(true)
+ #    end
+ #  end
+
+    context 'shared tests' do
+      run_tests(Bark::Request::Tnrs, SharedTestsHelper::SHARED_TESTS['tnrs'])
+    end
+
+ # end
+end 

data/spec/lib/request/tree_of_life_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Bark::Request::TreeOfLife do
+
+  context 'Ruby/Bark specific implementation' do
+    specify 'is written for an API_VERSION' do
+      expect( Bark::Request::TreeOfLife::API_VERSION).to eq('v2')
+    end
+
+    specify 'has an SEARCH_BASE' do
+      expect( Bark::Request::TreeOfLife::SEARCH_BASE).to eq('http://devapi.opentreeoflife.org/v2/tree_of_life')
+    end
+
+    specify 'reference methods by ot API wrapper shared name in METHODS' do 
+      expect( Bark::Request::TreeOfLife::METHODS.keys.sort).to eq(%i{tol_about tol_mrca tol_subtree tol_induced_subtree}.sort)
+    end
+
+    context 'building a request URI' do
+      specify 'for find_tree_of_life'  do
+        a = Bark::Request::TreeOfLife.new(method: :tol_about)
+        expect(a.uri.to_s).to eq('http://devapi.opentreeoflife.org/v2/tree_of_life/about')
+      end
+
+      specify 'for matched_tree_of_life' do
+        a = Bark::Request::TreeOfLife.new(method: :tol_mrca)
+        expect(a.uri.to_s).to eq('http://devapi.opentreeoflife.org/v2/tree_of_life/mrca')
+      end
+    end
+
+    context 'basic use, for :about, in a response' do
+      specify 'works' do
+        a = Bark::Request::TreeOfLife.new(method: :tol_about, params: {})
+        b = Bark::Response.new(request: a)
+        expect(b.request_succeeded?).to be(true)
+        expect(b.json.keys.include?('root_node_id')).to be(true)
+      end
+    end
+
+    context 'shared tests' do
+      run_tests(Bark::Request::TreeOfLife, SharedTestsHelper::SHARED_TESTS['tree_of_life'])
+    end
+
+  end
+end 

data/spec/lib/request_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Bark::Request do
+
+  let(:request) {Bark::Request.new}
+
+  context 'attributes include' do
+    specify '#payload' do
+      expect(request).to respond_to(:payload)  
+    end
+  end
+
+  context 'constants include' do
+    specify 'BASE_URL' do
+      expect( Bark::Request::BASE_URL).to eq('http://devapi.opentreeoflife.org')
+    end
+  end
+
+ end 
+

data/spec/lib/response_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Bark::Response do
+
+  subject { Bark::Response }
+
+  let(:uri) { URI('http://devapi.opentreeoflife.org/v2/taxonomy/about') }
+  let(:request) {
+    r = instance_double('Bark::Request')
+    allow(r).to receive(:uri).and_return( uri ) 
+    allow(r).to receive(:valid?).and_return(true)
+    allow(r).to receive(:json_payload).and_return({}.to_json)
+    allow(r).to receive(:method).and_return(:studies_properties)
+    r
+  }
+  
+  specify 'a good request returns' do
+    expect(Bark::Response.new(request: request)).to be_truthy
+  end
+
+end 
+

data/spec/lib/shared_tests_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+# Meta-tests for sanity
+describe SharedTestsHelper do
+
+  specify 'are instantiated from a URL' do
+    expect(SharedTestsHelper::SHARED_TESTS.count).to be > 0 
+  end
+
+  context 'SharedTestsHelper::OtTest' do
+    let(:t) { SharedTestsHelper::OtTest.new  }
+
+    specify 'have a name' do
+      expect(t).to respond_to(:name)
+    end
+
+    specify 'reference a function' do
+      expect(t).to respond_to(:method)
+    end
+
+    specify 'provide an input' do
+      expect(t).to respond_to(:input)
+    end
+
+    specify 'expect multiple tests' do
+      expect(t).to respond_to(:tests)
+    end
+  end
+end 

data/spec/shared_tests.rb

@@ -0,0 +1,87 @@
+# Methods that call shared tests.
+
+def get_response(request)
+
+end
+
+def run_tests(request_class, tests)
+  tests.each do |t|
+    context t.name do
+      r = request_class.new(method: t.method, params: t.input)
+
+      t.tests.keys.each do |k|
+       
+        # we don't need a response 
+        if k == 'parameters_error'
+          specify k.to_s do
+            msg = t.tests[k][1]
+            expect(r.valid?).to eq(false), msg
+            # TODO: possibly extend to see raised error  
+          end
+
+        # we do need a response
+        else
+          response = Bark::Response.new(request: r)
+          case k
+          when 'of_type'
+            specify k.to_s do
+              of_type_test(response, t, t.tests[k][1]) 
+            end
+          when 'equals'
+            t.tests[k].each_with_index do |subtest, i|
+              key = subtest[0][0]
+              value = subtest[0][1] 
+              msg = subtest[1]
+              specify "#{k} #{key}: #{value} (#{i})" do 
+                expect(response.json[key]).to eq(value), msg
+              end
+            end
+          when 'contains'
+            t.tests[k].each_with_index do |subtest, i|
+              key = subtest[0]
+              msg = subtest[1]
+              specify "#{k} #{key} (#{i})" do 
+                expect(response.json[key]).to be_truthy
+              end
+            end
+          when 'length_greater_than'
+            t.tests[k].each_with_index do |subtest, i|
+              key = subtest[0][0]
+              len = subtest[0][1].to_i
+              msg = subtest[1]
+              specify "#{k} #{key}: #{len} (#{i})" do 
+                expect(response.json[key].length > len ).to be(true), msg
+              end
+            end
+          when 'deep_equals' 
+            t.tests[k].each_with_index do |subtest, i|
+              sub_response = response.json
+              # could eval a string sensu python too
+              subtest[0][0].each do |k|
+                sub_response = sub_response[k]
+              end
+              value = subtest[0][1]
+              msg = subtest[1]
+              specify "#{k} #{subtest[0][0]}: #{value} (#{i})" do 
+                expect(sub_response).to eq(value), msg
+              end
+            end
+          when 'contains_error'
+            specify "#{k}" do 
+              msg = t.tests[k]
+              expect(response.json['error']).to be_truthy, msg 
+            end
+          else
+            pending "Test engine for [ #{k} ] not yet written."
+          end
+        end
+      end
+    end
+  end
+end
+
+
+def of_type_test(response, ot_test_instance, message)
+  expect(response.result.class).to eq(ot_test_instance.result_type), message
+end
+