ass_tests 1.0.0.alpha

data/lib/ass_tests/fixt.rb

@@ -0,0 +1,50 @@
+module AssTest
+  module OleFixt
+    class Abstract
+      attr_reader :ole_connector
+      def initialize(ole_connector)
+        @ole_connector = ole_connector
+      end
+
+      def fill(obj, **fields)
+        fields.each do |f, v|
+          obj.send("#{f}=".to_sym, v)
+        end
+        obj
+      end
+      private :fill
+
+      def fill_table(obj, table_name, rows = [])
+        table = obj.send(table_name.to_sym)
+        rows.each do |row|
+          fill(table.add, **row)
+        end
+        table
+      end
+      private :fill_table
+    end
+    def self.catalog(ole_connector)
+      Catalog.new(ole_connector)
+    end
+    class Catalog < Abstract
+      def new_(method, md_name, fields, tables)
+        r = ole_connector.catalogs.send(md_name.to_sym).send(method)
+        fill(r, fields)
+        tables.each do |table, rows|
+          fill_table(r, table, rows)
+        end
+        fill(r, fields)
+        yield r if block_given?
+        r.write
+        r.ref
+      end
+      private :new_
+      def new_item(md_name, fields = {}, tables = {}, &block)
+        new_(:createItem, md_name, fields, tables, &block)
+      end
+      def new_folder(md_name, fields = {}, tables = {}, &block)
+        new_(:createFolder, md_name, fields, tables, &block)
+      end
+    end
+  end
+end

data/lib/ass_tests/info_bases.rb

@@ -0,0 +1,341 @@
+module AssTests
+  module InfoBases
+    require 'ass_tests/info_bases/info_base'
+    module DSL
+      module Describer
+        class AbstractDescriber
+          def ib(&block)
+            instance_eval(&block) if block_given?
+            InfoBase.new(ib_name, connection_string, external?, options)
+          end
+
+          def external?
+            instance_of? ExternalIb
+          end
+        end
+
+        module DescribeOptions
+          def options
+            @options ||= InfoBase.ALL_OPTIONS.clone
+          end
+
+          def method_missing(method, *args)
+            if options.key? method
+              options[method] = args[0]
+            else
+              fail NoMethodError, method.to_s
+            end
+          end
+        end
+
+        class ExternalIb < AbstractDescriber
+          include DescribeOptions
+
+          attr_reader :ib_name, :connection_string
+
+          def initialize(ib_name, connection_string)
+            @ib_name = ib_name
+            @connection_string = AssLauncher::Support::ConnectionString\
+              .new(connection_string.to_s)
+          end
+        end
+
+        module CommonDescriber
+          attr_reader :ib_name, :connection_string
+          alias_method :cs, :connection_string
+
+          private :connection_string, :cs
+          def initialize(ib_name)
+            @ib_name = ib_name
+            @connection_string = init_connection_string
+          end
+
+          def user(value)
+            cs.usr = value
+          end
+
+          def password(value)
+            cs.pwd = value
+          end
+
+          def locale(value)
+            cs.locale = value
+          end
+        end
+
+        class FileIb < AbstractDescriber
+          include CommonDescriber
+          include DescribeOptions
+
+          def directory(d)
+            cs.file = File.join(d, ib_name.to_s)
+          end
+
+          def init_connection_string
+            AssLauncher::Support::ConnectionString::File\
+              .new({file: default_path})
+          end
+          private :init_connection_string
+
+          def default_path
+            File.join(AssTests.config.test_infobase_directory, ib_name.to_s)
+          end
+          private :default_path
+        end
+
+        class ServerIb < AbstractDescriber
+          module Helpers
+            require 'shellwords'
+            require 'optparse'
+
+            module Parser
+              def options_help
+                options.to_a
+              end
+
+              def opts
+                @opts ||= OptionParser.new
+              end
+
+              def parse_str(str)
+                parse Shellwords.shellwords(str.to_s)
+              end
+
+              def presult
+                @presult ||= {}
+              end
+              private :presult
+            end
+
+            class ServerConnection
+              include AssMaintainer::InfoBase::ServerIb::EnterpriseServers::ServerConnection
+              extend Parser
+              def self.options
+                opts.on('-H', '--host HOST:PORT') do |v|
+                  presult[:host_port] = v
+                end
+                opts.on('-U', '--user [USER_NAME]') do |v|
+                  presult[:user] = v
+                end
+                opts.on('-P', '--password [PASSWORD]') do |v|
+                  presult[:password] = v
+                end
+                opts
+              end
+
+              def self.parse(argv)
+                options.parse! argv
+                new presult[:host_port], presult[:user], presult[:password]
+              end
+            end
+
+            class AgentConnection < ServerConnection
+              def self.parse(argv)
+                super(argv).to_server_agent
+              end
+
+              def to_server_agent
+                AssMaintainer::InfoBase::ServerIb::EnterpriseServers::ServerAgent.new(host_port,
+                                                                  user,
+                                                                  password)
+              end
+            end
+
+            class ClasterConnection < ServerConnection
+              def fill_cs(cs)
+                cs.srvr = host_port.to_s
+                cs.susr = user
+                cs.spwd = password
+              end
+
+              def to_connstr
+                r = ""
+                r << "Srvr=\"#{host_port}\";"
+                r << "SUsr=\"#{user}\";" if user
+                r << "SPwd=\"#{password}\";" if password
+                r
+              end
+            end
+
+            class DbConnection < ServerConnection
+              def fill_cs(cs)
+                cs.dbsrvr = host_port.to_s
+                cs.dbuid = user
+                cs.dbpwd = password
+              end
+
+              def to_connstr
+                r = ""
+                r << "DBSrvr=\"#{host_port}\";"
+                r << "DBUID=\"#{user}\";" if user
+                r << "DBPwd=\"#{password}\";" if password
+                r
+              end
+            end
+
+            class Db < DbConnection
+              extend Parser
+              def self.options
+                opts = super
+                opts.on("-D" ,"--dbms [#{AssLauncher::Support::ConnectionString::\
+                        Server::DBMS_VALUES.join(' | ')}]",
+                        'Type of DB for connection string') do |v|
+                  presult[:dbms] = v
+                end
+                opts.on('-N','--db-name [DBNAME]','Name of databse') do |v|
+                  presult[:name] = v
+                end
+                opts.on('-C','--create-db [Y|N]',
+                        'Crate databse if not exists. Default Y') do |v|
+                  presult[:create_db] = v
+                end
+                opts
+              end
+
+              def self.parse(argv)
+                options.parse! argv
+                srv_conn = DbConnection.new(
+                  presult[:host_port], presult[:user], presult[:password])
+                new presult[:name], srv_conn, presult[:dbms], presult[:create_db]
+              end
+
+              attr_reader :name, :srv_conn, :create_db, :dbms
+              def initialize(name, srv_conn, dbms, create_db)
+                fail ArgumentError, "DB name require" if name.to_s.empty?
+                fail ArgumentError unless srv_conn.instance_of? DbConnection
+                @name = name
+                @srv_conn = srv_conn
+                @dbms = dbms || fail(ArgumentError, "Require DBMS")
+                @create_db = create_db || 'Y'
+              end
+
+              def fill_cs(cs)
+                srv_conn.fill_cs(cs)
+                cs.db = name
+                cs.dbms = dbms
+                cs.crsqldb = create_db
+              end
+
+              def to_connstr
+                r = srv_conn.to_connstr
+                r << "DB=\"#{name}\";"
+                r << "DBMS=\"#{dbms}\";"
+                r << "CrSQLDB=\"#{create_db}\";" if create_db
+                r
+              end
+            end
+          end
+
+          include CommonDescriber
+          include DescribeOptions
+
+          def agent(str)
+            @agent = Helpers::AgentConnection.parse_str(str) unless str.to_s.empty?
+          end
+
+          def claster(str)
+            @claster = Helpers::ClasterConnection.parse_str(str)
+            @claster.fill_cs(cs)
+          end
+
+          def db(str)
+            @db = Helpers::Db.parse_str(str)
+            @db.fill_cs(cs)
+          end
+
+          def schjobdn
+            cs.schjobdn = 'Y'
+          end
+
+          def ib(&block)
+            ib = super
+            # FIXME: ib.server_agent = @agent || def_agent
+            ib
+          end
+
+          def init_connection_string
+            @connection_string = AssLauncher::Support::ConnectionString::Server\
+              .new({srvr: 'localhost:1540', ref: ib_name.to_s})
+            init_connections
+            @connection_string
+          end
+          private :init_connection_string
+
+          def def_db
+            @db ||= Helpers::Db\
+              .parse_str(AssTests.config.test_infobase_db\
+                         + " --db-name #{ib_name}")
+          end
+          private :def_db
+
+          def def_agent
+            @agent ||= Helpers::AgentConnection\
+              .parse_str(AssTests.config.test_infobase_server_agent)
+          end
+          private :def_agent
+
+          def def_claster
+            @claster ||= Helpers::ClasterConnection\
+              .parse_str(AssTests.config.test_infobase_claster)
+          end
+          private :def_claster
+
+          def init_connections
+            def_db.fill_cs(cs)
+            def_claster.fill_cs(cs)
+          end
+          private :init_connections
+        end
+      end
+
+      def self.file(ib_name, &block)
+        Describer::FileIb.new(ib_name).ib(&block)
+      end
+
+      def self.server(ib_name, &block)
+        Describer::ServerIb.new(ib_name).ib(&block)
+      end
+
+      def self.external(ib_name, connection_string, &block)
+        Describer::ExternalIb.new(ib_name, connection_string).ib(&block)
+      end
+    end
+
+    def pull
+      @pull ||= {}
+    end
+    private :pull
+
+    def [](name)
+      fail ArgumentError, "InfoBase `#{name}' not discribed" unless\
+        pull.key? name
+      ib = pull[name]
+      ib.make unless ib.read_only?
+      fail 'External infobse must be exists' if ib.read_only? && !ib.exists?
+      ib
+    end
+
+    def describe(&block)
+      fail ArgumentError, 'Require block' unless block_given?
+      instance_eval(&block)
+    end
+
+    def add(ib)
+      fail ArgumentError, "Ib #{ib.name} already described" if pull.key? ib.name
+      pull[ib.name] = ib
+    end
+
+    def file(ib_name, &block)
+      add(DSL.file(ib_name, &block))
+    end
+
+    def server(ib_name, &block)
+      add(DSL.server(ib_name, &block))
+    end
+
+    def external(ib_name, connection_string, &block)
+      add(DSL.external(ib_name, connection_string, &block))
+    end
+    extend self
+  end
+end

data/lib/ass_tests/info_bases/info_base.rb

@@ -0,0 +1,143 @@
+module AssTests
+  module InfoBases
+    require 'ass_maintainer/info_base'
+    class InfoBase < AssMaintainer::InfoBase
+      # see {#initialize}
+      OPTIONS = {
+        template: nil,
+        fixtures: nil,
+      }
+
+      OPTIONS.each_key do |key|
+        define_method key do
+          options[key]
+        end
+      end
+
+      def self.ALL_OPTIONS()
+        AssMaintainer::InfoBase::OPTIONS.merge OPTIONS
+      end
+
+      # @param name [String]
+      # @param connection_string [String AssLauncher::Support::ConnectionString]
+      # @param read_only [false true] flag for read_only infobase
+      # @option options [String #src_root] :template path to template like a
+      #  +.cf+, +.dt+ file or dir of XML files. If respond to +#src_root+ then
+      #  +#src_root+ must returns path to dir of XML files
+      # @option options [#call] :fixtures object for fill InfoBase data.
+      #  Must hase method #call accepts {InfoBase} argumet
+      # @note +options+ may includes other options defined for
+      #  +AssMaintainer::InfoBase+
+      def initialize(name, connection_string, read_only = true, **options)
+        super name, connection_string, read_only, **OPTIONS.merge(options)
+      end
+
+      attr_reader :template_loaded
+      alias_method :template_loaded?, :template_loaded
+
+      attr_reader :fixtures_loaded
+      alias_method :fixtures_loaded?, :fixtures_loaded
+
+      def built?
+        exists? && (template_loaded? || false) && (fixtures_loaded? || false)
+      end
+
+      def make_infobase!
+        super
+        load_template!
+        load_fixtures!
+        self
+      end
+      private :make_infobase!
+
+      def load_template!
+        fail AssMaintainer::InfoBase::MethodDenied, :load_template! if\
+          read_only?
+        load_template
+        @template_loaded = true
+      end
+
+      def load_fixtures!
+        fail AssMaintainer::InfoBase::MethodDenied, :load_fixtures! if\
+          read_only?
+        fixtures.call(self) if fixtures
+        @fixtures_loaded = true
+      end
+
+      def erase_data!
+        fail AssMaintainer::InfoBase::MethodDenied, :erase_data! if read_only?
+        designer do
+          eraseData
+        end.run.wait.result.verify!
+        true
+      end
+
+      def reload_fixtures!
+        erase_data!
+        load_fixtures!
+      end
+
+      # @api private
+      def template_type
+        return :cf if template_cf?
+        return :dt if template_dt?
+        return :src if template_src?
+        template.to_s
+      end
+
+      # @api private
+      def file_template?(ext)
+        template.to_s =~ %r{\.#{ext}\z} && File.file?(template.to_s)
+      end
+
+      # @api private
+      def template_cf?
+        file_template? 'cf'
+      end
+
+      # @api private
+      def template_dt?
+        file_template? 'dt'
+      end
+
+      # @api private
+      def template_src?
+        File.file?(File.join(src_root, 'Configuration.xml')) if src_root
+      end
+
+      def src_root
+        return template if template.is_a? String
+        return template.src_root if template.respond_to?(:src_root)
+      end
+      private :src_root
+
+      # @api private
+      def load_template
+        return unless template
+        case template_type
+        when :cf then load_cf
+        when :dt then load_dt
+        when :src then load_src
+        else
+          fail "Invalid template: #{template}"
+        end
+        template_type
+      end
+
+      # @api private
+      def load_src
+        cfg.load_xml(src_root) && db_cfg.update
+      end
+
+      # @api private
+      def load_dt
+        restore!(template)
+      end
+
+      # @api private
+      def load_cf
+        cfg.load(template) && db_cfg.update
+      end
+    end
+  end
+end