tradingrobotdsl 0.0.1 → 0.0.2

data/History.txt

@@ -1,3 +1,14 @@
+== 0.0.2 / 2007-11-22
+* New features
+	* Plugin system for smarting 
+	* IB online and history quotes  plugins
+	* IB order placement plugin
+	* Techical analysis plugin new functions: SMA and EMA
+* Bug fixes
+	* OpenTick plugins temporary removed for testing
+
+* Bug fixes
+	* duration command 
 == 0.0.1 / 2007-11-18
 
 * Birthday!

data/lib/dsl.rb

@@ -1,173 +1,443 @@
-=begin
-  Trading robot Domain specific language implementation
-=end
-
-$:.push(File.dirname(__FILE__) + "/../../opentick-ruby/lib/")
-
-require 'opentick.rb'
-require 'thread'
-#add_stubs(@user, :password= => nil, :password_confirmation= => nil, :new_password= => nil)
+
+=begin
+  Trading robot Domain specific language implementation
+=end
+
+
+require 'thread'
+
 module DSL	
 
-    VERSION='0.0.1'
+  VERSION='0.0.2'
+
 	class NoDataException < RuntimeError
 		attr :deep_level
 		def initialize(deep_level)
 			@deep_level = deep_level
 		end
-	end # class NoDataException
-
-  class Contract        
-    @@list_by_name={}
-    @@list_by_id=[]
-    attr_reader :name, :exchange, :queue
-		attr_accessor :request_id
-    
-    def initialize(contract_name, exchange=nil)
-      @name = contract_name
-      @exchange = exchange
-      @request_id = 0
-			@queue = []
-    end    
-    
-    def self.list_by_name
-      @@list_by_name
-    end
-    
-    def self.list_by_id
-      @@list_by_id
-    end
-    
-    def self.find(contract_name)
-      @@list_by_name[contract_name]=Contract.new(contract_name) unless @@list_by_name.key?(contract_name)
-      @@list_by_name[contract_name]
-    end
-    
-    def method_missing(m, *args)
-      @exchange = m
-      self
+	end # class NoDataException
+
+	############################### class Plugin  ##$################################
+
+	module Plugin
+		def initialize(robot)
+			@robot = robot
+			@connection = nil
+			self.class.message.each do |name, command|
+				if name == :input
+					command.each do |name, command|
+						@robot.register_command(name, lambda {|*args| self.send(command, *args)}, self)
+					end
+				else	
+					@robot.register_command(name, lambda {|*args| self.send(command, *args)})
+				end
+			end
+		end
+
+		def run(hash)
+			raise "you must define own run method in subclasses"
+		end
+
+		def parse_params(hash)
+			hash.each do |param|
+				self.instance_variable_set "@" + param[0].to_s, param[1]
+			end
+		end
+	end # module Plugin
+
+	module IBPluginFunctions
+		# make structure Contract for ib-ruby module
+		def make_contract(contract)
+			IB::Datatypes::Contract.new(:symbol => contract.symbol.to_s, :exchange => contract.exchange.to_s,
+							:expiry => contract.expiry, :currency => contract.currency, :sec_type => contract.sec_type)
+		end
+	end
+
+	class IBHistoryPlugin
+		include Plugin
+		include IBPluginFunctions
+		@@ticker_id = 1
+	
+		def self.message
+			{ 
+				:input => { :history => :run }
+		  }
+		end
+
+		def run(*args)
+			hash=args[0]
+			$:.push(File.dirname(__FILE__) + "/../../ib-ruby/lib/")
+			require 'ib'			
+			require 'datatypes'
+			require 'messages'
+			require 'timeout'
+
+			@duration = 0
+			parse_params(hash)
+			@id = []
+			@connection = IB::IB.new({:client_id => "quotes"})
+			#@connection.dispatch(IB::OutgoingMessages::SetServerLoglevel.new(:loglevel => 5))
+			@connection.subscribe(IB::IncomingMessages::HistoricalData, lambda {|msg| on_quote(msg)})
+			@mutex = Mutex.new
+			@condition = ConditionVariable.new
+		end # run
+
+		def subscribe_contract(contract)
+			ib_contract = make_contract(contract)
+			msg = IB::OutgoingMessages::RequestHistoricalData.new(:ticker_id => @@ticker_id += 1, 
+						:contract => ib_contract, :end_date_time => @end, :duration => @duration, 
+						:bar_size => @size, :what_to_show => @show, :use_RTH => 1, :format_date => 2) 
+			@id[@@ticker_id] = contract.queue
+			@connection.dispatch(msg)
+		end # subscribe_contract
+
+		def query()
+			while !@id.inject(true) {|s,x| s &&=x.nil? } do
+								 #|| (Contract.list_by_value.inject(true) {|s,x| s &&= (x.queue.size >= @deep)}) 
+				@mutex.synchronize do 
+					begin
+						@condition.wait(@mutex) unless @id.inject(true) {|s,x| x == nil ? s : s &&= x.size >= @robot.deep_level}
+						yield
+					rescue NoDataException => e
+						@robot.deep_level = e.deep_level
+						retry 
+					end
+			 end # synchronize
+		 end	# while		
+		end
+
+    def on_quote(msg)			
+			queue = @id[msg.data[:req_id]]
+			cond = @id.inject(true) {|s,x| x == nil ? s : s &&= x.size >= @robot.deep_level}
+			@mutex.synchronize do
+				msg.data[:history].each do |q|								
+					queue.push q
+				end					
+			end
+				@condition.signal if !cond && @id.inject(true) {|s,x| x == nil ? s : s &&= x.size >= @robot.deep_level}
+    end
+	end # class IBHistoryPlugin
+
+	class IBOnlinePlugin 
+		include Plugin
+		include IBPluginFunctions
+		@@ticker_id = 1
+
+		def self.message
+			{ 
+				:input => { :online => :run }
+		  }
+		end
+
+		def run(*args)
+			hash=args[0]
+			$:.push(File.dirname(__FILE__) + "/../../ib-ruby/lib/")
+			require 'ib'			
+			require 'datatypes'
+			require 'messages'
+			require 'timeout'
+
+			@duration = 0
+			parse_params(hash)
+			@id = []
+			@data = []
+			@connection = IB::IB.new({:client_id => "quotes"})
+			#@connection.dispatch(IB::OutgoingMessages::SetServerLoglevel.new(:loglevel => 5))
+			@connection.subscribe(IB::IncomingMessages::TickPrice, lambda {|msg| on_quote(msg)})
+#			@connection.subscribe(IB::IncomingMessages::TickSize, lambda {|msg| on_trade(msg)})
+			@mutex = Mutex.new
+			@condition = ConditionVariable.new
+		end
+
+		def subscribe_contract(contract)
+			ib_contract = make_contract(contract)
+			msg = IB::OutgoingMessages::RequestMarketData.new(:ticker_id => @@ticker_id += 1, 
+						:contract => ib_contract)	
+			@id[@@ticker_id] = contract
+			@data[@@ticker_id] = {:open => 0, :high => 0, :low => 1e6, :close => 0}
+			@connection.dispatch(msg)
+		end
+
+		def filter
+			while true
+				begin
+					timeout(@duration) do
+						# fake loop
+						while true do
+						end
+					end
+				rescue TimeoutError
+					@id.size.times do |request_id|
+						next if @id[request_id].nil?
+						@id[request_id].queue.push :open  => @data[request_id][:open],
+																			 :high  => @data[request_id][:high],
+																			 :low   => @data[request_id][:low],
+																			 :close => @data[request_id][:close]
+						@data[request_id][:open] = @data[request_id][:high] =  @data[request_id][:low] = @data[request_id][:close]
+					end # times
+					@condition.signal if @id.inject(true) {|s,x| x == nil ? s : s &&= x.queue.size >= @robot.deep_level}
+				end # begin
+			end # while
+		end
+ 
+		def on_quote(msg)
+			return unless msg.data[:type] == :last
+ 			@mutex.synchronize do 
+ 				case @duration
+					when 0:
+						@id[msg.data[:ticker_id]].queue.push :price => msg.data[:price].to_f, :size => msg.data[:size].to_i
+						@condition.signal
+					else
+						id = msg.data[:ticker_id]
+						price = msg.data[:price].to_f
+						@data[id][:open]  = price if @data[id][:open] == 0
+						@data[id][:high]  = price if price > @data[id][:high]	
+						@data[id][:low]   = price if price < @data[id][:low]	
+						@data[id][:close] = price
+				end
+			end
+#			p "#{@id[msg.data[:ticker_id]].symbol.to_s} #{msg.data[:size]} #{msg.data[:price].to_digits}"
+		end
+
+		def query(*args)
+      Thread.abort_on_exception = true
+      @filter_thread = Thread.new do
+				self.filter
+			end
+			while	true
+				@mutex.synchronize do 
+					begin
+						@condition.wait(@mutex) unless @id.inject(true) {|s,x| x == nil ? s : s &&= x.queue.size >= @robot.deep_level}
+						yield
+					rescue NoDataException => e
+						@robot.deep_level = e.deep_level
+						retry 
+					end
+			  end # synchronize
+			end # while
+		end
+
+	end # IBOnlinePlugin
+ 
+	class IBOrderPlugin 
+		include Plugin
+		include IBPluginFunctions
+		@@order_id = 1
+
+		def self.message
+			{ :order => :order }
+		end
+
+		def initialize(robot)
+			$:.push(File.dirname(__FILE__) + "/../../ib-ruby/lib/")
+			require 'ib'			
+			require 'datatypes'
+			require 'messages'
+
+			super(robot)
+			@connection = IB::IB.new({:client_id => "orders"})
+			#@connection.dispatch(IB::OutgoingMessages::SetServerLoglevel.new(:loglevel => 5))
+			@connection.subscribe(IB::IncomingMessages::NextValidID, lambda {|msg| @@order_id = msg.data[:order_id]})
+			@robot.class.const_set "BUY", "BUY"
+			@robot.class.const_set "SELL", "SELL"
+			@robot.class.const_set "MKT", "MKT"
+			@robot.class.const_set "LMT", "LMT"
+		end # hash
+
+		# usage CONTRACT, ORDER_SIDE (BUY, SELL), ORDER_TYPE (MKT, LMT), SIZE, LIMIT_PRICE
+		def order(*args)
+			contract = args.shift
+			side = args.shift
+			type = args.shift
+			size = args.shift
+			order = {
+	            :id => 1,
+              :action => side,
+              :order_type => type,
+              :total_quantity => size,
+              :transmit => "1"
+			}
+			case type
+				when "LMT":
+					order[:limit_price] = args.shift
+			end
+			@connection.dispatch(IB::OutgoingMessages::PlaceOrder.new(
+				:order_id => @@order_id += 1,
+				:contract => make_contract(contract),
+				:order => IB::Datatypes::Order.new(order)
+      ))
+		end	
+	end # IBOrderPlugin
+
+	class TAPlugin
+		include Plugin
+		def self.message
+			{ :sma => :sma,
+				:ema => :ema
+			}
+		end		
+
+		def sma(contract, period)
+			raise NoDataException.new(period) if @robot.deep_level < period
+			(@robot.deep_level-period..@robot.deep_level-1).inject(0) {|s,x| s+=contract.price(x)} / period.to_f
+		end # def sma
+
+		def ema(contract, period, step = @robot.deep_level - period)
+			raise NoDataException.new(period) if @robot.deep_level < period
+			case period
+				when 1
+					return contract.queue[step][:close].to_f
+				else
+					k = 2 / ( 1 + period )
+					ema_prev = ema(contract, period - 1, step + 1)
+					return ema_prev + k * ( contract.price(step) - ema_prev )
+			end
+		end # def ema
+	end
+
+	############################### class Contract ##################################
+	
+  class Contract        
+    @@list_by_symbol={}
+    attr_reader :symbol, :exchange, :expiry, :sec_type, :currency, :queue
+		attr_accessor :request_id
+    
+    def initialize(contract_symbol)
+      @symbol = contract_symbol
+			@queue = []
+    end    
+    
+    def self.list_by_symbol
+      @@list_by_symbol
+    end
+    
+    def self.find(contract_symbol)
+      @@list_by_symbol[contract_symbol]=Contract.new(contract_symbol) unless @@list_by_symbol.key?(contract_symbol)
+      @@list_by_symbol[contract_symbol]
+    end
+    
+    def method_missing(m, *args)
+  		if m.to_s =~ /[A-Z]+/ 
+      	@exchange = m unless instance_variable_defined?(:@exchange)
+				@sec_type = "STK" unless instance_variable_defined?(:@sec_type) || (args.size > 0 && @sec_type = args.shift)
+				@currency = "USD" unless instance_variable_defined?(:@currency) || (args.size > 0 && @currency = args.shift)
+				@expiry = "" unless instance_variable_defined?(:@expiry) || (args.size > 0 && @expiry = args.shift)
+      	self
+			else
+				super
+			end
     end
 		
-		def price
-			@queue.first[:closePrice] unless @queue.first.nil?
-		end
-    
-    def subscribe_history(ot, robot)
-      msg = OpenTick::OutgoingMessages::HistoryStreamRequest.new(:exchange => @exchange.to_s, 
-          :ticker => @name.to_s, :from => robot.from.to_i, :to => robot.to.to_i, :type => 4, :interval => 1)
-      ot.dispatch(msg)
-      @request_id = msg.reqId       
-			@@list_by_id[@request_id] = self
-    end
+		def price(lag = 0)
+			f = @queue[lag]
+			return if f.nil?
+			if f.key?(:price)
+				f[:price]
+			else
+				f[:close].to_f #FIXME
+			end
+		end
+    
   end # class Contract
 	
-	############################### class Robot ##################################
-
-  class Robot
-    attr_accessor :duration, :from, :to, :deep
-    
-    def initialize(opentick_connection)
-      @ot = opentick_connection
-      @logged = false
+	############################### class Robot ##################################
+
+  class Robot
+    attr_accessor :deep_level
+		@@commands = {}
+    
+    def initialize
 			@mutex = Mutex.new
 			@condition = ConditionVariable.new
-			@deep = 1
-    end
-    
-    def login(username, password)
-      @ot.login(username, password)
-      @logged = true
-    end # login
-    
-    def login?
-      @logged
-    end
-    
-    def history(options)
-      raise "parameters absence" unless options.key?(:duration) && options.key?(:from) && options.key?(:to)
-      raise "duration > to - from" unless options[:duration] < options[:to] - options[:from]
-      @duration = options[:duration]      
-      @from = options[:from]
-      @to = options[:to]
-      class << self
-        alias_method :query, :query_history
-      end  
-      DSL::Contract.class_eval {
-        alias_method :subscribe, :subscribe_history
-      }
-    end # history
-    
-    def on_history_quote(msg)			
-			contract = Contract.list_by_id[msg.reqId]
-			cond =Contract.list_by_name.values.inject(true) {|s,x| s &&= (x.queue.size >= @deep)}
-			@mutex.synchronize do
-				msg.data.each {|q|								
-					if q[:type]==0 && q[:time].nil?
-						contract.request_id = 0	
-					else
-						contract.queue.push q
-					end					
-				}
-				@condition.signal if !cond && Contract.list_by_name.values.inject(true) {|s,x| s &&= (x.queue.size >= @deep)}
-			end
-    end
-    
-    def query_history(*args)
-      @ot.subscribe(OpenTick::IncomingMessages::HistoryStreamResponse, lambda {|msg| on_history_quote(msg)})      
-      args.each do |contract| 
-        contract.subscribe(@ot, self)        
-      end								
-			begin
-				while (Contract.list_by_name.values.inject(0) {|s,x| s+=x.request_id } > 0) || 
-					(args.inject(true) {|s,x| s &&= (x.queue.size >= @deep)}) do	
-						@mutex.synchronize do 
-							begin
-								@condition.wait(@mutex) unless args.inject(true) {|s,x| s &&= (x.queue.size >= @deep)}
-								yield
-							rescue NoDataException => e
-								@deep = e.deep_level
-								retry 
-							end
-							args.each {|contract|						
-								contract.queue.shift
-							}													
-						end # synchronize
-				end	# while		
-			end # begin
-    end # query_history
-		
-		def avg(contract, period)
-			raise unless contract.is_a?(DSL::Contract)
-			raise unless period.is_a?(Fixnum)
-			raise NoDataException.new(period) if @deep < period
-			contract.queue[0..period-1].inject(0) {|s,x| s+=x[:closePrice]} / period
-		end
-  end # class Robot
-
-end # module DSL
+			@deep_level = 1
+    end
+
+		def commands
+			@@commands
+		end
+    
+		def method_missing(m, *args)
+			raise "unknown command #{m}" unless @@commands.key?(m)
+			@@commands[m].call(*args)
+		end
+
+		# load plugins
+		def plugin(*args)
+			args.each { |plugin| plugin.new(self) }
+		end # plugin
+
+		# query quotes from input_plugin
+		def query(*args)
+			args.each do |contract|
+				@input_plugin.subscribe_contract(contract)
+			end
+			@input_plugin.query do
+				yield
+				args.each {|contract|						
+					contract.queue.shift
+				}													
+			end
+		end
+
+		# register plugin command in global commands list
+		def register_command(command, body, input_plugin=nil)
+			@@commands[command] = body
+			@input_plugin = input_plugin if input_plugin
+		end
+  end # class Robot
+
+end # module DSL
 
 ############################### module Kernel ################################
-
-module Kernel
-  # change context
-  def robot(*args, &blk)
-   DSL::Robot.new(*args).instance_eval(&blk)
-  end
-end # Kernel
+
+module Kernel
+  def robot(&blk)
+   DSL::Robot.new.instance_eval(&blk)
+  end
+end # Kernel
 
 ############################### class Object #################################
-
-def Object.const_missing(m)    
-  DSL::Contract::find(m)
-end # Object.const_missing
-
-if $0 == __FILE__  
-  robot OpenTick::OpenTick.new("feed1.opentick.com", 10010) do
-    login 'test_opentick', '123123'
-    history :duration => 300, :from => Time.now-10*24*3600, :to => Time.now
-    query GOOG.Q,CSCO.Q do						
-			p avg GOOG.Q, 3
-			p avg CSCO.Q, 3
-    end # query
-  end # robot
-end
+
+def Object.const_missing(m)    
+  if m.to_s =~ /[A-Z]+/ 
+		# FIXME workaround
+		case m
+		when :FUT
+			"FUT"
+		when :STK
+			"STK"
+		when :USD
+			"USD"
+		else	
+			return DSL::Robot.const_get(m) if DSL::Robot.const_defined?(m)
+			DSL::Contract::find(m) 
+		end
+	else
+		super
+	end
+end # Object.const_missing
+
+if $0 == __FILE__  
+  robot do
+
+		# loading plugins, first must be plugin for query
+		plugin DSL::IBHistoryPlugin, DSL::IBOrderPlugin, DSL::TAPlugin
+		# input plugin configuration
+		#online :duration => 10
+		history :end => "20071101 00:00:00 GMT", :duration => "1 D", 
+						:size => 10, :show => "TRADES"
+		# contract specifications
+		YM.ECBOT FUT, USD, 200712
+		# main loop
+		query YM do
+			if (ema YM, 9)/(ema YM, 25) - 1 > 0.05
+				order YM, BUY, MKT, 1
+			end
+			if (ewa YM, 9)/(ewa YM, 25) - 1 < -0.05
+				order YM, SELL, MKT, 1
+			end
+		end
+
+
+  end # robot
+end

data/spec/contract_spec.rb

@@ -1,32 +1,32 @@
-require File.join(File.expand_path(File.dirname(__FILE__)),"helper")
-require "#{LIB_DIR}/dsl"
-
-describe DSL::Contract, "before created" do  
-  it "contract list_by_name should be empty" do    
-    DSL::Contract.list_by_name.should be_empty    
+require File.join(File.expand_path(File.dirname(__FILE__)),"helper")
+require "#{LIB_DIR}/dsl"
+
+describe DSL::Contract, "before created" do  
+  it "contract list_by_name should be empty" do    
+    DSL::Contract.list_by_name.should be_empty    
   end
   it "contract list_by_id should be empty" do    
     DSL::Contract.list_by_id.should be_empty
-  end
-end
-
-describe DSL::Contract, "when created" do
-  before :each do
-    @contract = robot(nil) do 
-      MSFT.Q 
-    end
-  end
-  
-  it "should exists" do
-    @contract.should_not be_nil    
+  end
+end
+
+describe DSL::Contract, "when created" do
+  before :each do
+    @contract = robot(nil) do 
+      MSFT.Q 
+    end
+  end
+  
+  it "should exists" do
+    @contract.should_not be_nil    
   end 
 	
 	it "should be instance of DSL::Contract" do
-		@contract.should be_an_instance_of(DSL::Contract)
+		@contract.should be_an_instance_of(DSL::Contract)
   end 
-	
-  it "should set contract name" do
-    @contract.name.should eql(:MSFT)    
+	
+  it "should set contract name" do
+    @contract.name.should eql(:MSFT)    
   end  
 	
 	it "should set exchange" do
@@ -37,23 +37,23 @@ describe DSL::Contract, "when created" do
 		pending "ror2ru question" do
 			@contract.public_methods.should_not include("subscribe")
 		end
-	end
-  
-  after :each do
-    DSL::Contract.list_by_name.clear
-    DSL::Contract.list_by_id.clear
-  end
-end
-
-describe DSL::Contract, "in history mode" do
-  it "should create method alias subscribe->subscribe_query" do
-    @robot = DSL::Robot.new(nil)
-    @robot.history :duration => 1, :from => Time.now - 2, :to => Time.now
-    DSL::Contract.new("MSFT").public_methods.should include("subscribe")
-  end
-  
-  it "should subscribe to history quotes" do
-    @robot = DSL::Robot.new(nil)
-    @ot = mock("OpenTick")
-  end
-end
+	end
+  
+  after :each do
+    DSL::Contract.list_by_name.clear
+    DSL::Contract.list_by_id.clear
+  end
+end
+
+describe DSL::Contract, "in history mode" do
+  it "should create method alias subscribe->subscribe_query" do
+    @robot = DSL::Robot.new(nil)
+    @robot.history :duration => 1, :from => Time.now - 2, :to => Time.now
+    DSL::Contract.new("MSFT").public_methods.should include("subscribe")
+  end
+  
+  it "should subscribe to history quotes" do
+    @robot = DSL::Robot.new(nil)
+    @ot = mock("OpenTick")
+  end
+end

data/spec/robot_spec.rb

@@ -1,23 +1,23 @@
-# robot_spec.rb
-
-require File.join(File.expand_path(File.dirname(__FILE__)),"helper")
-require "#{LIB_DIR}/dsl"
-
-describe Kernel, "robot method" do
-	it "should change context" do		
-		robot(nil) {self}.should be_a_kind_of(DSL::Robot)
-	end
-end # robot method
-
-describe DSL::Robot, "when created" do
-	before :each do
-		@ot = mock("OpenTick")
-		@robot = DSL::Robot.new(@ot)
-	end
-
-	it "should exists" do
-		@robot.should_not be_nil		    
-	end
+# robot_spec.rb
+
+require File.join(File.expand_path(File.dirname(__FILE__)),"helper")
+require "#{LIB_DIR}/dsl"
+
+describe Kernel, "robot method" do
+	it "should change context" do		
+		robot(nil) {self}.should be_a_kind_of(DSL::Robot)
+	end
+end # robot method
+
+describe DSL::Robot, "when created" do
+	before :each do
+		@ot = mock("OpenTick")
+		@robot = DSL::Robot.new(@ot)
+	end
+
+	it "should exists" do
+		@robot.should_not be_nil		    
+	end
 
 	it "should be instance of DSL::Robot" do		
 		@robot.should be_an_instance_of(DSL::Robot)    
@@ -30,59 +30,59 @@ describe DSL::Robot, "when created" do
 	it "should not have query method alias" do
 		@robot.public_methods.should_not include("query")
 	end
-
-	it "should connect to opentick server on login" do
-		@ot.should_receive(:login).
-			once.
-			with(an_instance_of(String), an_instance_of(String))			
-
+
+	it "should connect to opentick server on login" do
+		@ot.should_receive(:login).
+			once.
+			with(an_instance_of(String), an_instance_of(String))			
+
 		@robot.login("test_opentick", "123123")
-		
-    @robot.login?.should be_true
-	end   
-end # when created
-
-describe DSL::Robot, "in history mode" do
-  before :each do
-    @robot = DSL::Robot.new(nil)
-  end
-
-  it "should set @duration, @from and @to" do
-    now = Time.now
-    @robot.history :duration => 300, :from => now-24*3600, :to => now
-    @robot.duration.should eql(300)
-    @robot.from.should eql(now-24*3600)
-    @robot.to.should eql(now)  
-  end  
-  
-  it "should raise exception on parameter absence" do
-    lambda { @robot.history({}) }.should raise_error
-  end
-  
-  it "should check @to - @from > @duration" do
-    lambda {@robot.history :duration => 300, :from => 1, :to => 2 }.should raise_error
-  end
-  
-  it "should create method alias query->query_history" do    
-    @robot.history :duration => 300, :from => Time.now-24*3600, :to => Time.now
-    @robot.public_methods.should include("query")
-  end
-end # in history mode
-
-describe DSL::Robot, "on query command" do
-  before :each do
+		
+    @robot.login?.should be_true
+	end   
+end # when created
+
+describe DSL::Robot, "in history mode" do
+  before :each do
+    @robot = DSL::Robot.new(nil)
+  end
+
+  it "should set @duration, @from and @to" do
+    now = Time.now
+    @robot.history :duration => 300, :from => now-24*3600, :to => now
+    @robot.duration.should eql(300)
+    @robot.from.should eql(now-24*3600)
+    @robot.to.should eql(now)  
+  end  
+  
+  it "should raise exception on parameter absence" do
+    lambda { @robot.history({}) }.should raise_error
+  end
+  
+  it "should check @to - @from > @duration" do
+    lambda {@robot.history :duration => 300, :from => 1, :to => 2 }.should raise_error
+  end
+  
+  it "should create method alias query->query_history" do    
+    @robot.history :duration => 300, :from => Time.now-24*3600, :to => Time.now
+    @robot.public_methods.should include("query")
+  end
+end # in history mode
+
+describe DSL::Robot, "on query command" do
+  before :each do
     @ot = mock("OpenTick")
-		@contract = mock("DSL::Contract")
-    @robot = robot(@ot) do
-      history :duration => 1, :from => 2, :to => 5
-      query @contract do        
-      end
-    end
-  end
-  
-  it "should subscribe history quotes" do
-    @ot.should_receive(:subscribe).once
-    #with(OpenTick::IncomingMessages::HistoryStreamResponse, an_instance_of(Proc))		
+		@contract = mock("DSL::Contract")
+    @robot = robot(@ot) do
+      history :duration => 1, :from => 2, :to => 5
+      query @contract do        
+      end
+    end
+  end
+  
+  it "should subscribe history quotes" do
+    @ot.should_receive(:subscribe).once
+    #with(OpenTick::IncomingMessages::HistoryStreamResponse, an_instance_of(Proc))		
   end
 	
 	it "should send subscribe message to contracts" do
@@ -94,9 +94,9 @@ describe DSL::Robot, "on query command" do
   after :each do
     DSL::Contract.list_by_name.clear
     DSL::Contract.list_by_id.clear
-  end
-end # on query command
-
-
-  
-
+  end
+end # on query command
+
+
+  
+

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: tradingrobotdsl
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
-date: 2007-11-19 00:00:00 +03:00
+  version: 0.0.2
+date: 2007-11-24 00:00:00 +03:00
 summary: Domain specific language for automated trading (robots)
 require_paths: 
 - lib