sunstone 5.0.1.3 → 5.0.1.4

data/test/active_record/query/find_test.rb

@@ -0,0 +1,37 @@
+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/where_test.rb

@@ -0,0 +1,79 @@
+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,135 +1,67 @@
 require 'test_helper'
 
-class ActiveRecord::QueryTest < Minitest::Test
+class ActiveRecord::QueryTest < ActiveSupport::TestCase
 
-  test '::find w/ old schema definition' do
-    replaced_stub = WebMock::StubRegistry.instance.global_stubs.find { |x|
-      x.request_pattern.uri_pattern.to_s == 'http://example.com/ships/schema'
-    }
-    WebMock::StubRegistry.instance.global_stubs.delete(replaced_stub)
-
-    new_stub = WebMock::API.stub_request(: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(:get, "/ships", { where: {id: 42}, limit: 1 }).to_return(body: [{id: 42}].to_json)
-
-    assert_equal 42, Ship.find(42).id
-
-    WebMock::API.remove_request_stub(new_stub)
-    WebMock::StubRegistry.instance.global_stubs.push(replaced_stub)
-  end
-
-  test '::all' do
-    ships = []
-    101.times { |i| ships << Ship.new(id: i) }
-    webmock(:get, "/ships", { limit: 100, offset: 0 }).to_return(body: ships[0..100].to_json)
-    webmock(:get, "/ships", { limit: 100, offset: 100 }).to_return(body: ships[101..-1].to_json)
-    assert_equal ships, Ship.all
+  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
 
-  test '::all w/o resource_limit' do
-    webmock(:get, "/fleets").to_return(body: [{id: 42}].to_json)
-    assert_equal [Fleet.new(id: 42)], Fleet.all
+  class Ship < ActiveRecord::Base
+    has_many :ownerships, as: :asset
   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
+  
+  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)
+    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)
+    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: 100, offset: 0, order: [{id: :asc}] }).to_return(body: Array.new(100, { id:  1 }).to_json)
-    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 }
-  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: { leased_at: nil }, limit: 100, offset: 0 }).to_return(body: [].to_json)
-
-    assert_equal [], Ship.where(:leased_at => nil).to_a
+  
+  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
+    })
 
-  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
+    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 on has_many relation' do
-    webmock(:get, "/fleets", where: {ships: { id: {eq: 1} } }).to_return(body: [].to_json)
+  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
+    })
 
-    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
-
-  # 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
-
-  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 '::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)
+    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
@@ -141,6 +73,15 @@ class ActiveRecord::QueryTest < Minitest::Test
 
     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
 
@@ -149,7 +90,7 @@ class ActiveRecord::QueryTest < Minitest::Test
   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 = \'Ship\' WHERE ownerships.id = 1', Ship.joins(:ownerships).where({ ownerships: { id: 1 } }).to_sql
+    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

data/test/schema_mock.rb

@@ -0,0 +1,117 @@
+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 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[:columns] = {}
+        @columns.each do |name, column|
+          json[:columns][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' => '5.0.0.5' }
+          }
+        when /^\/(\w+)\/schema$/i
+          {
+            body: self.class.class_variable_get(:@@schema).tables[$1].to_json,
+            headers: { 'StandardAPI-Version' => '5.0.0.5' }
+          }
+        end
+      end
+      
+    end
+    @suite_setup_run = true
+  end
+  
+end

data/test/sunstone/connection/configuration_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class Sunstone::Connection::ConfigurationTest < Minitest::Test
+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')

data/test/sunstone/connection/cookie_store_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class Sunstone::Connection::CookieStoreTest < Minitest::Test
+class Sunstone::Connection::CookieStoreTest < ActiveSupport::TestCase
 
   test '#send_request(#<Net::HTTPRequest) adds cookies to the cookie store if present' do
     store = CookieStore::HashStore.new