sunstone 6.1.0.2 → 7.0.0

data/test/active_record/query/count_test.rb

@@ -1,51 +0,0 @@
-require 'test_helper'
-
-class ActiveRecord::QueryCountTest < ActiveSupport::TestCase
-
-  schema do
-    create_table "ships", limit: 100 do |t|
-      t.string   "name",                    limit: 255
-    end
-  end
-  
-  class Fleet < ActiveRecord::Base
-    has_many :ships
-  end
-
-  class Ship < ActiveRecord::Base
-    belongs_to :fleet
-  end
-
-  test '::count' do
-    webmock(:get, "/ships/calculate", select: [{count: "*"}], limit: 100, offset: 0).to_return({
-      body: [10].to_json
-    })
-
-    assert_equal 10, Ship.count
-  end
-
-  test '::count(:column)' do
-    webmock(:get, "/ships/calculate", select: [{count: "id"}], limit: 100, offset: 0).to_return({
-      body: [10].to_json
-    })
-
-    assert_equal 10, Ship.count(:id)
-  end
-
-  test '::count with eager_load' do
-    webmock(:get, "/ships/calculate", select: [{count: "id"}], limit: 100, offset: 0).to_return({
-      body: [10].to_json
-    })
-
-    assert_equal 10, Ship.eager_load(:fleet).count
-  end
-
-  test '::sum(:column)' do
-    webmock(:get, "/ships/calculate", select: [{sum: "weight"}], limit: 100, offset: 0).to_return({
-      body: [10].to_json
-    })
-
-    assert_equal 10, Ship.sum(:weight)
-  end
-
-end

data/test/active_record/query/distinct_test.rb

@@ -1,30 +0,0 @@
-require 'test_helper'
-
-class ActiveRecord::QueryDistinctTest < ActiveSupport::TestCase
-
-  schema do
-    create_table "ships", limit: 100 do |t|
-      t.string   "name",                    limit: 255
-    end
-  end
-  
-  class Ship < ActiveRecord::Base
-  end
-
-  # Distinct
-  test '::distinct query' do
-    webmock(:get, "/ships", distinct: true, limit: 100, offset: 0).to_return({
-      body: [].to_json
-    })
-
-    assert_equal [], Ship.distinct
-  end
-
-  # TODO: i need arel-extensions....
-  # test '::distinct_on query' do
-  #   webmock(:get, "/ships", distinct_on: ['id']).to_return(body: [].to_json)
-  #
-  #   assert_equal [], Ship.distinct_on(:id)
-  # end
-
-end

data/test/active_record/query/find_test.rb

@@ -1,37 +0,0 @@
-require 'test_helper'
-
-class ActiveRecord::QueryFindTest < ActiveSupport::TestCase
-
-  schema do
-    create_table "ships", limit: 100 do |t|
-      t.string   "name",                    limit: 255
-    end
-  end
-  
-  class Ship < ActiveRecord::Base
-  end
-
-  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 '::find_each' do
-    requests = []
-    
-    requests << webmock(:get, "/ships", { limit: 100, offset: 0, order: [{id: :asc}] }).to_return({
-      body: Array.new(100, { id: 1 }).to_json
-    })
-    requests << webmock(:get, "/ships", { limit: 100, offset: 100, order: [{id: :asc}] }).to_return({
-      body: Array.new(10, { id: 2 }).to_json
-    })
-    
-    assert_nil Ship.find_each { |s| s }
-    
-    requests.each { |r| assert_requested(r) }
-  end
-  
-end

data/test/active_record/query/limit_test.rb

@@ -1,19 +0,0 @@
-require 'test_helper'
-
-class ActiveRecord::LimitTest < ActiveSupport::TestCase
-  schema do
-    create_table "ships" do |t|
-      t.string   "name",                limit: 255
-    end
-  end
-
-  class Ship < ActiveRecord::Base
-  end
-    
-  test '::limit' do
-    webmock(:get, "/ships", {limit: 5000}).to_return(body: [{id: 42}].to_json)
-    assert_equal Ship.limit(5000).map(&:id), [42]
-  end
-
-
-end

data/test/active_record/query/order_test.rb

@@ -1,27 +0,0 @@
-require 'test_helper'
-
-class ActiveRecord::OrderTest < ActiveSupport::TestCase
-
-  schema do
-    create_table "ships", limit: 100 do |t|
-      t.string   "name",                    limit: 255
-    end
-  end
-  
-  class Ship < ActiveRecord::Base
-  end
-
-  test '::order(COLUMN)' do
-    webmock(:get, "/ships", { limit: 1, order: [{id: :asc}] }).to_return({
-      body: [{id: 42}].to_json
-    })
-
-    assert_equal 42, Ship.order(:id).first.id
-  end
-  
-  # TODO: Uses Arel::Nodes::RandomOrdering from:
-  #       https://github.com/malomalo/activerecord-sort
-  #       which should probably go into arel-extensions?
-  test '::order(:random)'
-  
-end

data/test/active_record/query/where_test.rb

@@ -1,79 +0,0 @@
-require 'test_helper'
-
-class ActiveRecord::QueryWhereTest < ActiveSupport::TestCase
-
-  schema do
-    create_table "ships", limit: 100 do |t|
-      t.string   "name",                    limit: 255
-    end
-    
-    create_table "fleets" do |t|
-      t.string   "name",                    limit: 255
-      t.integer  "fleet_id"
-    end
-    
-    create_table "sailors" do |t|
-      t.string   "name",                    limit: 255
-      t.integer  "ship_id"
-    end
-  end
-
-  class Fleet < ActiveRecord::Base
-    has_many :ships
-  end
-  
-  class Ship < ActiveRecord::Base
-    belongs_to :fleet
-    has_many :sailors
-  end
-
-  class Sailor < ActiveRecord::Base
-    belongs_to :ship
-  end
-  
-  test '::where on columns' do
-    webmock(:get, "/ships", { where: { id: 10 }, limit: 100, offset: 0 }).to_return(body: [].to_json)
-
-    assert_equal [], Ship.where(id: 10).to_a
-  end
-
-  test '::where column is nil' do
-    webmock(:get, "/ships", { where: { fleet_id: nil }, limit: 100, offset: 0 }).to_return(body: [].to_json)
-
-    assert_equal [], Ship.where(fleet_id: nil).to_a
-  end
-
-  test '::where on belongs_to relation' do
-    webmock(:get, "/ships", where: {fleet: { id: {eq: 1} } }, limit: 100, offset: 0).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} } }, limit: 100, offset: 0).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 '::where on nested relationship' do
-    webmock(:get, "/fleets", where: { ships: {sailors: { id: {eq: 1} } } }, limit: 10).to_return(body: [].to_json)
-
-    assert_equal [], Fleet.where(ships: {sailors: {id: 1}}).limit(10).to_a
-  end
-  
-
-end

data/test/active_record/query_test.rb

@@ -1,131 +0,0 @@
-require 'test_helper'
-
-class ActiveRecord::QueryTest < ActiveSupport::TestCase
-
-  schema do
-    create_table "ships", limit: 100 do |t|
-      t.string   "name",                    limit: 255
-    end
-    
-    create_table "ownerships" do |t|
-      t.string  "asset_type"
-      t.integer  "asset_id"
-    end
-  end
-
-  class Ship < ActiveRecord::Base
-    has_many :ownerships, as: :asset
-  end
-  
-  class Ownership < ActiveRecord::Base
-    belongs_to :asset, polymorphic: true
-  end
-  
-  test '::first' do
-    webmock(:get, "/ships", { limit: 1, order: [{id: :asc}] }).to_return({
-      body: [].to_json
-    })
-
-    assert_nil Ship.first
-  end
-
-  test '::first!' do
-    webmock(:get, "/ships", { limit: 1, order: [{id: :asc}] }).to_return({
-      body: [].to_json
-    })
-
-    assert_raises ActiveRecord::RecordNotFound do
-      Ship.first!
-    end
-  end
-
-  test '::last' do
-    webmock(:get, "/ships", { limit: 1, order: [{id: :desc}] }).to_return({
-      body: [].to_json
-    })
-
-    assert_nil Ship.last
-  end
-
-  test '::where on the same column multiple times with symbols and strings' do
-    webmock(:get, "/ships", { where: [{ id: {gt: 10} }, 'AND', {id: {gt: 11}}], limit: 100, offset: 0 }).to_return(body: [].to_json)
-
-    arel_table = Ship.arel_table
-    assert_equal [], Ship.where(arel_table[:id].gt(10)).where(arel_table['id'].gt(11)).to_a
-  end
-
-  test '::where(AND CONDITION)' do
-    webmock(:get, "/ships", { where: {id: 10, name: 'name'}, limit: 1, order: [{id: :asc}] }).to_return({
-      body: [{id: 42}].to_json
-    })
-
-    arel_table = Ship.arel_table
-    assert_equal 42, Ship.where(arel_table[:id].eq(10).and(arel_table[:name].eq('name'))).first.id
-  end
-
-  test '::where(OR CONDITION)' do
-    webmock(:get, "/ships", { where: [{id: 10}, 'OR', {name: 'name'}], limit: 1, order: [{id: :asc}] }).to_return({
-      body: [{id: 42}].to_json
-    })
-
-    arel_table = Ship.arel_table
-    assert_equal 42, Ship.where(arel_table[:id].eq(10).or(arel_table[:name].eq('name'))).first.id
-  end
-
-  test '::where(AND & OR CONDITION)' do
-    webmock(:get, "/ships", { where: [{id: 10}, 'AND', [{id: 10}, 'OR', {name: 'name'}]], limit: 1, order: [{id: :asc}] }).to_return({
-      body: [{id: 42}].to_json
-    })
-
-    arel_table = Ship.arel_table
-    assert_equal 42, Ship.where(arel_table[:id].eq(10).and(arel_table[:id].eq(10).or(arel_table[:name].eq('name')))).first.id
-  end
-
-  test '::where(....big get request turns into post...)' do
-    name = 'q' * 3000
-    webmock(:post, "/ships").with(
-      headers: {'X-Http-Method-Override' => 'GET'},
-      body: {where: { name: name }, limit: 100, offset: 0 }.to_json
-    ).to_return(body: [{id: 42}].to_json)
-
-    assert_equal 42, Ship.where(name: name)[0].id
-  end
-
-  test '::where with JOIN' do
-    webmock(:get, "/ships", {where: { ownerships: {id: {eq: 1}} }, limit: 100, offset: 0 }).to_return({
-      body: [{id: 42}].to_json
-    })
-
-    arel = Ownership.arel_table[:id].eq(1)
-    assert_equal 42, Ship.joins(:ownerships).where(arel)[0].id
-  end
-
-  # Relation test
-
-  test '#to_sql' do
-    assert_equal "SELECT ships.* FROM ships WHERE ships.id = 10", Ship.where(:id => 10).to_sql
-  end
-
-  test '#to_sql binds correctly when joining' do
-    assert_equal 'SELECT ships.* FROM ships INNER JOIN ownerships ON ownerships.asset_type = \'ActiveRecord::QueryTest::Ship\' AND ownerships.asset_id = ships.id WHERE ownerships.id = 1', Ship.joins(:ownerships).where({ ownerships: { id: 1 } }).to_sql
-  end
-
-  test '#to_sar' do
-    assert_equal "/ships?%81%A5where%81%A2id%0A", Ship.where(:id => 10).to_sar.path
-  end
-
-  test 'bind params get eaten when joining' do
-    uri = URI(Ship.joins(:ownerships).where({ ownerships: { id: 1 } }).to_sar.path)
-    query = MessagePack.unpack(CGI.unescape(uri.query))
-    assert_equal({"where"=>{"ownerships"=>{"id"=>{"eq"=>1}}}}, query)
-  end
-  
-  test 'Arel::Nodes::HomogeneousIn' do
-    webmock(:get, "/ships", { where: {id: {in: [10,12]} }, limit: 100, offset: 0 }).to_return({
-      body: [].to_json
-    })
-
-    Ship.where(id: [10,12]).to_a
-  end
-
-end

data/test/active_record/rpc_test.rb

@@ -1,30 +0,0 @@
-require 'test_helper'
-
-class ActiveRecord::RPCTest < ActiveSupport::TestCase
-
-  schema do
-    create_table "ships", limit: 100 do |t|
-      t.string   "name",                    limit: 255
-    end
-  end
-
-  class Ship < ActiveRecord::Base
-    rpc :self_destruct
-  end
-  
-  test '::rpc calls custom controller function' do
-    webmock(:get, "/ships", { limit: 1, order: [{id: :asc}] }).to_return({
-      body: [{id: 3, name: 'Sivar'}].to_json
-    })
-
-    webmock(:post, '/ships/3/self_destruct').to_return({
-      body: {name: 'DESTROYED'}.to_json
-    })
-
-    ship = Ship.first
-    assert ship.self_destruct!
-    assert_equal 'DESTROYED', ship.name
-    assert ship.changes.empty?
-  end
-
-end

data/test/schema_mock.rb

@@ -1,121 +0,0 @@
-class ActiveSupport::TestCase
-  class Schema
-
-    class Table
-
-      class Column
-
-        def initialize(name, type, options={})
-          @name = name
-          @type = type
-          @options = options
-        end
-
-        def as_json
-          {type: @type, primary_key: false, null: true, array: false}.merge(@options)
-        end
-      end
-
-      attr_accessor :name, :options, :columns
-
-      def initialize(name, options={}, &block)
-        @name = name
-        @options = options
-        @columns = {}
-        case options[:id]
-        when false
-        else
-          integer('id', primary_key: true, null: false)
-        end
-
-        block.call(self)
-      end
-
-      def string(name, options={})
-        @columns[name] = Column.new(name, :string, options)
-      end
-      
-      def text(name, options={})
-        @columns[name] = Column.new(name, :text, options)
-      end
-
-      def datetime(name, options={})
-        @columns[name] = Column.new(name, :datetime, options)
-      end
-
-      def integer(name, options={})
-        @columns[name] = Column.new(name, :integer, options)
-      end
-
-      def to_json
-        json = @options.slice(:limit)
-        json[:attributes] = {}
-        @columns.each do |name, column|
-          json[:attributes][name] = column.as_json
-        end
-        json.to_json
-      end
-
-    end
-
-    attr_accessor :tables
-
-    def initialize
-      @tables = {}
-    end
-
-    def self.define(&block)
-      i = new
-      i.define(&block)
-      i
-    end
-
-    def define(&block)
-      instance_eval(&block)
-    end
-
-    def create_table(name, options={}, &block)
-      @tables[name] = Table.new(name, options, &block)
-    end
-
-  end
-
-  def self.schema(&block)
-    self.class_variable_set(:@@schema, Schema.define(&block))
-  end
-
-  set_callback(:setup, :before) do
-    if !instance_variable_defined?(:@suite_setup_run) && self.class.class_variable_defined?(:@@schema)
-      ActiveRecord::Base.establish_connection(adapter: 'sunstone', url: 'http://example.com')
-
-      req_stub = stub_request(:get, /^http:\/\/example.com/).with do |req|
-        case req.uri.path
-        when '/tables'
-          true
-        when /^\/\w+\/schema$/i
-          true
-        else
-          false
-        end
-      end
-
-      req_stub.to_return do |req|
-        case req.uri.path
-        when '/tables'
-          {
-            body: self.class.class_variable_get(:@@schema).tables.keys.to_json,
-            headers: { 'StandardAPI-Version' => '6.0.0.29' }
-          }
-        when /^\/(\w+)\/schema$/i
-          {
-            body: self.class.class_variable_get(:@@schema).tables[$1].to_json,
-            headers: { 'StandardAPI-Version' => '6.0.0.29' }
-          }
-        end
-      end
-
-    end
-    @suite_setup_run = true
-  end
-
-end

data/test/sunstone/connection/column_definition_test.rb

@@ -1,30 +0,0 @@
-require 'test_helper'
-
-class Sunstone::Connection::ColumnDefinitionTest < ActiveSupport::TestCase
-
-  schema do
-    create_table "ships", limit: 100 do |t|
-      t.string   "name",          limit: 255
-      t.integer  "guns",          limit: 8
-      t.integer  "sailor_count"
-    end
-  end
-
-  class Ship < ActiveRecord::Base
-  end
-
-  test "default limit on column" do
-    assert_nil Ship.columns_hash['sailor_count'].limit
-  end
-
-  test "custom limit on column" do
-    assert_equal 8, Ship.columns_hash['guns'].limit
-  end
-
-  test "custom limit on string column" do
-    assert_equal 255, Ship.columns_hash['name'].limit
-  end
-  
-end
-
-

data/test/sunstone/connection/configuration_test.rb

@@ -1,44 +0,0 @@
-require 'test_helper'
-
-class Sunstone::Connection::ConfigurationTest < ActiveSupport::TestCase
-
-  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

@@ -1,37 +0,0 @@
-require 'test_helper'
-
-class Sunstone::Connection::CookieStoreTest < ActiveSupport::TestCase
-
-  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