OnRails.org

    rails rails

./script/plugin install http://themidnightcoders.net:8089/svn/weborb

    ./script/generate model Customer

class CreateCustomers < ActiveRecord::Migration
  def self.up
    create_table :customers do |t|
      t.column "name", :string
      t.column "address", :string
    end
  end

  def self.down
    drop_table :customers
  end
end

    rake migrate

./script/console
>> Customer.create(:name => "Daniel", :address => "Denver") 
>> Customer.create(:name => "Samuel", :address => "Geneva")
>> exit

package {
     import flexunit.framework.TestCase;
    import mx.rpc.remoting.RemoteObject;
    import flash.events.Event;
    import mx.rpc.events.ResultEvent;
    import mx.rpc.events.FaultEvent;     

     public class WebORBReadOnlyTest extends TestCase {

          public function WebORBReadOnlyTest( methodName:String = null ) {
               super( methodName );
        }

        // This method triggers a remote call and defines the event handler for the asynchronous response.
          public function testGetCustomerList():void {
              var asyncCall:Function = addAsync(onCustomerListResult, 1000);
             var dataService:RemoteObject = new RemoteObject();   
            dataService.destination = "DataService"; // Default WebORB ActiveRecord accessor 
            dataService.addEventListener("result", asyncCall);
            dataService.addEventListener("fault", asyncCall);
             dataService.list("Customer");        
           }          
           // This is the even handler trigger by the asynchronous response, let assert that we received what we expected.
        private function onCustomerListResult(event:Event, token:Object=null):void 
        {
            assertTrue(event is ResultEvent); 
            var data:Object = ResultEvent(event).result;
            assertEquals(2, data.length);
            assertEquals("Daniel", data[0].name);
        }

      }
}

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" 
    layout="absolute"
                xmlns:flexunit="flexunit.flexui.*"
                creationComplete="runTests()">
    <mx:Script>
        <![CDATA[
            import flexunit.framework.TestSuite;

            private function runTests():void
            {
                 var ts:TestSuite = new TestSuite();                 
                 ts.addTestSuite( WebORBReadOnlyTest );                 
                testRunner.test = ts;
                testRunner.startTest();
             }
        ]]>
    </mx:Script>

    <!-- flexunit provides a very handy default test runner GUI -->
    <flexunit:TestRunnerBase id="testRunner" width="100%" height="100%" />

</mx:Application>

FLEX_HOME="/Applications/Adobe Flex Builder 2 Beta/Flex SDK 2/"
cp flex-config-patched.xml "$FLEX_HOME/frameworks/"
java -Xmx384m -Dsun.io.useCanonCaches=false -jar "$FLEX_HOME/lib/mxmlc.jar" -load-config "$FLEX_HOME/frameworks/flex-config-patched.xml"  -library-path+=../flexunit/bin/flexunit.swc WebORBTestApp.mxml
cp WebORBTestApp.swf ../../rails/public/flex 

require 'weborb/context'
require 'active_record/fixtures'
class ActiveRecordService 
  def create_fixtures(table_names)
    Fixtures.create_fixtures("#{RAILS_ROOT}/test/fixtures/", table_names, {})
  end 
end    

    <destination id="ActiveRecordService">
        <properties>
            <source>ActiveRecordService</source>
        </properties>
    </destination>

first:
  id: 1
  name: Daniel
  address: Littleton
another:
  id: 2
  name: Samuel
  address: Bernex

package {
     import flash.events.Event;

     import flexunit.framework.TestCase;

     import mx.rpc.events.FaultEvent;
     import mx.rpc.events.ResultEvent;
     import mx.rpc.remoting.RemoteObject;
     import mx.rpc.AsyncToken;     
    import mx.collections.ItemResponder;
    import mx.controls.Alert;

     public class WebORBReadOnlyTest extends TestCase {

          public function WebORBReadOnlyTest( methodName:String = null ) {
               super( methodName );
        }

        // The mechanism to invoke the server side create_fixtures method is still a little clunky here.
        // This should be part of the setUp method, which doesn't support asynchronous setUp for now.
        // So writing a test with fixture now requires three method (that's the really clunky part!)
        //     1. the testXXXXX method that must call the getActiveRecordService and the create_fixture method.
        //     2. the method that will actual call the server (here. doGetCustomerList)
        //     3. the result handler for the abort call that will perform the assert.
          public function testGetCustomerList():void {
             // getActiveRecordService - Signal to TestCase that this is an asynchronous test
             // and pass end point of the test method (in this case the onCustomerListResult method)
             var activeRecordService:RemoteObject = getActiveRecordService(onCustomerListResult); 
              create_fixtures(["customers"], doGetCustomerList, activeRecordService);
           }          
           private function doGetCustomerList(activeRecordService:Object):void {
             activeRecordService.list("Customer");                       
           }
           // This is the even handler trigger by the asynchronous response, let assert that we received what we expected.
        private function onCustomerListResult(event:Event, token:Object=null):void 
        {
            assertTrue(event.toString(), event is ResultEvent); // First param is message.
            var data:Object = ResultEvent(event).result;
            assertEquals(2, data.length);
            assertEquals("Daniel", data[0].name);
            assertEquals("Littleton", data[0].address);
        }

        private function getActiveRecordService(resultHandler:Function, timeOut:Number=2000):RemoteObject 
        {
              var asyncCall:Function = addAsync(resultHandler, timeOut);
             var activeRecordService:RemoteObject = new RemoteObject();   
            activeRecordService.destination = "ActiveRecordService";
            activeRecordService.addEventListener("result", asyncCall);
            activeRecordService.addEventListener("fault", asyncCall);
            return activeRecordService;            
        }

        private function create_fixtures(table_names:Array, callback:Function, callbackData:Object):void 
        {
             var activeRecordService:RemoteObject = new RemoteObject();   
            activeRecordService.destination = "ActiveRecordService";
             var call:AsyncToken = activeRecordService.create_fixtures(table_names);    
            call.addResponder(new ItemResponder(onCreateFixturesResult, onCreateFixturesFault));
            call.callback = callback;
            call.callbackData = callbackData;
        }
        private function onCreateFixturesResult(event:ResultEvent, token:Object=null):void 
        {
            event.token.callback(event.token.callbackData);
        }
        private function onCreateFixturesFault(event:Event, token:Object=null):void
        {
            fail("Failed to create fixtures. "+event.toString());
        }            

      }
}

 ./script/generate model Address 
 ./script/generate model Order --skip-migration  
 ./script/generate model  Item --skip-migration  

class CreateAddresses < ActiveRecord::Migration
  def self.up
    create_table :addresses do |t|
      t.column "street", :string
      t.column "zip", :string
      t.column "city", :string
    end
    create_table :orders do |t|
      t.column "customer_id", :integer
      t.column "created_at", :datetime
    end
    create_table :items do |t|
      t.column "order_id", :integer
      t.column "quantity", :integer
      t.column "product", :string
    end        
    remove_column :customers, :address
    add_column :customers, "bill_to_address_id", :integer
    add_column :customers, "ship_to_address_id", :integer
  end

  def self.down
    drop_table :addresses
    drop_table :orders
    drop_table :items
    add_column :customers, :address, :string
  end
end

class Customer < ActiveRecord::Base
  has_many :orders
  belongs_to :bill_to_address, :class_name => "Address", :foreign_key => "bill_to_address_id"
  belongs_to :ship_to_address, :class_name => "Address", :foreign_key => "ship_to_address_id"  
end
class Address < ActiveRecord::Base
  belongs_to :customer
end
class Order < ActiveRecord::Base
  belongs_to :customer
  has_many :items
end
class Item < ActiveRecord::Base
  belongs_to :order
end

first:
  id: 1
  name: Daniel
another:
  id: 2
  name: Samuel

first:
  id: 1
  street: First Street.
  zip: 80246
  city: Littleton  
another:
  id: 2
  street: Other Avenue.
  zip: 1200
  city: Bernex  

hardware_order:
  id: 1
  customer_id: 1
  bill_to_address_id: 1
book_order:
  id: 2
  customer_id: 1
  bill_to_address_id: 1

media_center:
  id: 1
  order_id: 1
  product: iTv
  quantity: 1
screen:
  id: 2
  order_id: 1
  product: 200" LCD Screen
  quantity: 1
remote:
  id: 3
  order_id: 1
  product: Remote Control
  quantity: 1
book1:
  id: 4
  order_id: 2
  product: Agile Web Development With Rails, 2nd Edition
  quantity: 1
book2:
  id: 5
  order_id: 2
  product: Mastering CSS
  quantity: 1

class ActiveRecordService 

  # Allow for a deep fetch (find_by_id with :include options)    
  def get(model_name, id, options={})
    model_class = Object.const_get model_name
    find_options = {:include => options['include']} # Here we limit options for now.
    result = model_class.send(:find_by_id, id, find_options)
    puts result.inspect
    result
  end  

  def find_all(model_name, options={})
    model_class = Object.const_get model_name
    find_options = {:include => options['include']} # Here we limit options for now.
    result = model_class.send(:all, find_options)
    puts result.inspect
    result
  end  
end

          public function testGetFirstCustomer():void {
             var activeRecordService:RemoteObject = getActiveRecordService(onGetFirstCustomerResult); 
              create_fixtures(["customers", "addresses", "orders", "items"], doGetCustomerFirstCustomer, activeRecordService);
           }          
           private function doGetCustomerFirstCustomer(activeRecordService:Object):void {
            var options:Object = {'include':['bill_to_address', {'orders':'items'}]};
             activeRecordService.get("Customer", 1, options);                       
           }
        private function onGetFirstCustomerResult(event:Event, token:Object=null):void 
        {
            assertTrue(event.toString(), event is ResultEvent); // First param is message.
            var customer:Object = ResultEvent(event).result;
            assertEquals("Daniel", customer.name);
            assertEquals("Littleton", customer.bill_to_address.city);
            assertEquals(2, customer.orders.length);    // 2 order
            assertEquals(3, customer.orders[0].items.length); // the first has 3 items
            assertEquals("Remote Control", customer.orders[0].items[2].product); 
        }