sunstone 6.0.0.5 → 6.1.3

data/test/active_record/preload_test.rb

@@ -1,51 +0,0 @@
-require 'test_helper'
-
-class ActiveRecord::PreloadTest < ActiveSupport::TestCase
-
-  schema do
-    create_table "ships" do |t|
-      t.string   "name",                    limit: 255
-      t.integer  "fleet_id"
-    end
-
-    create_table "fleets" do |t|
-      t.string   "name",                    limit: 255
-    end
-    
-    create_table "sailors" do |t|
-      t.string   "name",                    limit: 255
-    end
-    
-    create_table "sailors_ships", id: false do |t|
-      t.integer  "ship_id",                 null: false
-      t.integer  "sailor_id",               null: false
-    end
-    
-  end
-  
-  class Fleet < ActiveRecord::Base
-    has_many :ships
-  end
-
-  class Ship < ActiveRecord::Base
-    belongs_to :fleet
-  
-    has_and_belongs_to_many :sailors
-  end
-
-  class Sailor < ActiveRecord::Base
-    has_and_belongs_to_many :ships
-  end
-
-  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/all_test.rb

@@ -1,33 +0,0 @@
-require 'test_helper'
-
-class ActiveRecord::QueryAllTest < ActiveSupport::TestCase
-  schema do
-    create_table "ships" do |t|
-      t.string   "name",                limit: 255
-    end
-    
-    create_table "cars", limit: 100 do |t|
-      t.string   "name",                limit: 255
-    end
-  end
-
-  class Ship < ActiveRecord::Base
-  end
-
-  class Car < ActiveRecord::Base
-  end
-    
-  test '::all' do
-    webmock(:get, "/ships").to_return(body: [{id: 42}].to_json)
-    assert_equal [Ship.new(id: 42)], Ship.all
-  end
-
-  test '::all w/resource_limit' do
-    cars = []
-    101.times { |i| cars << Car.new(id: i) }
-    webmock(:get, "/cars", { limit: 100, offset: 0 }).to_return(body: cars[0..100].to_json)
-    webmock(:get, "/cars", { limit: 100, offset: 100 }).to_return(body: cars[101..-1].to_json)
-    assert_equal cars, Car.all
-  end
-
-end

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,123 +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_id = ships.id AND ownerships.asset_type = \'ActiveRecord::QueryTest::Ship\' 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
-
-end