sunstone 5.0.0.beta3 → 5.0.0.1

data/test/active_record/preload_test.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+class ActiveRecord::PreloadTest < Minitest::Test
+  
+  test '#preload' do
+    webmock(:get, "/fleets").to_return(body: [{id: 1}].to_json)
+    webmock(:get, "/ships", where: {fleet_id: 1}).to_return(body: [{id: 1, fleet_id: 1}].to_json)
+    webmock(:get, "/sailors_ships", where: {ship_id: 1}).to_return(body: [{ship_id: 1, sailor_id: 1}].to_json)
+    webmock(:get, "/sailors", where: {id: 1}).to_return(body: [{id: 1}].to_json)
+    
+    fleets = Fleet.preload(:ships => :sailors)
+    assert_equal [1], fleets.map(&:id)
+    assert_equal [1], fleets.first.ships.map(&:id)
+  end
+  
+end

data/test/active_record/query_test.rb

@@ -0,0 +1,91 @@
+require 'test_helper'
+
+class ActiveRecord::QueryTest < Minitest::Test
+
+  test '::find' do
+    webmock(:get, "/ships", { where: {id: 42}, limit: 1 }).to_return(body: [{id: 42}].to_json)
+    
+    assert_equal 42, Ship.find(42).id
+  end
+  
+  test '::first' do
+    webmock(:get, "/ships", { limit: 1, order: [{id: :asc}] }).to_return(body: [].to_json)
+    
+    assert_nil Ship.first
+  end
+  
+  test '::last' do
+    webmock(:get, "/ships", { limit: 1, order: [{id: :desc}] }).to_return(body: [].to_json)
+    
+    assert_nil Ship.last
+  end
+  
+  test '::find_each' do
+    webmock(:get, "/ships", { limit: 1000, order: [{id: :asc}] }).to_return(body: [].to_json)
+    
+    assert_nil Ship.find_each { |s| s }
+  end
+  
+  test '::where on columns' do
+    webmock(:get, "/ships", { where: {id: 10} }).to_return(body: [].to_json)
+    
+    assert_equal [], Ship.where(:id => 10).to_a
+  end
+  
+  test '::where column is nil' do
+    webmock(:get, "/ships", { where: {leased_at: nil} }).to_return(body: [].to_json)
+
+    assert_equal [], Ship.where(:leased_at => nil).to_a
+  end
+  
+  test '::where on belongs_to relation' do
+    webmock(:get, "/ships", where: {fleet: { id: {eq: 1} } }).to_return(body: [].to_json)
+
+    assert_equal [], Ship.where(:fleet => {id: 1}).to_a
+  end
+  
+  test '::where on has_many relation' do
+    webmock(:get, "/fleets", where: {ships: { id: {eq: 1} } }).to_return(body: [].to_json)
+
+    assert_equal [], Fleet.where(:ships => {id: 1}).to_a
+  end
+  
+  test '::where on has_and_belongs_to_many relation' do
+    webmock(:get, "/ships", where: {sailors: { id: {eq: 1} } }).to_return(body: [].to_json)
+
+    assert_equal [], Ship.where(:sailors => {id: 1}).to_a
+  end
+  
+  # Polymorphic
+  test '::where on a has_many throught a polymorphic source' do
+    webmock(:get, "/ships", where: { nations: { id: {eq: 1} } }, limit: 10).to_return(body: [].to_json)
+    
+    assert_equal [], Ship.where(nations: {id: 1}).limit(10).to_a
+  end
+  ### end polymorphic test
+  
+  test '::count' do
+    webmock(:get, "/ships/calculate", select: [{count: "*"}]).to_return(body: [10].to_json)
+    
+    assert_equal 10, Ship.count
+  end
+  
+  test '::count(:column)' do
+    webmock(:get, "/ships/calculate", select: [{count: "id"}]).to_return(body: [10].to_json)
+    
+    assert_equal 10, Ship.count(:id)
+  end
+  
+  test '::sum(:column)' do
+    webmock(:get, "/ships/calculate", select: [{sum: "weight"}]).to_return(body: [10].to_json)
+    
+    assert_equal 10, Ship.sum(:weight)
+  end
+  
+  # Relation test
+  
+  test '#to_sql' do
+    assert_equal "SELECT ships.* FROM ships WHERE ships.id = 10", Ship.where(:id => 10).to_sql
+  end
+  
+end

data/test/models.rb

@@ -0,0 +1,91 @@
+
+
+WebMock::StubRegistry.instance.global_stubs.push(
+  WebMock::RequestStub.new(:get, "http://example.com/ping").to_return(
+    body: "pong"
+  ),
+  
+  WebMock::RequestStub.new(:get, "http://example.com/tables").to_return(
+    body: %w(ships fleets sailors).to_json
+  ),
+  
+  WebMock::RequestStub.new(:get, "http://example.com/ships/schema").to_return(
+    body: {
+      id: {type: 'integer', primary_key: true, null: false, array: false},
+      fleet_id: {type: 'integer', primary_key: false, null: true, array: false},
+      name: {type: 'string', primary_key: false, null: true, array: false}
+    }.to_json
+  ),
+  
+  WebMock::RequestStub.new(:get, "http://example.com/fleets/schema").to_return(
+    body: {
+      id: {type: 'integer', primary_key: true, null: false, array: false},
+      name: {type: 'string', primary_key: false, null: true, array: false}
+    }.to_json
+  ),
+  
+  WebMock::RequestStub.new(:get, "http://example.com/sailors/schema").to_return(
+    body: {
+      id: {type: 'integer', primary_key: true, null: false, array: false},
+      name: {type: 'string', primary_key: false, null: true, array: false}
+    }.to_json
+  ),
+  
+  WebMock::RequestStub.new(:get, "http://example.com/sailors_ships/schema").to_return(
+    body: {
+      sailor_id: {type: 'integer', primary_key: false, null: false, array: false},
+      ship_id: {type: 'integer', primary_key: false, null: true, array: false}
+    }.to_json
+  ),
+  
+  WebMock::RequestStub.new(:get, "http://example.com/countries/schema").to_return(
+    body: {
+      id: {type: 'integer', primary_key: true, null: false, array: false},
+      name: {type: 'string', primary_key: false, null: true, array: false}
+    }.to_json
+  ),
+  
+  WebMock::RequestStub.new(:get, "http://example.com/ownerships/schema").to_return(
+    body: {
+      country_id: {type: 'integer', primary_key: false, null: false, array: false},
+      asset_type: {type: 'string', primary_key: false, null: false, array: false},
+      asset_id:   {type: 'integer', primary_key: false, null: true, array: false}
+    }.to_json
+  )
+)
+
+class ExampleRecord < ActiveRecord::Base
+  self.abstract_class = true
+end
+
+ExampleRecord.establish_connection(
+  adapter: 'sunstone',
+  url: 'http://example.com'
+)
+
+class Fleet < ExampleRecord
+  has_many :ships
+end
+
+class Ship < ExampleRecord
+  belongs_to :fleet
+  
+  has_and_belongs_to_many :sailors
+  
+  has_many :ownerships, as: :asset
+  has_many :nations, through: :ownerships, source: :country, inverse_of: :ships
+end
+
+class Sailor < ExampleRecord
+  has_and_belongs_to_many :ships
+end
+
+class Country < ExampleRecord
+  has_many :ownerships
+  has_many :fleets, through: :ownerships
+end
+
+class Ownership < ExampleRecord
+  belongs_to :country
+  belongs_to :asset, polymorphic: true
+end

data/test/sunstone/connection/configuration_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+class Sunstone::Connection::ConfigurationTest < Minitest::Test
+
+  test "setting the url sets the api_key" do
+    connection = Sunstone::Connection.new(url: 'http://my_api_key@localhost')
+    assert_equal('my_api_key', connection.api_key)
+  end
+
+  test "setting the url sets the host" do
+    connection = Sunstone::Connection.new(url: 'https://example.com')
+    assert_equal('example.com', connection.host)
+  end
+
+  test "setting the url sets the port" do
+    connection = Sunstone::Connection.new(url: 'http://localhost')
+    assert_equal(80, connection.port)
+
+    connection = Sunstone::Connection.new(url: 'https://localhost')
+    assert_equal(443, connection.port)
+    
+    connection = Sunstone::Connection.new(url: 'https://localhost:4321')
+    assert_equal(4321, connection.port)
+  end
+
+  test "setting the url sets the use_ssl option" do
+    connection = Sunstone::Connection.new(url: 'http://localhost')
+    assert_equal(false, connection.use_ssl)
+    
+    connection = Sunstone::Connection.new(url: 'https://localhost')
+    assert_equal(true, connection.use_ssl)
+  end
+  
+  test "setting the user_agent appends it to the User-Agent" do
+    connection = Sunstone::Connection.new(url: 'http://localhost')
+    assert_equal("Sunstone/#{Sunstone::VERSION} Ruby/#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} #{RUBY_PLATFORM}", connection.user_agent)
+    
+    connection = Sunstone::Connection.new(url: 'http://localhost', user_agent: "MyGem/3.14")
+    assert_equal("MyGem/3.14 Sunstone/#{Sunstone::VERSION} Ruby/#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} #{RUBY_PLATFORM}", connection.user_agent)
+  end
+  
+end
+
+

data/test/sunstone/connection/cookie_store_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+class Sunstone::Connection::CookieStoreTest < Minitest::Test
+
+  test '#send_request(#<Net::HTTPRequest) adds cookies to the cookie store if present' do
+    store = CookieStore::HashStore.new
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    stub_request(:get, "http://testhost.com/test").to_return(:body => 'get', :headers => {'Set-Cookie' => 'foo=bar; Max-Age=3600'})
+
+    Sunstone::Connection.with_cookie_store(store) { connection.get('/test') }
+    
+    assert_equal 1, store.instance_variable_get(:@domains).size
+    assert_equal 1, store.instance_variable_get(:@domains)['testhost.com'].size
+    assert_equal 1, store.instance_variable_get(:@domains)['testhost.com']['/test'].size
+    assert_equal 'bar', store.instance_variable_get(:@domains)['testhost.com']['/test']['foo'].value
+  end
+  
+  test '#send_request(#<Net::HTTPRequest) sends cookie header if cookie store is present' do
+    store = CookieStore::HashStore.new
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    stub_request(:get, "http://testhost.com/test").to_return(
+      headers: {
+        'Set-Cookie' => 'foo=bar; Path="/" Max-Age=3600'
+      },
+      body: 'get'
+    )
+    cookie_stub = stub_request(:get, "http://testhost.com/verify").with { |req|
+      req.headers['Cookie'] == 'foo=bar'
+    }.to_return(body: 'verify')
+    
+    Sunstone::Connection.with_cookie_store(store) { connection.get('/test') }
+    Sunstone::Connection.with_cookie_store(store) { connection.get('/verify') }
+    
+    assert_requested(cookie_stub)
+  end
+  
+end

data/test/sunstone/connection/request_helper_test.rb

@@ -0,0 +1,105 @@
+require 'test_helper'
+
+class Sunstone::Connection::RequestHelpersTest < Minitest::Test
+
+  # Sunstone.get ==============================================================
+
+  test '#get(path)' do
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    stub_request(:get, "http://testhost.com/test").to_return(:body => "get")
+
+    assert_equal('get', connection.get('/test').body)
+  end
+
+  test '#get(path, params) with params as string' do
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    stub_request(:get, "http://testhost.com/test").with(:query => {'key' => 'value'}).to_return(:body => "get")
+
+    assert_equal 'get', connection.get('/test', 'key=value').body
+  end
+
+  test '#get(path, params) with params as hash' do
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    stub_request(:get, "http://testhost.com/test").with(:query => {'key' => 'value'}).to_return(:body => "get")
+
+    assert_equal 'get', connection.get('/test', {:key => 'value'}).body
+  end
+
+  test '#get(path, &block)' do
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    stub_request(:get, "http://testhost.com/test").to_return(:body => 'get')
+
+    connection.get('/test') do |response|
+      assert_equal 'get', response.body
+    end
+  end
+
+  # Sunstone.post =============================================================
+
+  test '#post(path)' do
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    stub_request(:post, "http://testhost.com/test").to_return(:body => "post")
+
+    assert_equal('post', connection.post('/test').body)
+  end
+
+  test '#post(path, body)' do
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    stub_request(:post, "http://testhost.com/test").with(:body => 'body').to_return(:body => "post")
+
+    assert_equal('post', connection.post('/test', 'body').body)
+  end
+
+  test '#post(path, &block)' do
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    stub_request(:post, "http://testhost.com/test").to_return(:body => 'post')
+
+    connection.post('/test') do |response|
+      assert_equal 'post', response.body
+    end
+  end
+
+  # Sunstone.put ==============================================================
+
+  test '#put(path)' do
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    stub_request(:put, "http://testhost.com/test").to_return(:body => "put")
+
+    assert_equal('put', connection.put('/test').body)
+  end
+
+  test '#put(path, body)' do
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    stub_request(:put, "http://testhost.com/test").with(:body => 'body').to_return(:body => "put")
+
+    assert_equal('put', connection.put('/test', 'body').body)
+  end
+
+  test '#put(path, &block)' do
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    stub_request(:put, "http://testhost.com/test").to_return(:body => 'put')
+
+    connection.put('/test') do |response|
+      assert_equal 'put', response.body
+    end
+  end
+
+  # Sunstone.delete ===========================================================
+
+  test '#delete' do
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    stub_request(:delete, "http://testhost.com/test").to_return(:body => "delete")
+
+    assert_equal('delete', connection.delete('/test').body)
+  end
+
+  test '#delete(path, &block)' do
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    stub_request(:delete, "http://testhost.com/test").to_return(:body => 'delete')
+
+    connection.delete('/test') do |response|
+      assert_equal 'delete', response.body
+    end
+  end
+
+end

data/test/sunstone/connection/send_request_test.rb

@@ -0,0 +1,164 @@
+require 'test_helper'
+
+class Sunstone::Connection::SendRequestTest < Minitest::Test
+
+  test '#send_request(#<Net::HTTPRequest>) includes the api-key header when present' do
+    connection = Sunstone::Connection.new(url: "http://my_api_key@example.com")
+    
+    test_stub = stub_request(:get, "http://example.com/verify").with { |req|
+      req.headers['Api-Key'] == 'my_api_key'
+    }
+    connection.get('/verify')
+    assert_requested(test_stub)
+  end
+  
+  test '#send_request(#<Net::HTTPRequest>) includes the user_agent' do
+    connection = Sunstone::Connection.new(url: "http://example.com")
+    
+    test_stub = stub_request(:get, "http://example.com/verify").with { |req|
+      req.headers['User-Agent'] =~ /Sunstone\/\S+ Ruby\/\S+ \S+/
+    }
+    connection.get('/verify')
+    assert_requested(test_stub)
+    
+    # Custom Agent
+    connection = Sunstone::Connection.new(url: "http://example.com", user_agent: "MyClient/2")
+    
+    test_stub = stub_request(:get, "http://example.com/verify").with { |req|
+      req.headers['User-Agent'] =~ /MyClient\/2 Sunstone\/\S+ Ruby\/\S+ \S+/
+    }
+    connection.get('/verify')
+    assert_requested(test_stub)
+  end
+  
+  test '#send_request(#<Net::HTTPRequest>)' do
+    stub_request(:get, "http://testhost.com/test").to_return(body: 'get')
+
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    assert_equal('get', connection.send_request(Net::HTTP::Get.new('/test')).body)
+  end
+
+  test '#send_request(#<Net::HTTPRequest>, body) with string body' do
+    stub_request(:post, "http://testhost.com/test").with(
+      body: '{"key":"value"}'
+    ).to_return(
+      body: "post"
+    )
+
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    assert_equal('post', connection.send_request(Net::HTTP::Post.new('/test'), '{"key":"value"}').body)
+  end
+
+  test '#send_request(#<Net::HTTPRequest>, body) with IO body' do
+    stub_request(:post, "http://testhost.com/test").with { |request|
+      request.headers['Transfer-Encoding'] == "chunked" && request.body == '{"key":"value"}'
+    }.to_return(:body => "post")
+
+    rd, wr = IO.pipe
+    wr.write('{"key":"value"}')
+    wr.close
+
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    assert_equal('post', connection.send_request(Net::HTTP::Post.new('/test'), rd).body)
+  end
+
+  test '#send_request(#<Net::HTTPRequest>, body) with Ruby Object body' do
+    stub_request(:post, "http://testhost.com/test").with(body: '{"key":"value"}').to_return(body: "post")
+
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    assert_equal('post', connection.send_request(Net::HTTP::Post.new('/test'), {:key => 'value'}).body)
+  end
+
+  test '#send_request(#<Net::HTTPRequest>) raises Sunstone::Exceptions on non-200 responses' do
+    stub_request(:get, "http://testhost.com/400").to_return(status: 400)
+    stub_request(:get, "http://testhost.com/401").to_return(status: 401)
+    stub_request(:get, "http://testhost.com/403").to_return(status: 403)
+    stub_request(:get, "http://testhost.com/404").to_return(status: 404)
+    stub_request(:get, "http://testhost.com/410").to_return(status: 410)
+    stub_request(:get, "http://testhost.com/422").to_return(status: 422)
+    stub_request(:get, "http://testhost.com/450").to_return(status: 450)
+    stub_request(:get, "http://testhost.com/503").to_return(status: 503)
+    stub_request(:get, "http://testhost.com/550").to_return(status: 550)
+
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    assert_raises(Sunstone::Exception::BadRequest)   { connection.send_request(Net::HTTP::Get.new('/400')) }
+    assert_raises(Sunstone::Exception::Unauthorized) { connection.send_request(Net::HTTP::Get.new('/401')) }
+    assert_raises(Sunstone::Exception::Forbidden) { connection.send_request(Net::HTTP::Get.new('/403')) }
+    assert_raises(Sunstone::Exception::NotFound)     { connection.send_request(Net::HTTP::Get.new('/404')) }
+    assert_raises(Sunstone::Exception::Gone)         { connection.send_request(Net::HTTP::Get.new('/410')) }
+    assert_raises(Sunstone::Exception::ApiVersionUnsupported) { connection.send_request(Net::HTTP::Get.new('/422')) }
+    assert_raises(Sunstone::Exception)               { connection.send_request(Net::HTTP::Get.new('/450')) }
+    assert_raises(Sunstone::Exception::ServiceUnavailable)    { connection.send_request(Net::HTTP::Get.new('/503')) }
+    assert_raises(Sunstone::Exception)               { connection.send_request(Net::HTTP::Get.new('/550')) }
+  end
+
+  test '#send_request(#<Net::HTTPRequest>, &block) returns value returned from &block' do
+    stub_request(:get, "http://testhost.com/test").to_return(body: 'get')
+
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    value = connection.send_request(Net::HTTP::Get.new('/test')) do |response|
+      3215
+    end
+
+    assert_equal 3215, value
+  end
+
+  test '#send_request(#<Net::HTTPRequest>, &block)' do
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    stub_request(:get, "http://testhost.com/test").to_return(body: 'get')
+
+    connection.send_request(Net::HTTP::Get.new('/test')) do |response|
+      assert_equal 'get', response.body
+    end
+
+    # make sure block is not called when not in valid_response_codes
+    stub_request(:get, "http://testhost.com/test").to_return(status: 401, body: 'get')
+
+    assert_raises(Sunstone::Exception::Unauthorized) {
+      connection.send_request(Net::HTTP::Get.new('/test')) do |response|
+        raise Sunstone::Exception, 'Should not get here'
+      end
+    }
+  end
+
+  test '#send_request(#<Net::HTTPRequest>, &block) with block reading chunks' do
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    
+    rd, wr = IO.pipe
+    rd = Net::BufferedIO.new(rd)
+    wr.write(<<-DATA.gsub(/^ +/, '').gsub(/\n/, "\r\n"))
+      HTTP/1.1 200 OK
+      Content-Length: 5
+
+      hello
+    DATA
+
+    res = Net::HTTPResponse.read_new(rd)
+    mock_connection = mock('connection')
+    mock_connection.stubs(:request).yields(res)
+    connection.instance_variable_set(:@connection, mock_connection)
+
+    res.reading_body(rd, true) do
+      connection.send_request(Net::HTTP::Get.new('/test')) do |response|
+        response.read_body do |chunk|
+          assert_equal('hello', chunk)
+        end
+      end
+    end
+  end
+  
+  # TODO: support multple depreaction-notice headers
+  test 'deprecation warning printed when deprecation header returned' do
+    connection = Sunstone::Connection.new(url: "http://testhost.com")
+    
+    stub_request(:get, "http://testhost.com/test").to_return(
+      body: 'get',
+      headers: { 'Deprecation-Notice': 'my deprecation message' }
+    )
+    
+    ActiveSupport::Deprecation.expects(:warn).with('my deprecation message')
+    
+    connection.send_request(Net::HTTP::Get.new('/test'))
+  end
+  
+end