foundationapi 0.9.9

data/test/unit/foundation_api/model/cached_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class FoundationApi::Model::AttributeMethodsTest < ActiveSupport::TestCase
+  class Model
+    include FoundationApi::Model::Cached
+    
+  end
+
+  context 'cached_find' do
+    should 'be the stuff' do
+      Model.expects(:find).with(2)
+      Model.cached_find(2)
+    end
+    should 'call cache' do
+      Rails.cache.expects(:fetch).with(['FoundationApi::Model::AttributeMethodsTest::Model', 2])
+      Model.cached_find(2)
+    end
+  end
+
+end

data/test/unit/foundation_api/model/mapping_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+
+
+class FoundationApi::Model::MappingTest < ActiveSupport::TestCase
+  
+  class Model
+    include FoundationApi::Model::Mapping
+  end
+  
+  context 'map_from_params' do
+    should 'create hash with indifferent access' do
+      input = "%%tn_drawHistory_ 4,18,10 %%tn_patternIDsSelected_ 1,2,3,4,5,0 %%tn_prizePhaseEstimatedAmounts_ units=0"
+      expected = {'tn_drawHistory' => '4,18,10', 'tn_patternIDsSelected' => '1,2,3,4,5,0', 'tn_prizePhaseEstimatedAmounts' => 'units=0'}
+      res = Model.map_from_params(input)
+      assert res.is_a? HashWithIndifferentAccess
+      assert_equal expected, res
+      Model.new.map_from_params(input)
+    end
+  end
+  
+end

data/test/unit/foundation_api/request_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+class FoundationApi::RequestTest < ActiveSupport::TestCase
+  class Model
+    include FoundationApi::Request
+    
+  end
+  
+  context 'delegation' do
+    should 'call the appropriate interface' do
+      FoundationApi::JsonRPC::Client.expects(:request).with(:hurrr).returns(11)
+      assert_equal 11, Model.request(:hurrr)
+      Model.expects(:request).with(:huffr).returns(22)
+      assert_equal 22, Model.new.request(:huffr)
+    end    
+  end
+  
+  context 'conversion' do
+    should 'quote string' do
+      assert_equal "'aha'", Model.quote('aha')
+    end
+    should 'not quote numbers' do
+      assert_equal "1", Model.quote(1)
+    end
+    should 'quote date' do
+      assert_equal "'2013-08-15'", Model.quote(Date.parse("2013-08-15"))      
+    end
+    should 'quote elements of array if relevant' do
+      assert_equal "'2013-08-15', 'aha', 1", Model.quote([Date.parse("2013-08-15"), 'aha', 1])
+    end
+  end
+  
+end

data/test/unit/foundation_api/service_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+class FoundationApi::ServiceTest < ActiveSupport::TestCase
+  class Adapter < FoundationApi::Service
+    self.service_name = 'test_service'
+  end
+  
+  context 'class method' do
+    context 'request_data' do
+      should 'pass on the appropriate parameters' do
+        Adapter.expects(:request).with('test_service', :hello => :there).returns(:hello_again)
+        assert_equal :hello_again, Adapter.send(:request_data, :hello => :there)
+      end
+    end
+    context 'translate_options' do
+      should 'translate options correctly' do
+        expected = {'a' => 1, 'b' => 2}
+        assert_equal expected, Adapter.send( :translate_options, :conditions => {:a => 1, :b => 2})
+      end
+    end
+    context 'all' do
+      should 'have appropritate calls' do
+        Adapter.expects(:request_data).with({}).returns(:data)
+        Adapter.expects(:instantiate_objects).with(:data).returns(:good)
+        assert_equal :good, Adapter.all
+      end
+      should 'not try to instantiate object if no result' do
+        Adapter.expects(:request_data).with({}).returns(nil)
+        Adapter.expects(:instantiate_objects).never
+        assert_nil Adapter.all
+      end
+      should 'apply default scope' do
+        Adapter.default_scope = {:hello => :there}
+        Adapter.expects(:request_data).with({:hello => :there}).returns(nil)
+        assert_nil Adapter.all
+        Adapter.default_scope = {}
+      end
+    end
+    context 'where' do
+      should 'support optional condition' do
+        Adapter.expects(:translate_options).with(:conditions => {:a => :b}).returns(:good)
+        Adapter.expects(:request_data).with(:good).returns([:fine])
+        Adapter.expects(:instantiate_objects).with([:fine]).returns([:nice])
+        assert_equal [:nice], Adapter.where(:a => :b)
+      end
+      should 'accept string' do
+        Adapter.expects(:translate_options).with('a, b, c').returns(:good)
+        Adapter.expects(:request_data).with(:good).returns([:fine])
+        Adapter.expects(:instantiate_objects).with([:fine]).returns([:nice])
+        assert_equal [:nice], Adapter.where('a, b, c')
+      end
+    end
+  end
+end

data/test/unit/foundation_api/table/persistence_test.rb

@@ -0,0 +1,182 @@
+require 'test_helper'
+require 'foundation_api/test_helper'
+
+class FoundationApi::Table::PersistenceTest < ActiveSupport::TestCase
+  
+  class TestClass
+    include FoundationApi::Model::AttributeMethods
+    include FoundationApi::Table::Persistence
+    TestClass.persistence create: :CreateTestObject, update: :ChangeTestObject
+
+    def initialize(attributes = {})      
+      @attributes = HashWithIndifferentAccess.new attributes
+    end
+  end
+  
+  context 'class' do
+    setup do
+      TestClass.persistence create: :CreateTestObject, update: :ChangeTestObject
+    end
+    teardown do
+      TestClass.persistence_options = {}
+    end
+    should 'have  a persistence inteface' do
+      assert TestClass.respond_to?(:persistence)
+      assert_equal :CreateTestObject, TestClass.persistence_options[:create]
+      assert_equal :ChangeTestObject, TestClass.persistence_options[:update]
+    end
+    
+    context 'methods create' do
+      should 'instantiate and save object' do
+        @object = TestClass.new
+        attrs = {:hello => :world, :riding => :on_an_airplane}
+        TestClass.expects(:new).with(attrs).returns(@object)
+        @object.expects(:save).returns(:success)
+        assert_equal :success, TestClass.create(attrs)
+        TestClass.expects(:new).with(attrs).returns(@object)
+        @object.expects(:save!).returns(:success)
+        assert_equal :success, TestClass.create!(attrs)
+      end
+    end
+    
+    context 'remote_create' do
+      setup do
+        @attrs = {:still => :on, :a => :plane, :properties => {:hello => :there}}
+        @object = TestClass.new(@attrs)
+      end
+      should 'map attributes when requesting' do
+        @object.expects(:map_attributes).returns(:good)
+        TestClass.expects(:request).with(:CreateTestObject, :good).returns(:in_the_air)
+        assert_equal :in_the_air, TestClass.remote_create(@object)
+      end
+      should 'support mapping hashes into array' do
+        assert_equal ({"still"=>:on, "a"=>:plane, "properties"=>{"hello"=>:there}}), @object.map_attributes
+        TestClass.persistence create: :CreateTestObject, :hash_to_array => true
+        assert_equal ({"still"=>:on, "a"=>:plane, "properties"=>[["hello",:there]]}), @object.map_attributes
+        
+      end
+      should 'check for uniqueness if option specified' do
+        TestClass.persistence create: :CreateTestObject, unique: :name
+        @object[:name] = 'Ivo'
+        TestClass.expects(:where).with(:name => 'Ivo', :deleted => 0).returns([true])
+        TestClass.expects(:request).never
+        assert_raises FoundationApi::RecordNotUnique do
+          @object.save!
+        end
+        @object.expects(:map_attributes).returns(:good)
+        TestClass.expects(:where).with(:name => 'Ivo', :deleted => 0).returns([])
+        TestClass.expects(:request).with(:CreateTestObject, :good).returns(:in_the_air)
+        assert_nothing_raised do
+          @object.save!
+        end
+      end
+      should 'return id' do
+        @object.expects(:map_attributes).returns(:good)
+        TestClass.expects(:request).with(:CreateTestObject, :good).returns([123])
+        assert_equal 123, TestClass.remote_create(@object)
+        @object.expects(:map_attributes).returns(:good)
+        TestClass.expects(:request).with(:CreateTestObject, :good).returns(234)
+        assert_equal 234, TestClass.remote_create(@object)
+      end
+    end
+    context 'remote_update' do
+      should_eventually 'be supported' do
+      end
+    end
+    context 'remote_destroy' do
+      setup do
+        @options = TestClass.persistence_options
+        @object = TestClass.new(:in_melon => :office)
+      end
+      teardown do
+        TestClass.persistence_options = @options
+      end
+      should 'provide proper initialization' do
+        TestClass.persistence destroy: :DeleteTestObject
+        assert_equal :DeleteTestObject, TestClass.persistence_options[:destroy]
+        assert_equal 'testClassId', TestClass.send(:destroy_key)
+        TestClass.persistence destroy_key: 'baluba'
+        assert_equal 'baluba', TestClass.send(:destroy_key)
+      end
+      should 'check for support before executing' do
+        assert_raises FoundationApi::DestroyNotSupported do
+          @object.destroy
+        end
+        @object[:id] = 14
+        assert_raises FoundationApi::DestroyNotSupported do
+          @object.destroy!
+        end
+      end
+      should 'perform the appropriate call to the service for named id' do
+        TestClass.persistence destroy: :DeleteTestObject
+        assert_raises FoundationApi::RecordNotPersistent do
+          @object.destroy!
+        end
+        assert !@object.destroy, 'Should deny to destroy object and should not raise exception'
+        @object[:id] = 12
+        TestClass.expects(:request).with(:DeleteTestObject, 'testClassId' => 12)
+        @object.destroy
+      end
+      should 'perform the appropriate call to the service for array' do
+        TestClass.persistence destroy: :DeleteTestObject, destroy_type: :array
+        @object[:id] = 12
+        TestClass.expects(:request).with(:DeleteTestObject, [12])        
+        @object.destroy
+        TestClass.expects(:request).with(:DeleteTestObject, [11, 12, 13])
+        TestClass.destroy 11, 12, 13
+      end
+    end
+    
+  end
+
+
+  context 'instance' do
+    setup do
+      @object = TestClass.new({:still_on => :an_airplane})
+    end
+    context 'method save' do
+      should 'create record remotely and store id' do
+        @object.expects(:remote_create).with(@object).returns(:catch && 44)
+        @object.save
+        assert_equal 44, @object.id
+        @object.save(:options => :hello)
+        assert_equal 44, @object.id
+      end      
+    end
+    context 'persistence support' do
+      should 'raise error unless persistence support has been defined' do
+        @object.persistence_options = {}
+        assert_raises FoundationApi::CreateNotSupported do
+          @object.stubs(:persisted?).returns(false)
+          @object.save!
+        end
+        assert_raises FoundationApi::UpdateNotSupported do
+          @object.stubs(:persisted?).returns(true)
+          @object.save!
+        end
+      end
+    end
+    context 'having an id' do
+      setup do
+        @object[:id] = 1
+      end
+      should 'tell that record is persisted' do
+        assert @object.persisted?
+      end
+      should 'tell that it is not a new record' do
+        assert !@object.new_record?
+      end
+    end
+    context 'missing id' do
+      setup do
+        @object[:id] = nil
+      end
+      should 'state that record is not persisted' do
+        assert !@object.persisted?
+      end
+      should 'tell that it might be a new record' do
+        assert @object.new_record?
+      end
+    end
+  end
+end

data/test/unit/foundation_api/table/record_test.rb

@@ -0,0 +1,176 @@
+require 'test_helper'
+require 'foundation_api/test_helper'
+
+class FoundationApi::Table::RecordTest < ActiveSupport::TestCase
+  setup do
+    FoundationApi::JsonRPC::Client.site = "http://cyber:arts@localhost:4444/api"
+    FoundationApi::JsonRPC::Client.auth_token = @auth_token = 'tns5ddd7cc5271c8c6b5fab8aaf9ec492ed'
+  end
+
+  class TestObject < FoundationApi::Table::Record
+    alias_attribute :gun, :Pistol
+  end
+  
+  def hash_difference(a,b)
+    "Expected: #{a.inspect}, but was #{b.inspect}\n" +
+    "expected - actual #{(a.reject { |k,v| b[k] == v }).inspect}\n" +
+    "actual - expected #{(b.reject { |k,v| a[k] == v }).inspect}\n"
+  end
+  def assert_json_params_equal(a,b)
+    a_params = a.delete('params').first
+    b_params = b.delete('params').first
+    assert_equal a, b, hash_difference(a, b)
+    assert_equal a_params, b_params, hash_difference(a_params, b_params)
+  end
+
+  def expect(method, parameters, options = {}, &block)
+    if options[:return] || options[:error]
+      Net::HTTP.stubs(:raw_response_data).returns(%Q/{"result": #{options[:return] || 'null'}, "id": "jsonrpc", "error": #{options[:error] || 'null'}}/)
+    end
+    yield
+    request_str = %Q/{"params":[{"authorization":"#{@auth_token}",#{parameters}}],"method":"#{method}","id":"jsonrpc"}/
+    #puts request_str
+    #puts Net::HTTP.raw_post_body
+    assert_json_params_equal JSON.parse(request_str), JSON.parse(Net::HTTP.raw_post_body)
+  end
+  
+  
+  context 'behavior' do
+    setup do
+    end
+    should 'include specific modules' do
+      modules = [ActiveModel::Conversion]
+      assert_equal modules, FoundationApi::Table::Record.included_modules & modules
+    end
+    should 'have foundation concerns' do
+      modules = [FoundationApi::Model::Mapping, FoundationApi::Model::AttributeMethods, FoundationApi::Request]
+      assert_equal modules, FoundationApi::Table::Record.included_modules & modules
+    end
+  end
+  
+  context 'class methods' do
+    should 'know table name from class name' do
+      assert_equal 'foundationapi.TestObject', TestObject.send(:fully_qualified_table_name)
+      assert_equal 'foundationapi', TestObject.database_name
+      assert_equal 'TestObject', TestObject.table_name
+    end
+    should 'translate options correctly' do
+      expected = {:filters => ['a = 1', 'b = 2']}
+      assert_equal expected, TestObject.send( :translate_options, :conditions => {:a => 1, :b => 2})
+      assert_equal expected, TestObject.send( :translate_options, :conditions => ['a = 1', 'b = 2'])
+      expected = {:filters => ['great']}
+      assert_equal expected, TestObject.send( :translate_options, :conditions => 'great')
+      expected = {:filters => ["a = 'wow'", "b = 'hey'"]}
+      assert_equal expected, TestObject.send( :translate_options, :conditions => {:a => 'wow', :b => :hey})
+      expected = {:filters => ["a = 'hey'", "cool"]}
+      assert_equal expected, TestObject.send( :translate_options, :conditions => {:a => 'hey', :_expression => 'cool'})
+    end
+    should 'raise exception if parameters cannot be translated' do
+      assert_raises FoundationApi::TranslationError do
+        assert_equal TestObject.send( :translate_options, :conditions => 1)
+      end
+    end
+    context 'find' do
+      should 'handle success' do
+        TestObject.expects(:get_table_data).with('foundationapi.TestObject', :filters => ['id = 2']).returns([:good])
+        TestObject.expects(:instantiate_objects).with([:good]).returns([:nice])
+        assert_equal :nice, TestObject.find(2)
+      end
+      should 'handle failure' do
+        TestObject.expects(:get_table_data).with('foundationapi.TestObject', :filters => ['id = 2']).returns([])
+        TestObject.expects(:instantiate_objects).never
+        assert_nil TestObject.find(2)
+      end
+    end
+    context 'where' do
+      should 'support optional condition' do
+        TestObject.expects(:translate_options).with(:conditions => {:a => :b}).returns(:good)
+        TestObject.expects(:get_table_data).with('foundationapi.TestObject', :good).returns([:fine])
+        TestObject.expects(:instantiate_objects).with([:fine]).returns([:nice])
+        assert_equal [:nice], TestObject.where(:a => :b)
+      end
+      should 'accept string' do
+        TestObject.expects(:translate_options).with('a, b, c').returns(:good)
+        TestObject.expects(:get_table_data).with('foundationapi.TestObject', :good).returns([:fine])
+        TestObject.expects(:instantiate_objects).with([:fine]).returns([:nice])
+        assert_equal [:nice], TestObject.where('a, b, c')
+      end
+    end
+    context 'all' do
+      should 'handle success' do
+        TestObject.expects(:get_table_data).with('foundationapi.TestObject').returns([:good])
+        TestObject.expects(:instantiate_objects).with([:good]).returns([:nice])
+        assert_equal [:nice], TestObject.all
+      end
+    end
+    context 'get_table_data' do
+      should 'send correct format for GetTableData' do
+        expect 'GetTableData', '"table":"bingo.Perm","filters":["permId = 1", "permTypeId = 2"], "columns":["numbers","tweek"]',
+            :return => '{"columnNames":["numbers","tweek"], "rows":[{"fields":["12,13,14", "ugh"]}, {"fields":["22,13,14", "argh"]}]}' do
+              expected = [{'numbers' => "12,13,14", 'tweek' => "ugh"}, {'numbers' => "22,13,14", 'tweek' => "argh"}]
+          assert_equal expected, TestObject.send(:get_table_data, 'bingo.Perm', :filters => ['permId = 1', 'permTypeId = 2'], :columns => [:numbers, :tweek])
+        end
+      end
+      should 'return nil if there are no data' do
+        expect 'GetTableData', '"table":"bingo.Perm","filters":["permId = 1", "permTypeId = 2"], "columns":["numbers","tweek"]',
+            :return => '["numbers","tweek"]' do
+          assert_nil TestObject.send(:get_table_data, 'bingo.Perm', :filters => ['permId = 1', 'permTypeId = 2'], :columns => [:numbers, :tweek])
+        end
+      end
+      should_eventually 'take advantage of columns' do
+      end
+    end
+    
+    context 'error handling' do
+      should_eventually 'include raising exception when record not found' do
+      end
+    end
+  end
+  
+  context 'instance methods' do
+    should 'be dynamic' do
+      @object = TestObject.new
+      assert_raises NoMethodError do
+        @object.unknown
+      end
+      @object.attributes = HashWithIndifferentAccess.new({:unknown => 'aha'})
+      assert_equal 'aha', @object.unknown
+    end
+    should 'convert id to integer' do
+      @object = TestObject.new(:id => '2')
+      assert @object.id.is_a? Fixnum
+      assert_equal 2, @object.id
+    end
+  end
+  
+  context 'caching' do
+    context 'enabled' do
+      setup do
+        TestObject.caching_enabled = true      
+      end
+      teardown do
+        TestObject.caching_enabled = false
+      end
+      should 'cache where clause' do
+        Rails.cache.expects(:fetch).with([TestObject.name, :where, 'bark twice'],{}).returns(stub(:first => :expected))
+        assert_equal :expected, TestObject.where('bark twice').first
+      end
+      should 'cache object by id' do
+        Rails.cache.expects(:fetch).with([TestObject.name, 1],{}).returns(:expected)
+        assert_equal :expected, TestObject.find(1)
+      end
+    end
+    context 'disabled' do
+      should 'never call cache' do
+        Rails.cache.expects(:fetch).never
+        TestObject.expects(:get_table_data).returns([:expected])
+        TestObject.expects(:instantiate_objects).with([:expected]).returns([:nice])
+        assert_equal [:nice], TestObject.where('bark twice')
+        TestObject.expects(:get_table_data).returns([:expected])
+        TestObject.expects(:instantiate_objects).with([:expected]).returns([:nice])
+        assert_equal :nice, TestObject.find( 1 )
+      end
+    end
+  end
+  
+end