ass_launcher 0.1.1.alpha → 0.2.0

data/bin/lib/dev_helper/designer.rb

@@ -0,0 +1,172 @@
+module DevHelper
+  module Designer
+    module Cmd
+      require 'clamp'
+      require 'ass_launcher'
+      class Main < Clamp::Command
+        AssLauncher.config.search_path = ENV['ASSPATH'] if ENV['ASSPATH']
+        def self.banner
+          "1C designer wrapper.\n"\
+          "Current seaching paths of 1C:Enterprise installations:\n"\
+          "#{Paths.list}\n"\
+          "For add custom search path set env $ASSPATH"
+        end
+
+        class Designer < Clamp::Command
+          include AssLauncher::Api
+          option ['-v', '--version'], 'VERSION', 'specify of platform version',
+            required: true
+
+          def cl
+            @cl ||= cl_get
+          end
+
+          def cl_get
+            r = thicks(version).last
+            signal_usage_error "Platform version `#{version}' not found" if r.nil?
+            r
+          end
+        end
+
+        module ConnSring
+          def self.included(base)
+            base.option ['-b', '--info-base'], 'PATH',
+              baner(base),
+              required: _required(base) do |s|
+              @conn_str = cs_file(file: s)
+            end
+            base.send :attr_reader, :conn_str
+          end
+
+          def self._required(base)
+            base.respond_to? :conn_str_required?
+          end
+
+          def self.baner(base)
+            r = 'specify infobase path.'
+            r << ' If not specify it will make tmp infobase' unless\
+              _required(base)
+            r
+          end
+        end
+
+        class Run < Designer
+          include ConnSring
+          option ['-a', '--args'], '["ARG", "VAL" ...]',
+            'specify designer cmd arguments like Ruby Array' do |s|
+            @args = eval(s)
+            fail ArgumentError,
+              'specify designer cmd arguments like Ruby Array' unless\
+              @args.is_a? Array
+            @args
+          end
+
+          def execute
+            conn_str_ = conn_str || tmp_ib
+            args_ = args || []
+            cl.command(:designer, args_) do
+              connection_string conn_str_
+            end.run.wait.result.verify!
+          ensure
+            rm_tmp_ib
+          end
+
+          def rm_tmp_ib
+             FileUtils.rm_r tmp_ib_path if File.exists? tmp_ib_path
+          end
+
+          def tmp_ib
+            rm_tmp_ib
+            conn_str_ = cs_file(:file => tmp_ib_path)
+            process_holder = cl.command(:createinfobase) do
+              connection_string conn_str_
+            end.run.wait
+            process_holder.result.verify!
+            conn_str_
+          end
+
+          def tmp_ib_path
+            @tmp_ib_path ||= File.join(Dir.tmpdir, ib_dir_mame)
+          end
+
+          def ib_dir_mame
+            "#{self.class.name.gsub('::','-')}(#{version})"
+          end
+        end
+
+        class CreateInfobase < Designer
+
+          def self.conn_str_required?
+            true
+          end
+
+          include ConnSring
+
+          option ['-t', '--template'], 'PATH[.cf|.dt]',
+            'Create infobase from template' do |s|
+            @template = s
+          end
+
+          def execute
+            $stdout.puts "Success make ib: `#{make_infobase}'"
+          end
+
+          def make_infobase
+            conn_str_ = conn_str
+            template_ = template
+            cl.command(:createinfobase) do
+              connection_string conn_str_
+              useTemplate template_ if template_
+            end.run.wait.result.verify!
+            conn_str_
+          end
+
+        end
+
+        class Platforms < Clamp::Command
+          include AssLauncher::Api
+          def execute
+            $stdout.puts paths
+            $stdout.puts thicks_list
+            $stdout.puts thins_list
+          end
+
+          def paths
+            "Search paths:\n"\
+            "#{Paths.list}"
+          end
+
+          def thicks_list
+            "thik clients:\n"\
+            "#{list(thicks)}"
+          end
+
+          def thins_list
+            "thin clients:\n"\
+            "#{list(thins)}"
+          end
+
+          def list(clients)
+            " * #{clients.map {|c| c.version}.sort.join("\n * ")}"
+          end
+        end
+
+        class Paths < Clamp::Command
+          def self.list
+            " * #{AssLauncher::Enterprise.search_paths.join("\n * ")}"
+          end
+
+          def execute
+            $stdout.puts self.class.list
+          end
+        end
+
+        subcommand 'run', 'run of designer', Run
+        subcommand 'createinfobase', 'create file infrmation base', CreateInfobase
+        subcommand 'platforms', 'show list of instaled platforms', Platforms
+        subcommand 'search-paths', 'show search paths of 1C:Enterprise'\
+          ' installations', Paths
+      end
+    end
+  end
+end

data/bin/lib/dev_helper.rb

@@ -0,0 +1,59 @@
+module DevHelper
+  module CliDefValidator
+    require 'ass_launcher'
+    def valid_clients
+      AssLauncher::Enterprise::Cli::BinaryMatcher::ALL_CLIENTS
+    end
+
+    def valid_modes
+      AssLauncher::Enterprise::Cli::DEFINED_MODES
+    end
+
+    def validate_clients
+      fail ArgumentError,
+        "Invalid clients. Expected #{valid_clients.map(&:to_s)}" if\
+        (clients - valid_clients).size > 0
+    end
+
+    def validate_modes
+      fail ArgumentError,
+        "Invalid modes. Expected #{valid_modes.map(&:to_s)}" if\
+        (modes - valid_modes).size > 0
+    end
+
+    def valid_groups
+      AssLauncher::Enterprise::Cli::CliSpec.cli_def.parameters_groups.keys
+    end
+
+    def validate_group
+      fail ArgumentError,
+        "Invalid group `#{group_name}'."\
+        " Expected #{valid_groups.map(&:to_s)}" unless\
+          valid_groups.include?(group_name)
+    end
+  end
+
+  module Cmd
+    require_relative './dev_helper/cli_def_report'
+    require_relative './dev_helper/cli_def_snippets'
+    require_relative './dev_helper/designer'
+
+    class Main < Clamp::Command
+
+      subcommand 'show-version', 'show ass_launcher version' do
+        def execute
+          $stdout.puts AssLauncher::VERSION
+        end
+      end
+      subcommand 'cli-def-report',
+        'generate, csv formatted, report on defined CLI parameters'\
+        ' and puts it into STDOUT. (see DevHelper::CliDefReport)',
+        CliDefReport::Cmd::Report
+      subcommand 'cli-def-snippets',
+        CliDefSnippets::Cmd::Main._banner,
+        CliDefSnippets::Cmd::Main
+      subcommand 'designer', Designer::Cmd::Main.banner,
+        Designer::Cmd::Main
+    end
+  end
+end

data/examples/arguments_builder_example.rb

@@ -0,0 +1,150 @@
+require 'example_helper'
+
+module Examples
+  module ArgumentsBuilder
+
+    # 1C:Enterprise doesn't check CLI parameters and their arguments
+    # it may be cause of some problems when automation script writing
+    #
+    # AssLauncher provides feature for check CLI parameters.
+    # Feature consists of two parts:
+    # 1) CLI specifications which describe 1C:Enterprise CLI interface
+    # 2) Arguments builder which uses CLI specifications for checking CLI
+    #    parameters when we building command or location for running 1C clients
+
+    describe '1C:Enterprise CLI specifications' do
+      it 'AssLauncher defines specifications for 1C:Enterprise CLI interface' do
+        AssLauncher::Enterprise::Cli::CliSpec.cli_def.must_equal\
+          AssLauncher::Enterprise::CliDef
+      end
+
+      it 'Defined CLI specifications have CLI parameters collection' do
+        AssLauncher::Enterprise::Cli::CliSpec.cli_def.parameters\
+          .must_be_instance_of\
+           AssLauncher::Enterprise::Cli::Parameters::AllParameters
+      end
+
+      it 'CLI parameter defined for client type, version and run mode' do
+        parameter = AssLauncher::Enterprise::Cli::CliSpec.cli_def\
+          .parameters.find('/F', nil)[0]
+
+        # Parameter define for thick client in :enterprise mode
+        parameter.match?(CLIENTS::THICK, :enterprise).must_equal true
+
+        # Parameter doesn't defined for webclient
+        parameter.match?(CLIENTS::WEB, :webclient).must_equal false
+      end
+
+      it "All client's wrappers know self CLI specifications" do
+        CLIENTS::THICK.cli_spec.must_be_instance_of\
+          AssLauncher::Enterprise::Cli::CliSpec
+
+        CLIENTS::THIN.cli_spec.must_be_instance_of\
+          AssLauncher::Enterprise::Cli::CliSpec
+
+        CLIENTS::WEB.cli_spec.must_be_instance_of\
+          AssLauncher::Enterprise::Cli::CliSpec
+      end
+
+      it 'CliSpec have collection of CLI parameters which depended of run mode' do
+        CLIENTS::THICK.cli_spec.parameters(:designer).find('/CheckModules', nil)\
+          .must_be_instance_of\
+            AssLauncher::Enterprise::Cli::Parameters::Flag
+
+        CLIENTS::THICK.cli_spec.parameters(:enterprise).find('/CheckModules', nil)\
+          .must_be_nil
+      end
+    end
+
+    describe AssLauncher::Enterprise::Cli::ArgumentsBuilder do
+      # ArgumentsBuilder generate DSL for defined CLI cpecs
+      it 'When we build command or location we can use ArgumentsBuilder' do
+
+        command = CLIENTS::THICK.command(:designer) do
+          connection_string TMP::EMPTY_IB_CS
+          checkModules do
+            _Server
+            _ThinClient
+          end
+        end
+
+        command.args.join(', ').must_match\
+          %r{DESIGNER, /F, (.+), /CheckModules, , -Server, , -ThinClient}
+      end
+
+      # ArgumentsBuilder generates DSL which accepts case insensetive methods
+      # and methods with underscore prefix for separate uppercased method
+      # from the Ruby constant
+      it 'ArgumentsBuilder accepts DSL methods called as parameters name' do
+
+        proc {
+          CLIENTS::THIN.command do
+            DebuggerURL
+          end
+        }.must_raise NameError
+
+        args_1 = CLIENTS::THIN.command do
+          _DebuggerUrl 'http://example.org'
+        end.args.join(', ')
+
+        args_2 = CLIENTS::THIN.command do
+          debuggerUrl 'http://example.org'
+        end.args.join(', ')
+
+        # This example with () looks ugly
+        args_3 = CLIENTS::THIN.command do
+          DebuggerUrl('http://example.org')
+        end.args.join(', ')
+
+        # In all three cases arguments is equal
+        args_1.must_match %r{ENTERPRISE, /DebuggerURL, http://example\.org}
+        args_2.must_match %r{ENTERPRISE, /DebuggerURL, http://example\.org}
+        args_3.must_match %r{ENTERPRISE, /DebuggerURL, http://example\.org}
+      end
+
+      it 'ArgumentsBuilder have static DSL method #connection_string' do
+        args = CLIENTS::THIN.command do
+          connection_string TMP::EMPTY_IB_CS
+        end.args.join(', ')
+
+        args.must_match %r{ENTERPRISE, /F, (.+)}
+      end
+
+      it 'ArgumentsBuilder fail if parameter not defined' do
+        e = proc {
+          CLIENTS::WEB.location do
+            _BadParameter
+          end
+        }.must_raise AssLauncher::Enterprise::Cli::ArgumentsBuilder::BuildError
+
+        e.message.must_match %r{CLI parameter `/BadParameter' not definded .+}
+
+        e = proc {
+          CLIENTS::THICK.command(:designer) do
+            checkModules do
+              _BadSubParameter
+            end
+          end
+        }.must_raise AssLauncher::Enterprise::Cli::ArgumentsBuilder::BuildError
+
+        e.message.must_match %r{CLI parameter `-BadSubParameter' not definded .+}
+      end
+
+      it 'ArgumentsBuilder check CLI parameter arguments' do
+        e = proc {
+          CLIENTS::THIN.command do
+            _O 'Bad value'
+          end
+        }.must_raise ArgumentError
+
+        e.message.must_equal 'Wrong value `Bad value\' for /O parameter'
+
+        args = CLIENTS::THIN.command do
+          _O :Low
+        end.args.join(', ')
+
+        args.must_match %r{ENTERPRISE, /O, Low}
+      end
+    end
+  end
+end

data/examples/binary_wrappers_example.rb

@@ -0,0 +1,211 @@
+require 'example_helper'
+
+module Examples
+  module BinaryWrapper
+    require 'ass_launcher'
+
+    describe '1C:Enterprise binaries search paths' do
+
+      # AssLauncher searching 1C:Enterprise binaries
+      # in default installation paths which depends of
+      # operation system
+      it 'Array of default search paths' do
+        AssLauncher::Enterprise.search_paths.must_be_instance_of Array
+        AssLauncher::Enterprise.search_paths.wont_include __FILE__
+      end
+
+      # But we can add custom path into searching array
+      it 'Array of default search paths include custom path' do
+        # Add custom path
+        AssLauncher.config.search_path = __FILE__
+
+        AssLauncher::Enterprise.search_paths.must_include __FILE__
+
+        # Reset defauls
+        AssLauncher.config.search_path = nil
+      end
+
+    end
+
+    describe '1C:Enterprise binary types' do
+      extend AssLauncher::Api
+
+      # AssLauncher search two different 1C:Enterprise binary files aka
+      # 'thick' and 'thin' clients and returns array of suitable
+      # objects sach as BinaryWrapper::Thick and BinaryWrapper::Thin.
+
+      # Get thin clients array Api.thins method
+      thin_clients = thins
+      # Get thick clients array Api.thicks method
+      thick_clients = thicks
+
+      it 'Both method returned Array' do
+        thin_clients.must_be_instance_of Array
+        thick_clients.must_be_instance_of Array
+      end
+    end
+
+    describe '1C:Enterprise binary version' do
+      extend AssLauncher::Api
+
+      # AssLauncher provides posebility chose of 1C:Enterprise version.
+      # For define of required version uses Gem::Version::Requirement
+      # string.
+
+      # Get thick clients with version requiremet
+      thick_clients = thicks('~> 8.3.8.0')
+
+      it 'Fail if bad Gem::Version::Requirement' do
+        proc do
+          AssLauncher::Enterprise.thick_clients('bad version string')
+        end.must_raise ArgumentError
+      end
+    end
+
+    describe 'Binary wrappers run modes' do
+      # For BinaryWrapper::Thick objects
+      # defined run modes such as :enterprise, :designer and :createinfobase
+      it 'Run modes for thick client' do
+        AssLauncher::Enterprise::BinaryWrapper::ThickClient\
+          .run_modes.must_equal [:createinfobase, :enterprise, :designer]
+      end
+
+      # For BinaryWrapper::Thin objects
+      # defined :enterprise only run mode
+      it 'Run modes for thin client' do
+        AssLauncher::Enterprise::BinaryWrapper::ThinClient\
+          .run_modes.must_equal [:enterprise]
+      end
+    end
+
+    describe 'Execution thick client' do
+      extend AssLauncher::Api
+
+      # Get binary wrapper
+      client = thicks(Examples::PLATFORM_VER).last
+
+      # Fail if not 1C:Enterprise instalation found
+      fail "1C:Enterprise v.#{Examples::PLATFORM_VER} not found" if client.nil?
+
+      # Build command for necessary run mode 1C:Enterprise
+      # using arguments array
+      command = client.command(:designer,
+                               ['/F','bad infobase path',
+                                '/CheckModules','',
+                                '-Server','',
+                                '/L', 'en'])
+
+
+      # Run 1C:Enterprise in forked process
+      command.run
+
+      # Wait until 1C:Enterprise execution.
+      # But we can use 'command.ran.wait' for run and wait together
+      process_holder = command.process_holder.wait
+
+      it 'Verify execution result manually' do
+        process_holder.result.success?.must_equal false
+        process_holder.result.assout.must_match /Infobase not found!/i
+      end
+
+      it 'Verify execution result automatically' do
+        proc do
+          process_holder.result.verify!
+        end.must_raise AssLauncher::Support::Shell::RunAssResult::RunAssError
+      end
+    end
+
+    describe 'Execution thin client' do
+      extend AssLauncher::Api
+
+      # Get binary wrapper
+      client = thins(Examples::PLATFORM_VER).last
+
+      # Fail if not 1C:Enterprise instalation found
+      fail "1C:Enterprise v.#{Examples::PLATFORM_VER} not found" if client.nil?
+
+      # Build command for 1C:Enterprise using arguments array.
+      command = client.command( ['/F','bad infobase path',
+                                '/L', 'en'])
+
+
+      # Run 1C:Enterprise in forked process
+      process_holder = command.run
+
+      # Working process
+
+      # Kill 1C:Enterprise if no longer used
+      process_holder.kill
+    end
+
+    describe 'Building commands' do
+      extend AssLauncher::Api
+
+      # For building commands we can:
+      # 1) passing arguments array directly into command
+      # 2) using arguments builder DSL and passing block into command
+      # 3) using connection string passed into arguments builder
+      # 4) mix all this
+
+
+      # For more info about arguments builder see source code of
+      # class AssLauncher::Enterprise::Cli::ArgumentsBuilder
+
+      # Get binary wrapper
+      client = thicks(Examples::PLATFORM_VER).last
+
+      # Fail if not 1C:Enterprise instalation found
+      fail "1C:Enterprise v.#{Examples::PLATFORM_VER} not found" if client.nil?
+
+      # Build command for necessary run mode 1C:Enterprise
+      # using arguments array
+      command_first = client.command(:designer,
+                               ['/UC', 'uc value',
+                                '/S','example.org/infobase',
+                                '/CheckModules','',
+                                '-Server','',
+                                '/L', 'en'])
+
+      # Build command for necessary run mode 1C:Enterprise
+      # using arguments builder and arguments array
+      command_second = client.command(:designer, ['/UC', 'uc value']) do
+        _S 'example.org/infobase'
+        checkModules do
+          server
+        end
+        _L 'en'
+      end
+
+      # Build command for necessary run mode 1C:Enterprise
+      # using arguments builder and connection string and arguments array
+      conns = cs_srv srvr: 'example.org', ref: 'infobase'
+      command_third = client.command(:designer, ['/UC', 'uc value']) do
+        connection_string conns
+        checkModules do
+          server
+        end
+        _L 'en'
+      end
+
+      it 'All commands are equal exclude "/OUT" argument value' do
+        expected_args = ["DESIGNER",
+                         "/UC", "uc value",
+                         "/S", "example.org/infobase",
+                         "/CheckModules", "",
+                         "-Server", "",
+                         "/L", "en",
+                         "/DisableStartupDialogs", "",
+                         "/DisableStartupMessages", "",
+                         "/OUT"]
+        command_first.args.pop
+        command_first.args.must_equal expected_args
+
+        command_second.args.pop
+        command_second.args.must_equal expected_args
+
+        command_third.args.pop
+        command_third.args.must_equal expected_args
+      end
+    end
+  end
+end