vagas-orientdb4r 0.5.2

data/lib/orientdb4r/utils.rb

@@ -0,0 +1,203 @@
+module Orientdb4r
+
+  module Utils
+
+    def verify_options(options, pattern)
+      raise ArgumentError, 'options cannot be nil' if options.nil?
+
+      # unknown key?
+      options.keys.each do |k|
+        raise ArgumentError, "unknow option: #{k}" unless pattern.keys.include? k
+      end
+      # missing mandatory option?
+      pattern.each do |k,v|
+        raise ArgumentError, "missing mandatory option: #{k}" if v == :mandatory and !options.keys.include? k
+      end
+      # option in a set of allowed values
+      pattern.each do |k,v|
+        if v.instance_of? Array
+          raise ArgumentError, "value '#{options[k]}' not in #{v.inspect}, key=#{k}" unless v.include?(options[k])
+        end
+      end
+
+      options
+    end
+
+    def verify_and_sanitize_options(options, pattern)
+      verify_options(options, pattern)
+
+      # set default values if missing in options
+      pattern.each do |k,v|
+        options[k] = v if !v.nil? and :optional != v and !options.keys.include? k
+      end
+      options
+    end
+
+
+    ###
+    # Checks if a given string is either 'nil' or empty string.
+    def blank?(str)
+      str.nil? or (str.is_a? String and str.strip.empty?)
+    end
+
+    ###
+    # Generates a random string with given length.
+    def random_string(len=8)
+      (0...len).map{65.+(rand(25)).chr}.join
+    end
+
+    ###
+    # Compares two given versions.
+    # ==== Returns
+    # * 1 if first > second
+    # * 0 if first == second
+    # * -1 if first < second
+    def compare_versions(first, second)
+      raise ArgumentError, "bad version format, version=#{first}" unless first =~ Orientdb4r::Client::SERVER_VERSION_PATTERN
+      raise ArgumentError, "bad version format, version=#{second}" unless second =~ Orientdb4r::Client::SERVER_VERSION_PATTERN
+
+      firstv = /^(?:(\d+)\.)?(?:(\d+)\.)?(\*|\d+)/.match(first)[0]
+      secondv = /^(?:(\d+)\.)?(?:(\d+)\.)?(\*|\d+)/.match(second)[0]
+
+      rslt = 0
+      rslt = 1 if firstv > secondv
+      rslt = -1 if firstv < secondv
+
+      yield rslt if block_given?
+
+      rslt
+    end
+
+    class Proxy
+
+      attr_reader :target, :context
+
+      def initialize(target, context)
+        @target = target
+        @context = context
+      end
+
+      def proxy(&block)
+        block.call
+      end
+
+    end # Proxy
+
+  end # Utils
+
+
+  # TODO extend it to work with already defined methods ('before :foo, :baz' after method definition) [BF #21]
+  module Aop2
+
+    def self.included(base)
+      base.extend ClassMethods2
+      base.init_aop_extension
+    end
+
+    def aop_context
+      Thread.current[:aop2_context]
+    end
+    def aop_context=(ctx={})
+      Thread.current[:aop2_context] = ctx
+    end
+
+    module ClassMethods2
+
+      def init_aop_extension
+        @hooks = {}
+        [:before, :after, :around].each { |where| @hooks[where] = Hash.new { |hash, key| hash[key] = [] }}
+        # will be like this:
+        # {:before=>{:disconnect=>[:assert_connected], :query=>[:assert_connected], :command=>[:assert_connected]}, :after=>{}, :around=>{}}
+        class << self
+          attr_reader :hooks
+        end
+        @@redefining = false # flag whether the process of method redefining is running
+      end
+      def method_added(method)
+        unless @@redefining # avoid recursion
+          redefine_method(method) if is_hooked?(method)
+        end
+      end
+
+      #----------------------------------------------------------------- Helpers
+
+      def is_hooked?(method)
+        # look into array of keys (method names) in 2nd level hashs (see above)
+        hooks.values.map(&:keys).flatten.uniq.include? method
+      end
+
+
+
+      def before(original_method, *hooks)
+        add_hook(:before, original_method, *hooks)
+      end
+      def after(original_method, *hooks)
+        add_hook(:after, original_method, *hooks)
+      end
+      def around(original_method, *hooks)
+        add_hook(:around, original_method, *hooks)
+      end
+
+
+      def add_hook(type, original_method, *hooks) #!!
+        Array(original_method).each do |method|
+          store_hook(type, method, *hooks)
+        end
+      end
+      def store_hook(type, method_name, *hook_methods) #!!
+        hooks[type.to_sym][method_name.to_sym] += hook_methods.flatten.map(&:to_sym)
+      end
+
+      def redefine_method(orig_method)
+        @@redefining = true
+
+        arity = instance_method(orig_method.to_sym).arity
+        params = ''
+        fixed_cnt = arity.abs
+        fixed_cnt -= 1 if arity < 0
+        # build up a list of params
+        1.upto(fixed_cnt).each {|x| params << "p#{x},"}
+        params << "*argv" if arity < 0
+        params.gsub!(/,$/, '') # remove last ','
+
+        alias_method "#{orig_method}_aop2_orig".to_sym, orig_method.to_sym
+
+        class_eval <<-FILTER,__FILE__,__LINE__ + 1
+          def #{orig_method}(#{params})
+            self.aop_context = { :method => '#{orig_method}', :class => self.class }
+            begin
+              self.class.invoke_hooks(self, :before, :#{orig_method})
+              rslt = self.class.invoke_arround_hooks(self, :#{orig_method}, self.class.hooks[:around][:#{orig_method}].clone) {
+                #{orig_method}_aop2_orig(#{params})
+              }
+              self.class.invoke_hooks(self, :after, :#{orig_method})
+#            rescue Exception => e
+#              # TODO use logging
+#              $stderr.puts '' << e.class.name << ': ' << e.message
+#              $stderr.puts e.backtrace.inspect
+#              raise e
+            ensure
+              self.aop_context = nil
+            end
+            rslt
+          end
+        FILTER
+
+        @@redefining = false
+      end
+
+      def invoke_hooks(obj, hook_type, method_name)
+        hooks[hook_type][method_name.to_sym].each { |hook| obj.send hook }
+      end
+      def invoke_arround_hooks(obj, method_name, hooks, &block)
+        hook = hooks.slice! 0
+        return block.call if hook.nil? # call original method if no more hook
+
+        # invoke the hook with lambda containing recursion
+        obj.send(hook.to_sym) { invoke_arround_hooks(obj, method_name, hooks, &block); }
+      end
+
+    end # ClassMethods2
+  end # Aop2
+
+end

data/lib/orientdb4r/version.rb

@@ -0,0 +1,39 @@
+module Orientdb4r
+
+  # Version history.
+  VERSION_HISTORY = [
+    ['0.5.2',   '2016-09-17', "Compatible with OrientDB v2.2.x, PR #44, PR #45"],
+    ['0.5.1',   '2015-03-26', "Enh #39, PR #40"],
+    ['0.5.0',   '2015-03-03', "Compatible with OrientDB v2.x, PR #31, PR #32, PR #33"],
+    ['0.4.1',   '2013-09-03', "Enh #24, Enh #26, Enh #27"],
+    ['0.4.0',   '2013-08-14', "Closed gap between this driver and OrientDB v1.4.0+; Enh #20, BF #25"],
+    ['0.3.3',   '2012-12-16', "Enh #18, Enh #19"],
+    ['0.3.2',   '2012-11-02', "Enh #13, Enh #16"],
+    ['0.3.1',   '2012-08-27', "Timeout for reuse of dirty nodes in load balancing; BF #14, BF #15"],
+    ['0.3.0',   '2012-08-01', "Added support for cluster of distributed servers + load balancing"],
+    ['0.2.10',  '2012-07-21', "Experimental support for Excon HTTP library with Keep-Alive connection"],
+    ['0.2.9',   '2012-07-18', "Added feature Client#delete_database, New class Rid"],
+    ['0.2.8',   '2012-07-16', "New exception handling, added feature Client#create_class(:properties)"],
+    ['0.2.7',   '2012-07-07', "Added method Client#class_exists?"],
+    ['0.2.6',   '2012-07-03', "BF #8, BF #6"],
+    ['0.2.5',   '2012-07-01', "Added 'get_database' into database CRUD"],
+    # v-- https://groups.google.com/forum/?fromgroups#!topic/orient-database/5MAMCvFavTc
+    ['0.2.4',   '2012-06-26', "Added session management"],
+    ['0.2.3',   '2012-06-24', "Documents received by a query are kind of Orientdb4r::DocumentMetadata"],
+    # v-- https://groups.google.com/forum/?fromgroups#!topic/orient-database/jK4EZd068AE
+    # v-- https://groups.google.com/forum/?fromgroups#!topic/orient-database/nJOAsgwSnKI
+    ['0.2.2',   '2012-06-23', "Added support for server version detection [r5913]"],
+    ['0.2.1',   '2012-06-19', "Fixed linked property definition"],
+    ['0.2.0',   '2012-06-12', "Introduces document's CRUD operations"],
+    ['0.1.2',   '2012-06-10', 'Introduces new OClass module'],
+    ['0.1.1',   '2012-06-08', 'First working version (including unit tests) released at github.com'],
+    ['0.1.0',   '2012-06-02', 'Initial version on Ruby-1.9.3p194 and OrientDB-1.0.0']
+  ]
+
+  # Current version.
+  VERSION = VERSION_HISTORY[0][0]
+
+  # Driver identification.
+  DRIVER_NAME = 'Orientdb4r Ruby Client'
+
+end

data/orientdb4r.gemspec

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'orientdb4r/version'
+
+Gem::Specification.new do |s|
+
+  s.name = %q{vagas-orientdb4r}
+  s.version = Orientdb4r::VERSION
+
+  s.required_rubygems_version = Gem::Requirement.new('> 1.3.1') if s.respond_to? :required_rubygems_version=
+  s.authors = ['Vaclav Sykora', 'Ronie Uliana']
+  s.date = Orientdb4r::VERSION_HISTORY[0][1]
+  s.description = %q{Orientdb4r provides a simple interface on top of OrientDB's RESTful HTTP API (VAGAS.com version)}
+  s.email = %q{vaclav.sykora@gmail.com ronie.uliana@gmail.com}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.rdoc"
+  ]
+  s.homepage = %q{http://github.com/vagascom/orientdb4r}
+  s.rdoc_options = ['--charset=UTF-8']
+  s.require_paths = ['lib']
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Ruby binding for Orient DB.}
+  s.license = 'Apache License, v2.0'
+
+  s.add_dependency(%q<rest-client>, ["~> 1.7"])
+
+  s.add_development_dependency "rake", "~> 10.3"
+
+end

data/test/bin/test_client.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+
+###
+# This class tests communication with OrientDB cluster and load balancing.
+# Note: Test of binary communication.
+class TestBinDatabase < Test::Unit::TestCase
+
+  DB = 'temp'
+#Orientdb4r::logger.level = Logger::DEBUG
+
+  def setup
+    @client = Orientdb4r.client :binary => true
+  end
+
+  ###
+  # CONNECT
+  def test_connect
+    assert_nothing_thrown do @client.connect :database => DB, :user => 'admin', :password => 'admin'; end
+  end
+
+end

data/test/readme_sample.rb

@@ -0,0 +1,38 @@
+  $: << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+  require 'orientdb4r'
+
+  CLASS = 'myclass'
+
+  client = Orientdb4r.client  # equivalent for :host => 'localhost', :port => 2480, :ssl => false
+
+  client.connect :database => 'temp', :user => 'admin', :password => 'admin'
+
+  unless client.class_exists? CLASS
+    client.create_class(CLASS) do |c|
+      c.property 'prop1', :integer, :notnull => true, :min => 1, :max => 99
+      c.property 'prop2', :string, :mandatory => true
+      c.link     'users', :linkset, 'OUser' # by default: :mandatory => false, :notnull => false
+    end
+  end
+
+  admin = client.query("SELECT FROM OUser WHERE name = 'admin'")[0]
+  1.upto(5) do |i|
+    # insert link to admin only to first two
+    client.command "INSERT INTO #{CLASS} (prop1, prop2, users) VALUES (#{i}, 'text#{i}', [#{admin['@rid'] if i<3}])"
+  end
+
+  puts client.query "SELECT FROM #{CLASS}"
+  #>
+
+  puts client.query "SELECT count(*) FROM #{CLASS}"
+  #>
+
+  puts client.query "SELECT max(prop1) FROM #{CLASS}"
+  #>
+
+  puts client.query "TRAVERSE any() FROM (SELECT FROM #{CLASS} WHERE prop1 = 1)"
+  #>
+
+
+  client.drop_class CLASS
+  client.disconnect

data/test/test_client.rb

@@ -0,0 +1,93 @@
+require 'test_helper'
+
+###
+# This class tests communication with OrientDB cluster and load balancing.
+class TestClient < Test::Unit::TestCase
+
+  PROXY_URL = 'http://bad.domain.com'
+
+  ###
+  # Test inintialization of corresponding client type
+  def test_client_type
+    client = Orientdb4r.client :instance => :new
+    assert_instance_of Orientdb4r::RestClient, client
+    client = Orientdb4r.client :instance => :new, :binary => true
+    assert_instance_of Orientdb4r::Binary::BinClient, client
+  end
+
+  ###
+  # Test inintialization of single node.
+  def test_one_node_initialization
+    client = Orientdb4r.client :instance => :new
+    assert_not_nil client.nodes
+    assert_instance_of Array, client.nodes
+    assert_equal 1, client.nodes.size
+    assert_equal 2480, client.nodes[0].port
+    assert_equal false, client.nodes[0].ssl
+  end
+
+  ###
+  # Test inintialization of more nodes.
+  def test_nodes_initialization
+    client = Orientdb4r.client :nodes => [{}, {:port => 2481}], :instance => :new
+    assert_not_nil client.nodes
+    assert_instance_of Array, client.nodes
+    assert_equal 2, client.nodes.size
+    assert_equal 2480, client.nodes[0].port
+    assert_equal 2481, client.nodes[1].port
+    assert_equal false, client.nodes[0].ssl
+    assert_equal false, client.nodes[1].ssl
+
+    client = Orientdb4r.client :nodes => [{}, {:port => 2481}, {:port => 2482}], :instance => :new
+    assert_equal 3, client.nodes.size
+  end
+
+  ###
+  # Tests initialization of connection library.
+  def test_connection_library
+    # restclient
+    client = Orientdb4r.client :instance => :new
+    assert_equal :restclient, client.connection_library
+    assert_instance_of Orientdb4r::RestClientNode, client.nodes[0]
+
+    # excon
+    if Gem::Specification::find_all_by_name('excon').any?
+      client = Orientdb4r.client :connection_library => :excon, :instance => :new
+      assert_equal :excon, client.connection_library
+      assert_instance_of Orientdb4r::ExconNode, client.nodes[0]
+    end
+  end
+
+  ###
+  # Tests initialization of proxy.
+  def test_proxy
+    # no proxy - resclient
+    client = Orientdb4r.client :instance => :new
+    assert_nil client.proxy
+    assert_nil RestClient.proxy
+
+    # proxy - restclient
+    client = Orientdb4r.client :proxy => PROXY_URL, :instance => :new
+    assert_equal PROXY_URL, client.proxy
+    assert_equal PROXY_URL, RestClient.proxy
+    assert_raise Orientdb4r::ConnectionError do
+      client.connect :database => 'temp', :user => 'admin', :password => 'admin'
+    end
+    RestClient.proxy = nil # restore no setting
+
+    if Gem::Specification::find_all_by_name('excon').any?
+      # no proxy - excon
+      client = Orientdb4r.client :connection_library => :excon, :instance => :new
+      assert_nil client.proxy
+      assert_nil client.nodes[0].proxy
+
+      # proxy - excon
+      client = Orientdb4r.client :connection_library => :excon, :proxy => PROXY_URL, :instance => :new
+      assert_equal PROXY_URL, client.proxy
+      assert_equal PROXY_URL, client.nodes[0].proxy
+      assert_raise Orientdb4r::ConnectionError do
+        client.connect :database => 'temp', :user => 'admin', :password => 'admin'
+      end
+    end
+  end
+end

data/test/test_database.rb

@@ -0,0 +1,261 @@
+require 'test_helper'
+
+###
+# This class tests DB management.
+class TestDatabase < Test::Unit::TestCase
+
+  DB = 'temp'
+
+  def setup
+    @client = Orientdb4r.client
+  end
+
+  def teardown
+    if @client.database_exists? :database => 'UniT', :user => 'root', :password => DB_ROOT_PASS
+      @client.delete_database :database => 'UniT', :user => 'root', :password => DB_ROOT_PASS
+    end
+    @client.disconnect
+  end
+
+  ###
+  # CONNECT
+  def test_connect
+    assert_nothing_thrown do @client.connect :database => DB, :user => 'admin', :password => 'admin'; end
+    rslt = @client.connect :database => DB, :user => 'admin', :password => 'admin'
+    assert_instance_of TrueClass, rslt
+
+    assert_equal 'admin', @client.user
+    assert_equal 'admin', @client.password
+    assert_equal DB, @client.database
+
+    # connection refused
+    client = Orientdb4r.client :port => 2840, :instance => :new
+    assert_raise Orientdb4r::ConnectionError do
+      client.connect :database => DB, :user => 'admin', :password => 'admin'
+    end
+
+    # bad DB name
+    assert_raise Orientdb4r::UnauthorizedError do
+      @client.connect :database => 'unknown_db', :user => 'admin', :password => 'admin'
+    end
+    # !!! curl -v --user admin:adminX http://localhost:2480/connect/foo/bar
+#    # bad DB name with '/' => wrong REST resource
+#    assert_raise Orientdb4r::ServerError do
+#      @client.connect :database => 'temp/temp', :user => 'admin', :password => 'admin'
+#    end
+    # bad credentials
+    assert_raise Orientdb4r::UnauthorizedError do
+      @client.connect :database => DB, :user => 'admin1', :password => 'admin'
+    end
+  end
+
+
+  ###
+  # DISCONNECT
+  def test_disconnect
+    @client.connect :database => DB, :user => 'admin', :password => 'admin'
+    assert @client.connected?
+    assert_nothing_thrown do @client.disconnect; end
+    assert !@client.connected?
+    # unable to query after disconnect
+    assert_raise Orientdb4r::ConnectionError do @client.query 'SELECT FROM OUser'; end
+
+    assert_nil @client.user
+    assert_nil @client.password
+    assert_nil @client.database
+  end
+
+
+  ###
+  # CREATE DATABASE
+  def test_create_database
+    # bad options
+    assert_raise ArgumentError do @client.create_database(:database => 'UniT', :storage => :foo); end
+    assert_raise ArgumentError do @client.create_database(:database => 'UniT', :type => :foo); end
+
+    assert_nothing_thrown do
+      @client.create_database :database => 'UniT', :user => 'root', :password => DB_ROOT_PASS
+    end
+    assert_nothing_thrown do
+      @client.get_database :database => 'UniT', :user => 'admin', :password => 'admin'
+    end
+    # creating an existing DB
+    assert_raise Orientdb4r::StateConflictError do
+      @client.create_database :database => 'UniT', :user => 'root', :password => DB_ROOT_PASS
+    end
+    # insufficient rights
+    assert_raise Orientdb4r::UnauthorizedError do
+      @client.create_database :database => 'UniT1', :user => 'admin', :password => 'admin'
+    end
+
+    # By convention 3 users are always created by default every time you create a new database.
+    # Default users are: admin, reader, writer
+    assert_nothing_thrown do
+      @client.connect :database => 'UniT', :user => 'admin', :password => 'admin'
+    end
+    @client.delete_database({:database => 'UniT', :user => 'root', :password => DB_ROOT_PASS})
+
+    # create non-default DB: storage=local;type=graph
+    assert_nothing_thrown do
+      @client.create_database :database => 'UniT', :user => 'root', :password => DB_ROOT_PASS, :storage => :plocal, :type => :graph
+      @client.delete_database :database => 'UniT', :user => 'root', :password => DB_ROOT_PASS
+    end
+  end
+
+
+  ###
+  # GET DATABASE
+  def test_get_database
+    # not connected - allowed with additional authentication
+    assert_nothing_thrown do @client.get_database :database => DB, :user => 'admin', :password => 'admin' ; end
+    assert_raise Orientdb4r::ConnectionError do @client.get_database; end
+    # connected
+    @client.connect :database => DB, :user => 'admin', :password => 'admin'
+    assert_nothing_thrown do @client.get_database; end # gets info about connected DB
+
+    rslt = @client.get_database
+    assert_not_nil rslt
+    assert_instance_of Hash, rslt
+    assert !rslt.empty?
+    # server
+    assert rslt.include? 'server'
+    assert_instance_of Hash, rslt['server']
+    assert !rslt['server'].empty?
+    assert rslt['server'].include? 'version'
+    # classes
+    assert rslt.include? 'classes'
+    assert_instance_of Array, rslt['classes']
+    assert !rslt['classes'].empty?
+
+    # bad databases
+    assert_raise Orientdb4r::UnauthorizedError do @client.get_database :database => 'UnknownDB'; end
+    assert_raise Orientdb4r::ServerError do @client.get_database :database => 'temp/admin'; end # bad REST resource
+
+
+    # database_exists?
+    assert @client.database_exists?(:database => DB, :user => 'admin', :password => 'admin')
+    assert @client.database_exists?(:database => DB) # use credentials of logged in user
+    assert !@client.database_exists?(:database => 'UnknownDB')
+    assert !@client.database_exists?(:database => 'temp/admin')
+  end
+
+
+  ###
+  # DELETE DATABASE
+  def test_delete_database
+    @client.create_database :database => 'UniT', :user => 'root', :password => DB_ROOT_PASS
+
+    # deleting non-existing DB
+    assert_raise Orientdb4r::ServerError do
+      @client.delete_database :database => 'UniT1', :user => 'root', :password => DB_ROOT_PASS
+    end
+    # insufficient rights
+    assert_raise Orientdb4r::UnauthorizedError do
+      @client.delete_database :database => 'UniT', :user => 'admin', :password => 'admin'
+    end
+
+    assert_nothing_thrown do
+      @client.delete_database({:database => 'UniT', :user => 'root', :password => DB_ROOT_PASS})
+    end
+  end
+
+
+  ###
+  # SERVER info
+  def xtest_server
+    # admin/admin has not 'server.info' resource access in standard installation
+    assert_raise Orientdb4r::OrientdbError do @client.server :user => 'admin', :password => 'admin'; end
+
+    assert_nothing_thrown do @client.server :user => 'root', :password => DB_ROOT_PASS; end
+    rslt = @client.server :user => 'root', :password => DB_ROOT_PASS
+    assert_instance_of Hash, rslt
+    assert rslt.include? 'connections'
+    assert_not_nil rslt['connections']
+  end
+
+
+  ###
+  # GET List Databases
+  # Retrieves the available databases.
+  def test_list_databases
+    dbs = @client.list_databases :user => 'root', :password => DB_ROOT_PASS
+    assert_not_nil dbs
+    assert_instance_of Array, dbs
+    assert !dbs.empty?
+    assert dbs.include? DB
+  end
+
+
+  ###
+  # Test of :assert_connected before advice.
+  def test_assert_connected
+    @client.disconnect if @client.connected? # to be sure it this method is called as first in this TestCase and thread local client is still connected
+    assert_raise Orientdb4r::ConnectionError do @client.query 'SELECT FROM OUser'; end
+    assert_raise Orientdb4r::ConnectionError do @client.command "INSERT INTO OUser(name) VALUES('x')"; end
+    assert_raise Orientdb4r::ConnectionError do @client.gremlin("g.addVertex('class:X', 'prop1', 1, 'prop2', 'string1')"); end
+    assert_raise Orientdb4r::ConnectionError do @client.batch({:transaction => true, :operations => []}); end
+    #BF #21 assert_raise Orientdb4r::ConnectionError do @client.create_class 'x'; end
+    assert_raise Orientdb4r::ConnectionError do @client.create_property 'x', 'prop', :boolean; end
+    assert_raise Orientdb4r::ConnectionError do @client.class_exists? 'x'; end
+    assert_raise Orientdb4r::ConnectionError do @client.get_class 'x'; end
+    assert_raise Orientdb4r::ConnectionError do @client.drop_class 'x'; end
+    assert_raise Orientdb4r::ConnectionError do @client.create_document({ '@class' => 'x', :prop => 1 }); end
+    assert_raise Orientdb4r::ConnectionError do @client.get_document('#1:0'); end
+    assert_raise Orientdb4r::ConnectionError do @client.update_document({}); end
+    assert_raise Orientdb4r::ConnectionError do @client.delete_document('#1:0'); end
+  end
+
+
+  ###
+  # Tests using of session ID.
+  def test_session_id
+    client = Orientdb4r.client :instance => :new
+    assert_nil client.nodes[0].session_id
+    client.connect :database => DB, :user => 'admin', :password => 'admin'
+    session_id = client.nodes[0].session_id
+    assert_not_nil session_id
+    client.query 'SELECT count(*) FROM OUser'
+    assert_equal session_id, client.nodes[0].session_id
+    client.get_class 'OUser'
+    assert_equal session_id, client.nodes[0].session_id
+    client.disconnect
+    assert_nil client.nodes[0].session_id
+  end
+
+
+  ###
+  # EXPORT
+  def test_export
+    client = Orientdb4r.client :instance => :new
+
+    # export of connected database
+    client.connect :database => DB, :user => 'admin', :password => 'admin'
+    rslt = client.export
+    assert File.exist? './temp.gz'
+    assert File.file? './temp.gz'
+    assert 'temp.gz', rslt
+    File.delete './temp.gz'
+
+    # export with given file
+    given_filename = "#{Dir.tmpdir}/TEMP.gz"
+    client.export :file => given_filename
+    assert File.exist? given_filename
+    assert File.file? given_filename
+    assert given_filename, rslt
+
+    # explicit given DB
+    client.disconnect
+    assert_nothing_thrown do
+      client.export :database => DB, :user => 'admin', :password => 'admin', :file => given_filename
+    end
+    # unknow DB
+    assert_raise Orientdb4r::UnauthorizedError do
+      client.export :database => 'unknown', :user => 'admin', :password => 'admin'
+    end
+    # bad password
+    assert_raise Orientdb4r::UnauthorizedError do
+      client.export :database => DB, :user => 'admin', :password => 'unknown'
+    end
+  end
+
+end