orient_db_client 0.0.1

data/test/integration/server_session_test.rb

@@ -0,0 +1,37 @@
+require File.join File.dirname(__FILE__), '..', 'test_helper'
+
+class TestServerSession < MiniTest::Unit::TestCase
+	include ServerConfig
+	include ConnectionHelper
+
+	def setup
+		@options = SERVER_OPTIONS
+		@connection = connect_to_orientdb(SERVER_OPTIONS)
+		@session = @connection.open_server({
+			:user => @options["server_user"],
+			:password => @options["server_password"]
+		})
+	end
+
+	def teardown
+		@connection.close if @connection
+	end
+
+  def test_database_exists_command
+  	assert @session.database_exists?(@options["database"])
+  	refute @session.database_exists?("InvalidDatabase")
+  end
+
+  def test_create_and_delete_local_database_commands
+  	database = "test_create_local_database"
+
+    @session.delete_database(database) if @session.database_exists?(database)
+
+  	begin
+  		@session.create_local_database(database)
+  		assert @session.database_exists?(database)
+  	ensure
+  		@session.delete_database(database) if @session.database_exists?(database)
+  	end
+  end
+end

data/test/support/connection_helper.rb

@@ -0,0 +1,25 @@
+module ConnectionHelper
+  def connect_to_orientdb(options)
+		OrientDbClient.connect(options["host"], {
+      port: options["port"]
+    })
+  end
+
+  def mock_connect_to_orientdb(version, socket = nil)
+    mock_socket = socket || MiniTest::Mock.new
+    connection = nil
+
+    begin
+      TCPSocket.stubs(:open).returns(mock_socket)
+
+      mock_socket.stubs(:read).returns([version].pack('s>'))
+      mock_socket.stubs(:close)
+
+      connection = connect_to_orientdb({})
+    ensure
+      TCPSocket.unstub(:open)
+    end
+
+    connection
+  end
+end

data/test/support/create_database.sql

@@ -0,0 +1,33 @@
+# Setting up V prototype database in OrientDB
+
+DROP DATABASE remote:localhost/ruby_driver_test root "8F6FB3168FAF265896A3532C83C5E33F8B6A47996229184582D1499D5B3E8C75";
+
+CREATE DATABASE remote:localhost/ruby_driver_test root "8F6FB3168FAF265896A3532C83C5E33F8B6A47996229184582D1499D5B3E8C75" local;
+
+CONNECT remote:localhost/ruby_driver_test admin admin;
+
+CREATE CLUSTER ographvertex PHYSICAL APPEND;
+CREATE CLUSTER ographedge PHYSICAL APPEND;
+
+CREATE CLASS OGraphVertex CLUSTER ographvertex;
+ALTER CLASS ographvertex SHORTNAME V;
+
+CREATE CLASS OGraphEdge CLUSTER ographedge;
+ALTER CLASS ographedge SHORTNAME E;
+
+CREATE PROPERTY OGraphVertex.in LINKSET OGraphEdge;
+CREATE PROPERTY OGraphVertex.out LINKSET OGraphEdge;
+
+CREATE PROPERTY OGraphEdge.in LINK OGraphVertex;
+CREATE PROPERTY OGraphEdge.out LINK OGraphVertex;
+
+# ----------------------------------------------------------------------
+# DATA
+# ----------------------------------------------------------------------
+
+INSERT INTO V (label, in, out) VALUES ('User 1', [], []);
+INSERT INTO V (label, in, out) VALUES ('User 2', [], []);
+
+INSERT INTO E (label, out, in) VALUES ('follows', #5:0, #5:1);
+UPDATE #5:0 ADD out = #6:0;
+UPDATE #5:1 ADD in = #6:0;

data/test/support/databases.yml

@@ -0,0 +1,8 @@
+test:
+  host: localhost
+  port: 2424
+  server_user: root
+  server_password: 83CACE21A23DB46F93BFD58A3CE48C8D29926C6EF424D7DA9BD725AE070CCDC0
+  database: temp
+  user: admin
+  password: admin

data/test/support/expectation_helper.rb

@@ -0,0 +1,13 @@
+module ExpectationHelper
+  def expect_sequence(subject, chain, name)
+    sequence_instance = sequence(name)
+
+    chain.each do |step|
+    	expectation = subject.expects(step[:method])
+
+    	expectation.with(step[:param]) if step[:param]
+
+    	expectation.returns(step[:return]).in_sequence(sequence_instance)
+    end
+  end
+end

data/test/support/protocol_helper.rb

@@ -0,0 +1,25 @@
+module ProtocolHelper
+  def pack_byte(value)
+    if value.is_a?(String)
+      value = value.length > 0 ? value[0].ord : 0
+    end
+
+    [ value ].pack('C')
+  end
+
+  def pack_integer(value)
+    [ value ].pack('l>')
+  end
+
+  def pack_long(value)
+    [ value ].pack('q>')
+  end
+
+  def pack_short(value)
+    [ value ].pack('s>')
+  end
+
+  def pack_string(value)
+    [ value ].pack('a*')
+  end
+end

data/test/support/server_config.rb

@@ -0,0 +1,6 @@
+require 'yaml'
+
+module ServerConfig
+		SERVER_CONFIG = YAML.load_file(File.join(File.dirname(__FILE__), "databases.yml"))
+		SERVER_OPTIONS = SERVER_CONFIG["test"]
+end

data/test/support/servers-template.yml

@@ -0,0 +1,5 @@
+test:
+	host: localhost
+	port: 2424
+	user: root
+	password: # Listed in orientdb-server-config.xml of OrientDB server

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+gem 'minitest' # ensures you're using the gem, and not the built in MT
+require 'minitest/autorun'
+require 'mocha'
+
+Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
+
+require 'orient_db_client'
+require 'orient_db_client/exceptions'

data/test/unit/connection_test.rb

@@ -0,0 +1,84 @@
+require File.join File.dirname(__FILE__), '..', 'test_helper'
+
+class TestConnection < MiniTest::Unit::TestCase
+	include ConnectionHelper
+	include ServerConfig
+
+	def setup
+		@connection = mock_connect_to_orientdb(7, @socket)
+		@options = SERVER_OPTIONS
+    @session = 25234
+	end
+
+  def test_creating_a_cluster
+    expected_cluster_id = 65
+
+    OrientDbClient::Protocols::Protocol7.stubs(:datacluster_add).returns({
+      :session => @session,
+      :message_content => { :new_cluster_number => expected_cluster_id }
+    })
+
+    cluster_id = @connection.create_cluster(@session, :physical, "TEST")
+
+    assert_equal expected_cluster_id, cluster_id
+  end
+
+  def test_creating_a_record
+    cluster_id = 5
+    expected_cluster_position = 735
+
+    OrientDbClient::Protocols::Protocol7.stubs(:record_create).returns({
+      :session => @session,
+      :message_content => { :cluster_id => cluster_id,
+                            :cluster_position => expected_cluster_position }
+    })
+
+    rid = @connection.create_record(@session, cluster_id, {})
+
+    assert_equal cluster_id, rid.cluster_id
+    assert_equal expected_cluster_position, rid.cluster_position
+  end
+
+  def test_updating_a_record
+    expected_version = 1
+
+    OrientDbClient::Protocols::Protocol7.stubs(:record_update).returns({
+      :session => @session,
+      :message_content => { :record_version => expected_version }
+    })
+
+    version = @connection.update_record(@session, OrientDbClient::Rid.new(1,0), {}, :none)
+
+    assert_equal expected_version, version
+  end
+
+  def test_opening_the_server
+    OrientDbClient::Protocols::Protocol7.stubs(:connect).returns({
+      :session => @session,
+      :message_content => { :session => @session }
+    })
+
+    session = @connection.open_server({
+      :user => @options["server_user"],
+      :password => @options["server_password"]
+    })
+
+    assert_instance_of OrientDbClient::ServerSession, session
+    assert_equal @session, session.id
+  end
+
+  def test_opening_a_database
+    OrientDbClient::Protocols::Protocol7.stubs(:db_open).returns({
+      :session => @session,
+      :message_content => { :session => @session, :clusters => [] }
+    })
+
+  	session = @connection.open_database(@options["database"], {
+  		:user => @options["user"],
+  		:password => @options["password"]
+  	})
+
+  	assert_instance_of OrientDbClient::DatabaseSession, session
+    assert_equal @session, session.id
+  end
+end

data/test/unit/deserializers/deserializer7_test.rb

@@ -0,0 +1,141 @@
+require File.join File.dirname(__FILE__), '..', '..', 'test_helper'
+
+class TestDeserializer7 < MiniTest::Unit::TestCase
+    def setup
+        @deserializer = OrientDbClient::Protocols::Protocol7.deserializer
+    end
+
+    def test_deserialize
+        record = %Q{ORole@name:"ORole",id:0,defaultClusterId:3,clusterIds:[3],inheritedRole:#3:2,lastUpdate:1296279468t,buffer:_U2VuZCByZWluZm9yY2VtZW50cw==_,byte:97b,date:1306274400a,float:5.6234f,double:2.67234235d,bignum:6871947673673457345l,bigdec:6.2724522625234c,properties:[(name:"mode",type:17,offset:0,mandatory:false,notNull:false,min:,max:,linkedClass:,linkedType:,index:#),*name:"rules",type:12,offset:1,mandatory:false,notNull:false,min:,max:,linkedClass:,linkedType:17,index:#*]}
+
+        result = @deserializer.deserialize(record)
+
+        refute_nil result
+        
+        assert_equal 'ORole',   result[:class]
+
+        refute_nil  result[:structure]
+
+        result[:structure].tap do |s|
+            assert_equal :byte, s['byte']
+            assert_equal :binary, s['buffer']
+            assert_equal :integer, s['id']
+            assert_equal :float, s['float']
+            assert_equal :double, s['double']
+            assert_equal :time, s['lastUpdate']
+            assert_equal :long, s['bignum']
+            assert_equal :decimal, s['bigdec']
+            assert_equal :collection, s['properties']
+        end
+
+        result[:document].tap do |d|
+            assert_equal 0,         d['id']
+            assert_equal 3,         d['defaultClusterId']
+
+            assert d['inheritedRole'].is_a?(OrientDbClient::Rid), "expected Rid, but got #{d.class}"
+            assert_equal '#3:2', d['inheritedRole'].to_s
+
+            assert_equal 5.6234, d['float']
+            assert_equal 2.67234235, d['double']
+            assert_equal 6.2724522625234, d['bigdec']
+
+            assert_equal "Send reinforcements", d['buffer']
+
+            d['byte'].tap do |f|
+                assert_equal 97, f
+            end
+
+            d['bignum'].tap do |f|
+                assert f.is_a?(Bignum), "expected Bignum, but got #{f.class}"
+                assert_equal 6871947673673457345, f
+            end
+
+            d['date'].tap do |f|
+                assert f.is_a?(Date), "expected Date, but got #{f.class}"
+                assert_equal 2011,  f.year
+                assert_equal 5,     f.month
+                assert_equal 24,    f.day
+            end
+
+            d['lastUpdate'].tap do |f|
+                assert f.is_a?(Time), "expected Time, but got #{f.class}"
+                assert_equal 2011,  f.year
+                assert_equal 1,     f.month
+                assert_equal 29,    f.day
+                assert_equal 5,     f.hour
+                assert_equal 37,    f.min
+                assert_equal 48,    f.sec
+            end
+
+            d['clusterIds'].tap do |f|
+                assert f.is_a?(Array), "expected Array, but got #{f.class}"
+                assert_equal 1, f.length
+                assert_equal 3, f[0]
+            end
+
+            d['properties'].tap do |f|
+                assert f.is_a?(Array), "expected Array, but got #{f.class}"
+                assert_equal 2, f.length
+
+                refute_nil f[0][:structure]
+
+                f[0][:document].tap do |p|
+                    assert_equal 'mode',    p['name']
+                    assert_equal 17,        p['type']
+                    assert_equal 0,         p['offset']
+                    assert_equal false,     p['mandatory']
+                    assert_equal false,     p['notNull']
+                    assert_nil              p['min']
+                    assert_nil              p['max']
+                    assert_nil              p['linkedClass']
+                    assert_nil              p['linkedType']
+                    assert_nil              p['index']
+                end
+
+                f[1][:document].tap do |p|
+                    assert_equal 'rules',   p['name']
+                    assert_equal 12,        p['type']
+                    assert_equal 1,         p['offset']
+                    assert_equal false,     p['mandatory']
+                    assert_equal false,     p['notNull']
+                    assert_nil              p['min']
+                    assert_nil              p['max']
+                    assert_nil              p['linkedClass']
+                    assert_equal 17,        p['linkedType']
+                    assert_nil              p['index']
+                end
+            end
+        end
+    end
+
+    def test_deserialize_with_maps
+        record = %Q{ORole@name:"reader",inheritedRole:,mode:0,rules:{"database":null,"database.cluster.internal":2,"database.cluster.orole":3,"database.cluster.ouser":4,"database.class.*":5,"database.cluster.*":6,"database.query":7,"database.command":8,"database.hook.record":9}}
+
+        result = @deserializer.deserialize(record)
+
+        refute_nil result
+        
+        assert_equal 'ORole',   result[:class]
+
+        result[:document].tap do |d|
+            assert_nil d['inheritedRole']
+
+            assert_equal 0, d['mode']
+
+            d['rules'].tap do |f|
+                assert f.is_a?(Hash), "expected Hash, but got #{f.class}"
+
+                assert_nil   f['database']
+
+                assert_equal 2, f['database.cluster.internal']
+                assert_equal 3, f['database.cluster.orole']
+                assert_equal 4, f['database.cluster.ouser']
+                assert_equal 5, f['database.class.*']
+                assert_equal 6, f['database.cluster.*']
+                assert_equal 7, f['database.query']
+                assert_equal 8, f['database.command']
+                assert_equal 9, f['database.hook.record']
+            end
+        end
+    end
+end

data/test/unit/network_message_test.rb

@@ -0,0 +1,24 @@
+require File.join File.dirname(__FILE__), '..', 'test_helper'
+
+class TestNetworkMessage < MiniTest::Unit::TestCase
+	def test_pack
+		test_string = "This string is automatically preceeded by its size"
+
+		data = [
+			[ :byte, 143 ],
+			[ :short, 5000 ],
+			[ :integer, 153000 ],
+			[ :raw_string, "This is a string" ],
+			[ :integer, test_string.length, :skip ],
+			[ :string, test_string ]
+		]
+
+		expected = data.map { |d| d[1] }.pack('C s> l> a* l> a*')
+
+		message = OrientDbClient::NetworkMessage.new { |m|
+			data.each { |d|	m.add d[0], d[1] unless d[2] == :skip }
+		}
+
+		assert_equal expected, message.pack
+	end
+end

data/test/unit/orient_db_client_test.rb

@@ -0,0 +1,16 @@
+require File.join File.dirname(__FILE__), '..', 'test_helper'
+require 'socket'
+
+class TestOrientDbClient < MiniTest::Unit::TestCase
+  include ConnectionHelper
+
+  def test_exception_on_unsupported_protocol
+    bad_protocol = -1
+
+    exp = assert_raises(OrientDbClient::UnsupportedProtocolError) do
+      mock_connect_to_orientdb(bad_protocol)
+    end
+
+    assert_equal "The host reports protocol version #{bad_protocol}, which is not currently supported by this driver.", exp.message
+  end
+end

data/test/unit/protocol_factory_test.rb

@@ -0,0 +1,14 @@
+require File.join File.dirname(__FILE__), '..', 'test_helper'
+
+require 'orient_db_client/protocol_factory'
+
+class TestProtocolFactory < MiniTest::Unit::TestCase
+	def test_returns_protocol7_instance
+ 	 	assert_equal OrientDbClient::Protocols::Protocol7, OrientDbClient::ProtocolFactory.get_protocol(7)
+ 	end
+
+    def test_returns_protocol9_instance
+        assert_equal OrientDbClient::Protocols::Protocol9, OrientDbClient::ProtocolFactory.get_protocol(9)
+    end
+end
+