skadategems-dev 0.0.9

data/lib/skadategems/dev/source_controller.rb

@@ -0,0 +1,101 @@
+require 'skadategems/dev/software_version'
+
+module SkadateGems
+  module Dev
+
+    # Skadate software source controller
+    class SourceController
+
+      # @return [String] source root directory
+      attr_reader :root
+
+      # @param root_dir [String] source root directory
+      def initialize(root_dir)
+        @root = root_dir
+      end
+
+      # Get full path to a file from the current source model.
+      # @param relative_path [String] relative path to a file
+      # @return [String] absolute path to a file
+      def filename(relative_path)
+        File.join(@root, relative_path)
+      end
+
+      # @return [String] full path to a `internals/Header.inc.php` file
+      def header_inc_php
+        filename 'internals/Header.inc.php'
+      end
+
+      # Silently tries to get software version object.
+      # @return [SoftwareVersion] or nil in case of file reading or parsing error
+      def version
+        return @version if @version
+
+        begin
+          string_def = parse_version_definition
+          if SoftwareVersion::MAP.key?(string_def)
+            @version = SoftwareVersion::MAP[string_def]
+          else
+            @version = SoftwareVersion.new(string_def)
+          end
+        rescue Errno::ENOENT, ParseError
+          nil
+        end
+      end
+
+      # @return [SoftwareVersion] software version object
+      # @raise [IOError] if `internals/Header.inc.php` can not be found
+      # @raise [SoftwareVersion::IncompatibilityError]
+      #   if detected version is not compatible with current version of `skadategems-dev`
+      def version!
+        if @version.nil?
+          string_def = parse_version_definition
+
+          if SoftwareVersion::MAP.key?(string_def)
+            @version = SoftwareVersion::MAP[string_def]
+          else
+            raise SoftwareVersion::CompatibilityError
+          end
+        end
+
+        @version
+      end
+
+      # Search and parse for a version definition within the `#header_inc_php` file.
+      # @raise [SourceController::ParseError] if the version definition can not be parsed
+      # @private use #version or #version! to gather a software version
+      def parse_version_definition
+        File.open(header_inc_php) do |file|
+          /define\(\s?(['"])PACKAGE_VERSION\1\s?,\s?(['"])(\d{1,2}.\d{1,2}.\d{4})\2\s?\)\s?;/.match(file.read)
+        end
+
+        $3 or raise ParseError
+      end
+
+      # @return [String] full path to a `internal_c/` directory
+      def internal_c
+        filename (version!.build < 2960 ? '$internal_c' : 'internal_c')
+      end
+
+      # @return [String] full path to a `external_c/` directory
+      def external_c
+        filename (version!.build < 2960 ? '$external_c' : 'external_c')
+      end
+
+      # @return [String] full path to a `userfiles/` directory
+      def userfiles
+        filename (version!.build < 2960 ? '$userfiles' : 'userfiles')
+      end
+
+      # @return [String] full path to a `internals/config.php` file
+      def config_php
+        filename ("internals/#{(version!.build < 2960 ? '$config.php' : 'config.php')}")
+      end
+
+      # Raised in case of source file parse error.
+      # @see SourceController#version!
+      class ParseError < StandardError; end
+    end
+
+  end
+end

data/lib/skadategems/dev/version.rb

@@ -0,0 +1,5 @@
+module SkadateGems
+  module Dev
+    VERSION = '0.0.9'
+  end
+end

data/skadategems-dev.gemspec

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'skadategems/dev/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'skadategems-dev'
+  spec.version       = SkadateGems::Dev::VERSION
+  spec.summary       = 'Skadate Development Toolkit'
+  spec.homepage      = 'https://github.com/skadategems/skadategems-dev'
+
+  spec.description   = <<-EOT
+Command line tool for Skadate Software developers
+EOT
+
+  spec.author        = 'Dan Kerimdzhanov'
+  spec.email         = 'kerimdzhanov@gmail.com'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^spec/})
+  spec.require_paths = %w[lib]
+
+  spec.platform      = Gem::Platform::RUBY
+  spec.required_ruby_version = '>= 2.0.0'
+
+  spec.add_dependency 'thor',    '~> 0.18.1'
+  spec.add_dependency 'execphp', '~> 0.1.0'
+  spec.add_dependency 'ruby-progressbar', '~> 1.4.2'
+
+  spec.add_development_dependency 'bundler', '~> 1.5.3'
+end

data/spec/skadategems/dev/bundle_spec.rb

@@ -0,0 +1,268 @@
+require 'spec_helper'
+require 'skadategems/dev/skadate'
+require 'skadategems/dev/bundle'
+
+module SkadateGems
+  module Dev
+
+    describe Bundle do
+      let(:root_dir) { '/path/to/skadate' }
+
+      let(:source) do
+        double(SourceController, root: root_dir,
+                                 internal_c: File.join(root_dir, 'internal_c'),
+                                 external_c: File.join(root_dir, 'external_c'),
+                                 userfiles:  File.join(root_dir, 'userfiles'),
+                                 filename:   File.join(root_dir, 'layout/themes/'))
+      end
+
+      let(:skadate) { double(Skadate, source: source) }
+
+      let(:bundle) { Bundle.new(skadate) }
+
+      describe '#should_include?' do
+
+        %w[ admin
+            cron/heavy.php
+            internals/API/Component.class.php
+            layout/themes/fb/img/logo.gif
+        ].each do |file|
+          it "allows `#{file}`" do
+            filename = File.join(root_dir, file)
+            expect(bundle.should_include?(filename)).to be_true
+          end
+        end
+
+        %w[ internal_c
+            internal_c/lang
+            external_c
+            external_c/%123D/%456%K.php
+            userfiles
+            userfiles/1234_5678/1234_5678.jpg
+            previous.tar.gz
+            archived.zip
+            vi-cache.swp
+            tmp-file.txt~
+            Thumbs.db
+            desktop.ini
+        ].each do |file|
+          it "denies `#{file}`" do
+            filename = File.join(root_dir, file)
+            expect(bundle.should_include?(filename)).to be_false
+          end
+        end
+
+        context 'when `bundle#layout_theme` is set to "dp"' do
+          before(:each) { bundle.layout_theme = 'dp' }
+
+          %w[ layout/themes
+              layout/themes/dp
+              layout/themes/dp/components
+              layout/themes/dp/img/logo.gif
+          ].each do |file|
+            it "allows `#{file}`" do
+              filename = File.join(root_dir, file)
+              expect(bundle.should_include?(filename)).to be_true
+            end
+          end
+
+          %w[ layout/themes/bn
+              layout/themes/ct/components
+              layout/themes/fb/img/logo.gif
+          ].each do |file|
+            it "denies `#{file}`" do
+              filename = File.join(root_dir, file)
+              expect(bundle.should_include?(filename)).to be_false
+            end
+          end
+        end
+
+      end
+
+      describe '#tar' do
+        let(:tar_io) do
+          tar_io = double(Gem::Package::TarWriter)
+          allow(tar_io).to receive(:mkdir)
+          tar_io
+        end
+
+        let(:tar_file) do
+          tar_file = double('tar_file')
+
+          tar_file
+        end
+
+        before(:each) do
+          allow(Gem::Package::TarWriter).to receive(:new) do |string_io, &block|
+            block.call(tar_io)
+          end
+
+          allow(Dir).to receive(:[]).and_return []
+
+          allow(File).to receive(:exists?).and_return false
+        end
+
+        it 'checks for root `.htaccess` existence' do
+          expect(File).to receive(:exists?)
+                      .with('/path/to/skadate/.htaccess')
+          bundle.tar
+        end
+
+        context 'when root `.htaccess` exists' do
+          before(:each) do
+            allow(File).to receive(:exists?)
+                       .with('/path/to/skadate/.htaccess')
+                       .and_return true
+
+            allow(tar_io).to receive(:add_file)
+                         .with('.htaccess', 0644) do |&block|
+              block.call(tar_file)
+            end
+          end
+
+          it 'adds it with attributes "-rw-r--r--"' do
+            expect(tar_io).to receive(:add_file)
+                          .with('.htaccess', 0644) {}
+            bundle.tar
+          end
+
+          it 'includes its contents' do
+            expect(File).to receive(:open)
+                        .with('/path/to/skadate/.htaccess', 'rb') do |&block|
+              block.call(double('IO', read: 'htaccess contents'))
+            end
+
+            expect(tar_file).to receive(:write)
+                            .with('htaccess contents')
+
+            bundle.tar
+          end
+        end
+
+        it 'globs :root_dir recursively' do
+          expect(Dir).to receive(:[])
+                     .with('/path/to/skadate/**/*')
+                     .and_return []
+
+          bundle.tar
+        end
+
+        context 'when meets a directory' do
+          before(:each) do
+            allow(Dir).to receive(:[])
+                      .and_return %w[/path/to/skadate/internals]
+
+            allow(File).to receive(:directory?).and_return true
+          end
+
+          it 'includes it with attributes "drwxr-xr-x"' do
+            expect(tar_io).to receive(:mkdir).with('internals', 0755)
+            bundle.tar
+          end
+
+          it 'checks whether the directory contains `.htaccess`' do
+            expect(File).to receive(:exists?)
+                        .with('/path/to/skadate/internals/.htaccess')
+
+            bundle.tar
+          end
+
+          context 'if directory contains `.htaccess`' do
+            before(:each) do
+              allow(File).to receive(:exists?)
+                         .with('/path/to/skadate/internals/.htaccess')
+                         .and_return true
+
+              allow(tar_io).to receive(:add_file)
+                           .with('internals/.htaccess', 0644) do |&block|
+                block.call(tar_file)
+              end
+            end
+
+            it 'adds it with attributes "-rw-r--r--"' do
+              expect(tar_io).to receive(:add_file)
+                            .with('internals/.htaccess', 0644) {}
+              bundle.tar
+            end
+
+            it 'includes its contents' do
+              expect(File).to receive(:open)
+                              .with('/path/to/skadate/internals/.htaccess', 'rb') do |&block|
+                block.call(double('IO', read: 'htaccess contents'))
+              end
+
+              expect(tar_file).to receive(:write)
+                              .with('htaccess contents')
+
+              bundle.tar
+            end
+          end
+        end
+
+        context 'when meets a file' do
+          before(:each) do
+            allow(Dir).to receive(:[])
+                      .and_return %w[/path/to/skadate/member/index.php]
+
+            allow(File).to receive(:directory?).and_return false
+
+            allow(tar_io).to receive(:add_file) do |&block|
+              block.call(tar_file)
+            end
+          end
+
+          it 'adds it with mode "-rw-r--r--"' do
+            expect(tar_io).to receive(:add_file)
+                          .with('member/index.php', 0644) {}
+            bundle.tar
+          end
+
+          it 'includes its contents' do
+            expect(File).to receive(:open)
+                        .with('/path/to/skadate/member/index.php', 'rb') do |&block|
+              block.call(double('IO', read: 'file contents'))
+            end
+
+            expect(tar_file).to receive(:write)
+                            .with('file contents')
+
+            bundle.tar
+          end
+        end
+
+        context "when meets a file that shouldn't be included" do
+          before(:each) do
+            expect(Dir).to receive(:[])
+                       .and_return ['/path/to/skadate/internal_c/forms']
+          end
+
+          it 'skips the file' do
+            expect(File).to_not receive(:directory?)
+            bundle.tar
+          end
+        end
+
+        %w[internal_c internal_c/components internal_c/lang external_c userfiles].each do |dir|
+          it "includes empty `#{dir}/` with mode 0777" do
+            expect(tar_io).to receive(:mkdir).with(dir, 0777)
+            bundle.tar
+          end
+        end
+
+        it 'returns a `StringIO`' do
+          expect(Dir).to receive(:[]).and_return []
+          expect(bundle.tar).to be_a StringIO
+        end
+
+        it 'caches the resulting object' do
+          expect(Dir).to receive(:[]).and_return []
+          expect(bundle.tar).to equal bundle.tar
+        end
+      end
+
+      describe '#gzip' do
+      end
+    end
+
+  end
+end

data/spec/skadategems/dev/cli/remote_spec.rb

@@ -0,0 +1,623 @@
+require 'spec_helper'
+require 'skadategems/dev/cli/skadate'
+
+module SkadateGems::Dev
+  module CLI
+
+    describe Remote do
+      def lib; SkadateGems::Dev end
+
+      let(:skadate) { lib::Skadate.new('/path/to/skadate') }
+
+      let(:accessor) do
+        double ExecPHP::RemoteServer,
+               execphp_uri: 'http://localhost/exec.php',
+               exec: nil
+      end
+
+      let(:remote) do
+        double lib::Remote,
+               accessor: accessor,
+               exec: nil
+      end
+
+      before(:each) do
+        allow(lib::Skadate)
+            .to receive(:new)
+            .and_return(skadate)
+
+        allow(skadate)
+            .to receive(:remote)
+            .and_return(remote)
+      end
+
+      describe '$> skadate remote ping' do
+        def ping!
+          @stdout = capture(:stdout) do
+            Skadate.start %w[remote ping]
+          end
+        end
+
+        it 'prints out a requesting url' do
+          ping!
+
+          expect(@stdout).to include "=> http://localhost/exec.php\n"
+        end
+
+        it 'sends the `echo` request to a remote server' do
+          expect(accessor).to receive(:exec) do |batch, &block|
+            expect(batch.to_s).to eq "echo \"pong!\";\n"
+          end
+
+          ping!
+        end
+
+        context 'when a response is received' do
+          let(:response) do
+            double 'http response', :code => 403,
+                                    :message => 'Found',
+                                    :body => ''
+          end
+
+          before(:each) do
+            allow(accessor).to receive(:exec) do |batch, &block|
+              block.call(response)
+            end
+          end
+
+          it 'prints out it‘s status code and message' do
+            ping!
+            expect(@stdout).to include "#> 403 [Found]\n"
+          end
+
+          context 'when a response body is empty' do
+            it 'prints out the "empty response body" error' do
+              ping!
+              expect(@stdout).to include "Error: empty response body\n"
+            end
+          end
+
+          context 'when a response body is unexpected' do
+            let(:response) do
+              double 'http response', :code => '200',
+                                      :message => 'OK',
+                                      :body => 'Oops...'
+            end
+
+            it 'prints out the "wrong response body" error including a response body' do
+              ping!
+
+              expect(@stdout).to include <<-STDOUT
+Error: wrong response body:
+"Oops..."
+              STDOUT
+            end
+
+            context 'if a response body is longer than 1000' do
+              let(:response) do
+                double 'http response', :code => '200',
+                                        :message => 'OK',
+                                        :body => 'a' * 1001
+              end
+
+              it 'truncates a response body length' do
+                ping!
+
+                expect(@stdout).to include <<-STDOUT
+Error: wrong response body:
+#{'a' * 985} ... (continued)
+                STDOUT
+              end
+            end
+          end
+
+          context 'when a server responds with "pong!"' do
+            let(:response) do
+              double 'http response', :code => '200',
+                                      :message => 'OK',
+                                      :body => 'pong!'
+            end
+
+            it 'prints out ">> pong!"' do
+              ping!
+              expect(@stdout).to include ">> pong!\n"
+            end
+          end
+        end
+
+      end
+
+      describe '$> skadate remote exec FILENAME' do
+        def exec!
+          @stdout = capture(:stdout) do
+            Skadate.start %w[remote exec remote-script.php]
+          end
+        end
+
+        let(:response) do
+          double 'http response', :code => '200',
+                                  :message => 'OK',
+                                  :body => 'Yay!'
+        end
+
+        it 'puts a given php file to remote#exec as a batch script' do
+          batch = double(ExecPHP::ScriptBatch)
+
+          expect(remote).to receive(:exec)
+              .and_yield(batch)
+              .and_return(response)
+
+          expect(batch).to receive(:include_file)
+              .with('remote-script.php')
+
+          exec!
+        end
+
+        it 'prints out a response#body' do
+          expect(remote).to receive(:exec)
+              .and_return(response)
+
+          exec!
+
+          expect(@stdout).to eq "Yay!\n"
+        end
+      end
+
+      describe '$> skadate remote clone' do
+        def clone!(options)
+          @stdout = capture(:stdout) do
+            Skadate.start %w[remote clone].concat(options)
+          end
+        end
+
+        def directory(options = {})
+          double "remote dir `#{options[:path]}`", {
+            directory?: true,
+            list: []
+          }.merge(options)
+        end
+
+        def file(options = {})
+          size = options[:size] || 0
+
+          file = double "remote file `#{options[:path]}`", {
+            directory?: false,
+            path: options[:path],
+            size: size,
+            friendly_size: "#{size} bytes",
+            save_as: nil
+          }
+
+          allow(file).to receive(:basename) do
+            File.basename(options[:path])
+          end
+
+          allow(file).to receive(:extname) do
+            File.extname(options[:path])
+          end
+
+          file
+        end
+
+        let(:logger_mock) { double lib::Remote::CloneLogger }
+
+        before(:each) do
+          allow(::File)
+              .to receive(:exists?)
+              .with('/path/to/skadate/.dev/log')
+              .and_return(true)
+
+          allow(lib::Remote::CloneLogger)
+              .to receive(:start)
+              .and_yield(logger_mock)
+
+          allow(logger_mock)
+              .to receive(:puts)
+
+          allow(logger_mock)
+              .to receive(:entry)
+              .and_yield
+
+          @logger_padding = 0
+          allow(logger_mock).to receive(:padding) { @logger_padding }
+          allow(logger_mock).to receive(:padding=) { |val| @logger_padding = val }
+
+          allow(logger_mock).to receive(:mute?).and_return(false)
+        end
+
+        describe 'without arguments' do
+          it 'prints out the error message' do
+            clone! []
+            expect(@stdout).to include "Error: `remote clone` options are required\n"
+          end
+
+          it 'prints out the usage help' do
+            clone! []
+            expect(@stdout).to include "Usage:\n"
+            expect(@stdout).to include "Options:\n"
+          end
+        end
+
+        context '#logger.start' do
+          it 'mkdir -p `.dev/log` if not exists' do
+            expect(::File)
+                .to receive(:exists?)
+                .with('/path/to/skadate/.dev/log')
+                .and_return(false)
+
+            expect(FileUtils)
+                .to receive(:mkdir_p)
+                .with('/path/to/skadate/.dev/log')
+
+            allow(lib::Remote::CloneLogger)
+                .to receive(:start) # skip block
+
+            clone! %w[--database]
+          end
+
+          it 'calls logger.start("/path/to/skadate/.dev/log/remote-clone[$timestamp].log")' do
+            expect(lib::Remote::CloneLogger).to receive(:start) do |log_filename, &_|
+              expect(log_filename).to match %r[/path/to/skadate/\.dev/log/remote-clone\[\d+\]\.log]
+            end
+
+            clone! %w[--database]
+          end
+        end
+
+        describe '--sources' do
+          def clone_sources!
+            clone! %w[--sources]
+          end
+
+          let(:root_dir) { directory path: '/' }
+          let(:admin_dir) { directory path: '/admin' }
+          let(:templates_dir) { directory path: '/admin/templates' }
+
+          let(:htaccess) { file path: '/.htaccess', size: 88 }
+          let(:favicon) { file path: '/favicon.ico', size: 1406 }
+          let(:index_php) { file path: '/index.php', size: 204 }
+
+          let(:remote_configs) { double lib::Remote::Configs }
+
+          let(:layout_theme_dir) { directory path: '/layout/themes/fb' }
+
+          before(:each) do
+            allow(remote)
+                .to receive(:root)
+                .and_return(root_dir)
+
+            allow(root_dir)
+                .to receive(:list)
+                .and_return []
+
+            allow(remote)
+                .to receive(:configs)
+                .and_return(remote_configs)
+
+            allow(remote_configs)
+                .to receive(:[])
+                .and_return(double 'remote-config', { name: 'theme', value: 'fb' })
+
+            allow(remote)
+                .to receive(:directory)
+                .with('/layout/themes/fb')
+                .and_return(layout_theme_dir)
+          end
+
+          it 'informs #logger about the starting task' do
+            expect(logger_mock)
+                .to receive(:puts)
+                .with('>> Downloading application sources...', :yellow)
+
+            clone_sources!
+          end
+
+          it 'goes through a remote directories recursively' do
+            expect(root_dir).to receive(:list).and_return [admin_dir]
+            expect(admin_dir).to receive(:list).and_return [templates_dir]
+            expect(templates_dir).to receive(:list).and_return []
+
+            clone_sources!
+          end
+
+          it 'informs #logger about each processing directory' do
+            allow(root_dir).to receive(:list).and_return [admin_dir]
+            allow(admin_dir).to receive(:list).and_return [templates_dir]
+
+            expect(logger_mock).to receive(:entry).with(admin_dir)
+            expect(logger_mock).to receive(:entry).with(templates_dir)
+
+            clone_sources!
+          end
+
+          %w[ $external_c
+              $internal_c
+              $userfiles
+              $userfiles/tmp
+              cgi-bin
+              external_c
+              internal_c
+              layout/themes
+              m/application/cache/smarty_compile
+              userfiles
+              userfiles/tmp
+          ].each do |entry|
+            it "skips `/#{entry}`" do
+              entry_dir = directory(:path => "/#{entry}")
+              expect(root_dir).to receive(:list).and_return [ entry_dir ]
+              expect(entry_dir).to_not receive(:list)
+
+              expect(logger_mock)
+                  .to receive(:entry)
+                  .with(entry_dir, :skipped, 'skipped by pathname')
+
+              clone_sources!
+            end
+          end
+
+          it 'downloads files listed in remote directories' do
+            root_dir_files = [ htaccess, favicon, index_php ]
+
+            expect(root_dir).to receive(:list)
+                .and_return(root_dir_files)
+
+            root_dir_files.each do |file|
+              expect(file).to receive(:save_as)
+                  .with("/path/to/skadate#{file.path}")
+            end
+
+            clone_sources!
+          end
+
+          it 'informs #logger about each downloading file and status' do
+            allow(root_dir)
+                .to receive(:list)
+                .and_return [ htaccess, favicon, index_php ]
+
+            allow(htaccess)
+                .to receive(:save_as)
+                .with('/path/to/skadate/.htaccess')
+                .and_return(true)
+
+            expect(logger_mock)
+                .to receive(:entry)
+                .with(htaccess) do |&block|
+              expect(block.call).to eq :downloaded
+            end
+
+            allow(favicon)
+                .to receive(:save_as)
+                .with('/path/to/skadate/favicon.ico')
+                .and_return(false)
+
+            expect(logger_mock)
+                .to receive(:entry)
+                .with(favicon) do |&block|
+              expect(block.call).to eq :unchanged
+            end
+
+            clone_sources!
+          end
+
+          %w[ /archive1.tar.bz2
+              /archive2.tar.gz
+              /path/to/dir/archive3.zip
+              /folder/archive4.rar
+          ].each do |file_path|
+            it "skips `#{file_path}` by '*#{File.extname(file_path)}'" do
+              entry_file = file(path: file_path)
+
+              allow(root_dir)
+                  .to receive(:list)
+                  .and_return [ entry_file ]
+
+              expect(logger_mock)
+                  .to receive(:entry)
+                  .with(entry_file, :skipped, "skipped by (*#{File.extname(file_path)})")
+                  .and_yield
+
+              expect(entry_file).to_not receive(:save_as)
+
+              clone_sources!
+            end
+          end
+
+          it 'skips files which size > `MAX_SOURCE_FILE_SIZE`' do
+            big_file = file path: 'install/skadate9.sql',
+                            size: Remote::MAX_SOURCE_FILE_SIZE + 1
+
+            allow(root_dir)
+                .to receive(:list)
+                .and_return [ big_file ]
+
+            expect(logger_mock)
+                .to receive(:entry)
+                .with(big_file, :skipped, 'skipped by filesize')
+                .and_yield
+
+            expect(big_file).to_not receive(:save_as)
+
+            clone_sources!
+          end
+
+          context 'for a file which size exceeds `SHOW_PROGRESS_FILE_SIZE`' do
+            it 'creates and handles the `ruby-progressbar`' do
+              remote_file = file path: '/games/1234_5678_90.swf',
+                                 size: Remote::SHOW_PROGRESS_FILE_SIZE + 1
+
+              allow(root_dir)
+                  .to receive(:list)
+                  .and_return [ remote_file ]
+
+              expect(remote_file)
+                  .to receive(:save_as)
+                  .with('/path/to/skadate/games/1234_5678_90.swf') do |&block|
+                if block
+                  block.call(1234)
+                  block.call(5678)
+                end
+              end
+
+              pb_mock = double
+
+              expect(ProgressBar)
+                  .to receive(:create) do |options|
+                expect(options[:title]).to eq '1234_5678_90.swf'
+                expect(options[:starting_at]).to eq 1234
+                pb_mock
+              end
+
+              expect(pb_mock)
+                  .to receive(:progress)
+                  .and_return(1234)
+
+              expect(pb_mock)
+                  .to receive(:progress=)
+                  .with(6912)
+
+              clone_sources!
+            end
+          end
+        end
+
+        describe '--database' do
+          def clone_database!
+            clone! %w[--database]
+          end
+
+          let(:remote_sql_dump) do
+            file path: 'external_c/1234567890.sql',
+                 size: 1024 * 1024 * 30
+          end
+
+          before(:each) do
+            allow(remote).to receive(:create_mysql_dump)
+                .and_yield(remote_sql_dump)
+          end
+
+          it 'informs #logger about the starting task' do
+            expect(logger_mock)
+                .to receive(:puts)
+                .with('>> Creating remote database dump...', :yellow)
+
+            clone_database!
+          end
+
+          it 'requests remote database dump creation' do
+            expect(remote).to receive(:create_mysql_dump)
+            clone! %w[--database]
+          end
+
+          it 'downloads and saves a created dump as `remote-db-clone.sql`' do
+            expect(remote_sql_dump)
+                .to receive(:save_as)
+                .with('/path/to/skadate/remote-db-clone.sql') do |&block|
+              block.call(1234)
+              block.call(5678)
+            end
+
+            progressbar = double
+
+            expect(ProgressBar)
+                .to receive(:create)
+                .and_return(progressbar)
+
+            expect(progressbar)
+                .to receive(:progress)
+                .and_return(1234)
+
+            expect(progressbar)
+                .to receive(:progress=)
+                .with(6912)
+
+            clone_database!
+          end
+
+          context 'when dump file is compressed (tar.gz)' do
+            let(:remote_sql_dump) do
+              file path: 'external_c/12345.tar.gz',
+                   size: 1024 * 1024 * 15
+            end
+
+            it 'downloads and saves file as `remote-db-clone.tar.gz`' do
+              expect(remote_sql_dump).to receive(:save_as)
+                  .with('/path/to/skadate/remote-db-clone.tar.gz')
+
+              clone_database!
+            end
+          end
+        end
+
+        describe '--userfiles' do
+          def clone_userfiles!
+            clone! %w[--userfiles]
+          end
+
+          let(:list) {[
+            file(path: '/userfiles/full_size_2047_5625_42.jpg'),
+            file(path: '/userfiles/gift_25_1262767083.jpg'),
+            file(path: '/userfiles/sp.gif')
+          ]}
+
+          let(:userfiles) { directory path: '/userfiles' }
+
+          before(:each) do
+            allow(remote)
+                .to receive(:userfiles)
+                .and_return(userfiles)
+
+            allow(userfiles)
+                .to receive(:list)
+                .and_return(list)
+          end
+
+          it 'informs #logger about the starting task' do
+            expect(logger_mock)
+                .to receive(:puts)
+                .with('>> Detecting `$userfiles` directory...', :yellow)
+
+            clone_userfiles!
+          end
+
+          it 'uses Remote#userfiles to detect `$userfiles` directory' do
+            expect(remote)
+                .to receive(:userfiles)
+                .and_return(userfiles)
+
+            clone_userfiles!
+          end
+
+          it 'downloads `$userfiles` directory contents' do
+            list.each do |file|
+              expect(file).to receive(:save_as)
+                  .with("/path/to/skadate#{file.path}") do |&block|
+                if block
+                  block.call(123)
+                  block.call(456)
+                end
+              end
+            end
+
+            clone_userfiles!
+          end
+
+          it 'skips `$userfiles/tmp` directory entry' do
+            tmpdir = directory(path: '/userfiles/tmp')
+            list << tmpdir
+
+            expect(logger_mock)
+                .to receive(:entry)
+                .with(tmpdir, :skipped, 'skipped by pathname')
+                .and_yield
+
+            expect(tmpdir).to_not receive(:list)
+
+            clone_userfiles!
+          end
+        end
+
+      end
+    end
+
+  end
+end