kangaroo 0.0.1.pre

data/spec/model/persistence_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'kangaroo/model/base'
+
+module Kangaroo
+  module Model
+    describe Persistence do
+
+      before :each do
+        @klass = Class.new(Kangaroo::Model::Base)
+        @klass.define_multiple_accessors :a, :b
+        @klass.stub!(:default_attributes).and_return({})
+      end
+
+      context '#instantiate' do
+        it 'raises error if id is missing' do
+          lambda { @klass.send(:instantiate, {}) }.should raise_error(Kangaroo::InstantiatedRecordNeedsIDError)
+        end
+
+        it 'returns an instance' do
+          object = @klass.send :instantiate, {:id => 1, :a => 'one'}
+          object.should be_an_instance_of(@klass)
+        end
+
+        it 'sets attributes' do
+          object = @klass.send :instantiate, {:id => 1, :a => 'one'}
+          object.a.should == 'one'
+        end
+      end
+
+
+      describe '#find' do
+        it 'raises RecordNotFound error if no record was found' do
+          @remote_stub = mock 'remote'
+          @klass.stub!(:remote).and_return @remote_stub
+
+          @remote_stub.stub!(:read).
+            and_return []
+          lambda {@klass.find(1)}.should raise_error(Kangaroo::RecordNotFound)
+        end
+      end
+
+      it 'marks initialized record as new' do
+        object = @klass.new
+        object.should be_a_new_record
+      end
+
+      it 'marks instantiated record as persisted' do
+        object = @klass.send :instantiate, {:id => 1}
+        object.should be_persisted
+      end
+    end
+  end
+end

data/spec/model/relation_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+module Kangaroo
+  module Model
+    describe Relation do
+      before do
+        @target = mock 'target'
+        @relation = Relation.new @target
+      end
+
+      it 'delegates array methods via target#all' do
+        array_mock = mock 'array'
+        array_mock.should_receive :each
+
+        @target.should_receive(:search_and_read).and_return array_mock
+        @relation.send :each
+      end
+
+      it 'stores conditions via where() and hands them over to target#all' do
+        @target.should_receive(:search_and_read).with [{:a => :b}], anything, anything
+        @relation.where(:a => :b).all
+      end
+
+      it 'merges chained where() conditions' do
+        @target.should_receive(:search_and_read).with [{:a => :b}, {:b => :c}], anything, anything
+        @relation.where(:a => :b).where(:b => :c).all
+      end
+
+      it 'doesnt change the relation on chaining' do
+        @target.should_receive(:search_and_read).with [{:a => :b}], anything, anything
+        chained_relation = @relation.where(:a => :b)
+        chained_relation.where(:b => :c)
+        chained_relation.all
+      end
+
+      it 'stores limit and hands it over to target#all' do
+        @target.should_receive(:search_and_read).with [], hash_including(:limit => 10), anything
+        @relation.limit(10).all
+      end
+
+      it 'overwrites limit clauses when chained' do
+        @target.should_receive(:search_and_read).with [], hash_including(:limit => 10), anything
+        @relation.limit(20).limit(10).all
+      end
+
+      it 'stores offset and hands it over to target#all' do
+        @target.should_receive(:search_and_read).with [], hash_including(:offset => 10), anything
+        @relation.offset(10).all
+      end
+
+      it 'overwrites offset clauses when chained' do
+        @target.should_receive(:search_and_read).with [], hash_including(:offset => 10), anything
+        @relation.offset(20).offset(10).all
+      end
+
+      it 'stores select and hands it over to target#all' do
+        @target.should_receive(:search_and_read).
+          with [], anything, hash_including(:fields => ["a", "b"])
+        @relation.select(:a, :b).all
+      end
+
+      it 'stores context hands it over to target#all' do
+        @target.should_receive(:search_and_read).
+          with [], hash_including(:context => {:lang => 'de_DE'}), hash_including(:context => {:lang => 'de_DE'})
+        @relation.context(:lang => 'de_DE').all
+      end
+
+      it 'merges chained contexts' do
+        @target.should_receive(:search_and_read).
+          with [], hash_including(:context => {:lang => 'de_DE', :tz => 'de'}), hash_including(:context => {:lang => 'de_DE', :tz => 'de'})
+        @relation.context(:lang => 'de_DE').context(:tz => 'de').all
+      end
+
+      describe '#reverse' do
+        it 'adds descending id order if no order was specified' do
+          @relation.reverse.order_clause.should == ['id desc']
+        end
+
+        it 'reverses previously specified orders' do
+          @relation.order('name').reverse.order_clause.should == ['name desc']
+          @relation.order('name', true).reverse.order_clause.should == ['name']
+          @relation.order('name').order('code', true).reverse.order_clause.should == ['name desc', 'code']
+        end
+      end
+
+      describe '#[]' do
+        it 'doesnt touch existing limit clause' do
+          @target.should_receive(:search_and_read).
+            with([], hash_including(:limit => 2), anything).
+            and_return []
+          @relation.limit(2)[1]
+        end
+
+        it 'doesnt touch existing offset clause' do
+          @target.should_receive(:search_and_read).
+            with([], hash_including(:offset => 40), anything).
+            and_return []
+          @relation.offset(40)[10]
+        end
+
+        it '[n] returns the n-th record' do
+          @target.should_receive(:search_and_read).
+            with([], hash_including(:limit => 1, :offset => 21), anything).
+            and_return []
+          @relation[21]
+        end
+
+        it '[n, m] return m records skipping n' do
+          @target.should_receive(:search_and_read).
+            with [], hash_including(:limit => 4, :offset => 21), anything
+          @relation[21, 4]
+        end
+
+        it '[n..m] returns records n to m' do
+          @target.should_receive(:search_and_read).
+            with [], hash_including(:limit => 5, :offset => 21), anything
+          @relation[21..25]
+        end
+      end
+    end
+  end
+end

data/spec/ruby_adapter/class_definition_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'server_helper'
+
+require 'kangaroo/ruby_adapter/base'
+
+module Kangaroo
+  module RubyAdapter
+    describe ClassDefinition do
+      def stub_oo_model name
+        oo_model = mock 'oo_model'
+        oo_model.stub!('model_class_name').and_return(name)
+        oo_model
+      end
+
+      def adapt_oo_model name
+        oo_model = stub_oo_model name
+        adapter = Base.new(oo_model)
+        adapter.send :define_class
+      end
+
+      it 'creates a class in Oo for a (theoretical) top-level OpenObject model' do
+        ruby_model = adapt_oo_model 'Oo::User'
+
+        ruby_model.name.should == 'Oo::User'
+        ruby_model.superclass.should be(Kangaroo::Model::Base)
+      end
+
+      it 'creates module namespaces for nested OpenObject models' do
+        ruby_model = adapt_oo_model 'Oo::A::B::User'
+
+        ruby_model.name.should == 'Oo::A::B::User'
+        Oo::A.should be_a(Module)
+        Oo::A::B.should be_a(Module)
+      end
+
+      it 'nests models in classes if a parent model is already loaded' do
+        parent_model = adapt_oo_model 'Oo::C::D'
+        ruby_model = adapt_oo_model 'Oo::C::D::E'
+
+        Oo::C::D.should be_a(Class)
+        Oo::C::D::E.should be_a(Class)
+      end
+
+      it 'raises an error if trying to define a parent model after a child model' do
+        child_model = adapt_oo_model 'Oo::Sale::Order::Line'
+
+        lambda { adapt_oo_model('Oo::Sale::Order') }.should raise_error(Kangaroo::ChildDefinedBeforeParentError)
+      end
+    end
+  end
+end

data/spec/server_helper.rb

@@ -0,0 +1,167 @@
+require 'rubygems'
+require 'rapuncel'
+require 'active_support/core_ext/string'
+require "xmlrpc/server"
+require 'webrick'
+
+module TestServices
+  class ObjectService
+    def execute *args
+      xmlrpc_call 'execute', *args
+    end
+
+    protected
+    def xmlrpc_call name, *args
+    end
+  end
+
+  class CommonService
+    def login *args
+      xmlrpc_call 'login', *args
+      args
+    end
+
+    def some_method *args
+      xmlrpc_call 'some_method', *args
+      args
+    end
+
+    protected
+    def xmlrpc_call name, *args
+    end
+  end
+
+  class DbService
+    def list *args
+      xmlrpc_call 'list', *args
+      args
+    end
+
+    def rename *args
+      xmlrpc_call 'rename', *args
+      args
+    end
+
+    protected
+    def xmlrpc_call name, *args
+    end
+  end
+
+  class ReportService
+    def create *args
+      xmlrpc_call 'create', *args
+      args
+    end
+
+    protected
+    def xmlrpc_call name, *args
+    end
+  end
+
+  class WizardService
+    def create *args
+      xmlrpc_call 'create', *args
+    end
+
+    protected
+    def xmlrpc_call name, *args
+    end
+  end
+end
+
+module TestServerHelper
+  def self.included klass
+    klass.before :all do
+      @test_server = TestServer.start
+    end
+
+    klass.after :all do
+      @test_server.stop
+    end
+  end
+
+  def client service
+    Rapuncel::Client.new :host => '127.0.0.1', :port => 8069, :path => "/xmlrpc/#{service}"
+  end
+
+  def proxy service, *args
+    Kangaroo::Util::Proxy.const_get(service.camelize).new client(service), *args
+  end
+
+  def object_service
+    @test_server.object_service
+  end
+
+  def common_service
+    @test_server.common_service
+  end
+
+  def db_service
+    @test_server.db_service
+  end
+
+  def report_service
+    @test_server.report_service
+  end
+
+  def wizard_service
+    @test_server.wizard_service
+  end
+end
+
+class TestServer
+  SERVICES = %w(ObjectService CommonService DbService WizardService ReportService)
+  SERVICES.each do |service|
+    attr_accessor service.underscore
+  end
+  attr_accessor :server
+
+  def initialize
+    @server = WEBrick::HTTPServer.new(:Port => 8069, :BindAddress => '127.0.0.1', :MaxClients => 1,
+                                      :Logger => WEBrick::Log.new(File.open('/dev/null', 'w')))
+
+    SERVICES.each do |service|
+      mount_service service
+    end
+  end
+
+  def serve
+    if RUBY_PLATFORM =~ /mingw|mswin32/
+      signals = [1]
+    else
+      signals = %w[INT TERM HUP]
+    end
+    signals.each { |signal| trap(signal) { @server.shutdown } }
+
+    @server.start
+  end
+
+  def mount_service service
+    server = XMLRPC::WEBrickServlet.new ''
+    add_handler server, service
+    @server.mount "/xmlrpc/#{mount_point(service)}", server
+  end
+
+  def mount_point service
+    service.underscore.sub '_service', ''
+  end
+
+  def add_handler server, service
+    const = "TestServices::#{service}".constantize
+    inst = const.new
+    send "#{service.underscore}=", inst
+    server.add_handler(XMLRPC::iPIMethods(''), inst)
+  end
+
+  def stop
+    @server.shutdown
+  end
+
+  def self.start
+    new.tap do |s|
+      Thread.new do
+        s.serve
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'kangaroo'
+
+module SpecHelper
+  def anythings count
+    [anything] * count
+  end
+end
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

data/spec/test_env/test.yml

@@ -0,0 +1,11 @@
+host: 127.0.0.1
+port: 8069
+
+database:
+  name: kangaroo_test_database
+  user: admin
+  password: admin
+  
+  models:
+    - res.*
+    - product.product

data/spec/util/configuration_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'server_helper'
+
+require 'kangaroo/util/configuration'
+
+module Kangaroo
+  module Util
+    describe Configuration do
+      include TestServerHelper
+
+      def config_file
+        File.join File.dirname(__FILE__), '..', 'test_env', 'test.yml'
+      end
+
+      it "configures Kangaroo by config file" do
+        config = Kangaroo::Util::Configuration.new(config_file, Logger.new('/dev/null'))
+
+        config.models.should == ['res.*']
+        config.database.db_name.should == 'kangaroo_test_database'
+        config.database.user.should == 'admin'
+        config.database.password.should == 'admin'
+      end
+
+      it 'authorizes the configured user before model loading' do
+        config = Kangaroo::Util::Configuration.new(config_file, Logger.new('/dev/null'))
+        loader = mock('loader')
+        loader.stub! :load!
+        Loader.stub!(:new).and_return loader
+
+        common_service.should_receive(:xmlrpc_call).
+                        with('login', 'kangaroo_test_database', 'admin', 'admin')
+        config.load_models
+      end
+    end
+  end
+end