skadategems-dev 0.0.9

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

@@ -0,0 +1,182 @@
+require 'spec_helper'
+require 'skadategems/dev/cli/skadate'
+
+module SkadateGems::Dev
+  module CLI
+
+    describe Skadate do
+      let(:skadate) { SkadateGems::Dev::Skadate.new('/path/to/skadate') }
+      let(:version) { '9.2.2960' }
+
+      before(:each) do
+        allow(SkadateGems::Dev::Skadate)
+            .to receive(:new)
+            .and_return(skadate)
+
+        allow(skadate.source)
+            .to receive(:parse_version_definition)
+            .and_return(version)
+      end
+
+      describe '$> skadate version' do
+        def invoke!(section)
+          @stdout = capture(:stdout) do
+            Skadate.start ['version', section]
+          end
+        end
+
+        describe 'list #' do
+          it 'prints out SoftwareVersion::LIST' do
+            invoke! 'list'
+
+            lines = @stdout.lines.map { |l| l[2..-2] }
+
+            SoftwareVersion::LIST.each do |version|
+              expect(lines).to include "skadate-#{version.to_s} [#{version.release_date}]"
+            end
+          end
+
+          context 'when current working directory is a Skadate source root' do
+            it 'marks current version with asterisk (*)' do
+              invoke! 'list'
+
+              expect(@stdout.lines).to include "* skadate-9.2.2960 [2013-04-16]\n"
+            end
+          end
+        end
+
+        describe 'about #' do
+          it 'prints out all about' do
+            invoke! 'about'
+
+            expect(@stdout.lines).to eq([
+              "Skadate Software 9.2.2960 (Master) [previous]\n",
+              "Release date: April 16, 2013\n",
+              "Copyright (c) 2004-#{Date.today.year} Skalfa LLC\n"
+            ])
+          end
+        end
+
+        describe 'number #' do
+          it 'prints out the version number' do
+            invoke! 'number'
+            expect(@stdout).to eq "9.2.2960\n"
+          end
+        end
+
+        describe 'build #' do
+          it 'prints out the build number' do
+            invoke! 'build'
+            expect(@stdout).to eq "2960\n"
+          end
+        end
+
+        context 'when the `source#header_inc_php` file can not be found' do
+          before(:each) do
+            allow(skadate.source)
+                .to receive(:parse_version_definition)
+                .and_raise(Errno::ENOENT)
+          end
+
+          it 'failures with an error' do
+            expect { invoke! 'about' }.to raise_error Errno::ENOENT
+          end
+        end
+      end
+
+      describe '$> skadate init' do
+        def skadate_init!(arguments)
+          @stdout = capture(:stdout) do
+            Skadate.start( %w[init].concat(arguments) )
+          end
+        end
+
+        before(:each) do
+          allow(File)
+              .to receive(:exists?)
+              .with('/path/to/skadate/.dev')
+              .and_return(true)
+
+          allow(File)
+              .to receive(:exists?)
+              .with('/path/to/skadate/.dev/.htaccess')
+              .and_return(true)
+        end
+
+        it 'creates a `.dev/` directory if not exists' do
+          expect(File)
+              .to receive(:exists?)
+              .with('/path/to/skadate/.dev')
+              .and_return(false)
+
+          expect(FileUtils)
+              .to receive(:mkdir)
+              .with('/path/to/skadate/.dev')
+
+          skadate_init! []
+        end
+
+        it 'generates a `.dev/.htaccess` file with the "Deny from all" instruction' do
+          expect(File)
+              .to receive(:exists?)
+              .with('/path/to/skadate/.dev/.htaccess')
+              .and_return(false)
+
+          expect(File)
+              .to receive(:write)
+              .with('/path/to/skadate/.dev/.htaccess', <<-HTACCESS)
+Order Deny,Allow
+Deny from all
+          HTACCESS
+
+          skadate_init! []
+        end
+
+        context 'when the `--remote-url` option is given' do
+          let(:execphp_ssa) do
+            double ExecPHP::ServerSideAccessor,
+                   :access_token => 'super-secret',
+                   :generate => nil
+          end
+
+          let(:execphp_config) do
+            double ExecPHP::RemoteServer,
+                   :save_as => nil
+          end
+
+          before(:each) do
+            allow(ExecPHP::ServerSideAccessor)
+                .to receive(:new)
+                .and_return(execphp_ssa)
+
+            allow(ExecPHP::RemoteServer)
+                .to receive(:new)
+                .and_return(execphp_config)
+          end
+
+          it 'generates a `.dev/remote-server.json` configuration file' do
+            expect(ExecPHP::RemoteServer)
+                .to receive(:new)
+                .with('http://skadate-driven-site.com/exec.php', 'super-secret')
+                .and_return(execphp_config)
+
+            expect(execphp_config)
+                .to receive(:save_as)
+                .with('/path/to/skadate/.dev/remote-server.json')
+
+            skadate_init! %w[--remote-url http://skadate-driven-site.com/]
+          end
+
+          it 'generates an `exec.php` (server-side script runner) file' do
+            expect(execphp_ssa)
+                .to receive(:generate)
+                .with('/path/to/skadate/exec.php')
+
+            skadate_init! %w[--remote-url http://skadate-driven-site.com/]
+          end
+        end
+      end
+    end
+
+  end
+end

data/spec/skadategems/dev/remote/clone_logger_spec.rb

@@ -0,0 +1,324 @@
+require 'spec_helper'
+require 'skadategems/dev/remote/clone_logger'
+require 'stringio'
+
+module SkadateGems::Dev
+  class Remote
+
+    describe CloneLogger do
+      let(:io_probe) { StringIO.new }
+      let(:logger) { CloneLogger.new(io_probe) }
+
+      describe '.start' do
+
+        it 'opens a new log file for writing' do
+          expect(::File)
+            .to receive(:open)
+            .with('/path/to/file.log', 'w')
+
+          CloneLogger.start('/path/to/file.log') { }
+        end
+
+        it 'instantiates a new logger giving a `log_file_io` reference' do
+          allow(::File).to receive(:open).and_yield(io_probe)
+
+          expect(CloneLogger).to receive(:new)
+              .with(io_probe).and_return(logger)
+
+          CloneLogger.start('...') { }
+        end
+
+        it 'yields a logger instance' do
+          allow(::File).to receive(:open).and_yield(io_probe)
+
+          allow(CloneLogger).to receive(:new)
+              .with(io_probe).and_return(logger)
+
+          expect { |b| CloneLogger.start('...', &b) }.to yield_with_args(logger)
+        end
+
+=begin
+        it 'ensures that the logger is flushed' do
+          allow(::File).to receive(:open).and_yield(io_probe)
+
+          allow(CloneLogger).to receive(:new)
+              .with(io_probe).and_return(logger)
+
+          expect(logger).to receive(:flush).twice
+
+          CloneLogger.start { } # 1
+
+          expect do
+            CloneLogger.start { raise StandardError } # 2
+          end.to raise_error(StandardError)
+        end
+=end
+
+      end
+
+      describe '#initialize' do
+        it 'assigns @file_io' do
+          expect(logger.instance_variable_get(:@file_io)).to eq io_probe
+        end
+
+        it 'assigns @mute = false' do
+          expect(logger.instance_variable_get(:@mute)).to eq false
+        end
+
+        it 'assigns @padding = 0' do
+          expect(logger.instance_variable_get(:@padding)).to be_zero
+        end
+      end
+
+      describe '#puts' do
+        def puts!(message, color = nil)
+          @stdout = capture(:stdout) do
+            logger.puts(message, color)
+          end
+        end
+
+        it 'prints out a given string' do
+          puts! '>> Yay!'
+          expect(@stdout).to eq ">> Yay!\n"
+        end
+
+        it 'writes a given string to a log file' do
+          puts! '>> Yay!'
+          expect(io_probe.string).to eq ">> Yay!\n"
+        end
+
+        context 'when a color is given' do
+          before(:each) do
+            expect(logger).to receive(:set_color)
+                .with('>> Yay!', :yellow)
+                .and_return('[>> Yay!]')
+          end
+
+          it 'uses #set_color to colorize a string' do
+            puts! '>> Yay!', :yellow
+            expect(@stdout).to eq "[>> Yay!]\n"
+          end
+
+          it "doesn't affect to a written log" do
+            puts! '>> Yay!', :yellow
+            expect(io_probe.string).to eq ">> Yay!\n"
+          end
+        end
+      end
+
+      describe '#entry' do
+        let(:padding) { nil }
+
+        def remote_dir(path)
+          Directory.new(double, path)
+        end
+
+        def remote_file(path, size)
+          File.new(double, path, size)
+        end
+
+        def push!(entry, status = nil, label = nil, &block)
+          @stdout = capture(:stdout) do
+            logger.padding = padding if padding
+            logger.entry(entry, status, label, &block)
+          end
+        end
+
+        context 'for directory `/` (app root)' do
+          before(:each) do
+            push!(remote_dir '/') { }
+          end
+
+          it 'prints "=> / ...\n"' do
+            expect(@stdout).to eq "=> / ...\n"
+          end
+
+          it 'writes "=> /\n"' do
+            expect(io_probe.string).to eq "=> /\n"
+          end
+
+          context 'with @padding = 1' do
+            let(:padding) { 1 }
+
+            it 'prints "  => / ...\n"' do
+              expect(@stdout).to eq "  => / ...\n"
+            end
+
+            it 'writes "  => /\n"' do
+              expect(io_probe.string).to eq "  => /\n"
+            end
+          end
+
+          context 'with @padding = 2' do
+            let(:padding) { 2 }
+
+            it 'prints "    => / ...\n"' do
+              expect(@stdout).to eq "    => / ...\n"
+            end
+
+            it 'writes "    => /\n"' do
+              expect(io_probe.string).to eq "    => /\n"
+            end
+          end
+        end
+
+        context 'for directory `/internals/API`' do
+          before(:each) do
+            push!(remote_dir '/internals/API') { }
+          end
+
+          it 'prints "=> /internals/API ...\n"' do
+            expect(@stdout).to eq "=> /internals/API ...\n"
+          end
+
+          it 'writes "=> /internals/API\n"' do
+            expect(io_probe.string).to eq "=> /internals/API\n"
+          end
+
+          context 'with @padding = 1' do
+            let(:padding) { 1 }
+
+            it 'prints "  => /internals/API ...\n"' do
+              expect(@stdout).to eq "  => /internals/API ...\n"
+            end
+
+            it 'writes "  => /internals/API\n"' do
+              expect(io_probe.string).to eq "  => /internals/API\n"
+            end
+          end
+
+          context 'with @padding = 2' do
+            let(:padding) { 2 }
+
+            it 'prints "    => /internals/API ...\n"' do
+              expect(@stdout).to eq "    => /internals/API ...\n"
+            end
+
+            it 'writes "    => /internals/API\n"' do
+              io_probe.seek(0)
+              expect(io_probe.read).to eq "    => /internals/API\n"
+            end
+          end
+        end
+
+        context 'for directory `/internal_c` (skipped by pathname)' do
+          before(:each) do
+            push! remote_dir('/internal_c'), :skipped, 'skipped by pathname'
+          end
+
+          it 'prints "*> /internal_c [skipped by pathname]\n"' do
+            expect(@stdout).to eq "*> /internal_c [skipped by pathname]\n"
+          end
+
+          it 'writes "*> /internal_c [skipped by pathname]\n"' do
+            expect(io_probe.string).to eq "*> /internal_c [skipped by pathname]\n"
+          end
+
+          context 'with @padding = 1' do
+            let(:padding) { 1 }
+
+            it 'prints "  *> /internal_c [skipped by pathname]\n"' do
+              expect(@stdout).to eq "  *> /internal_c [skipped by pathname]\n"
+            end
+
+            it 'writes "  *> /internal_c [skipped by pathname]\n"' do
+              expect(io_probe.string).to eq "  *> /internal_c [skipped by pathname]\n"
+            end
+          end
+
+          context 'with @padding = 2' do
+            let(:padding) { 2 }
+
+            it 'prints "    *> /internal_c [skipped by pathname]\n"' do
+              expect(@stdout).to eq "    *> /internal_c [skipped by pathname]\n"
+            end
+
+            it 'writes "    *> /internal_c [skipped by pathname]\n"' do
+              expect(io_probe.string).to eq "    *> /internal_c [skipped by pathname]\n"
+            end
+          end
+        end
+
+        context 'for file `/index.php` (95 B) [loading...]' do
+          before(:each) do
+            push!(remote_file('/index.php', 95)) { }
+          end
+
+          it 'prints "~> index.php ...\n"' do
+            expect(@stdout).to eq "~> index.php (95 B) ...\n"
+          end
+
+          it 'writes "~> index.php\n"' do
+            expect(io_probe.string).to eq "~> index.php (95 B)\n"
+          end
+        end
+
+        context 'for file `/cron/heavy.php` (1,225) [downloaded]' do
+          before(:each) do
+            push!(remote_file('/cron/heavy.php', 1_225)) { :downloaded }
+          end
+
+          it 'prints "~> heavy.php (1.2 KiB) ... [downloaded]\n"' do
+            expect(@stdout).to eq "~> heavy.php (1.2 KiB) ... [downloaded]\n"
+          end
+
+          it 'writes "~> heavy.php (1.2 KiB) [downloaded]\n"' do
+            expect(io_probe.string).to eq "~> heavy.php (1.2 KiB) [downloaded]\n"
+          end
+        end
+
+        context 'for file `/install/skadate9.sql` (9,491,203) [unchanged]' do
+          before(:each) do
+            push!(remote_file('/install/skadate9.sql', 9_491_203)) { :unchanged }
+          end
+
+          it 'prints "~> skadate9.sql (9 MiB) ... [unchanged]\n"' do
+            expect(@stdout).to eq "~> skadate9.sql (9 MiB) ... [unchanged]\n"
+          end
+
+          it 'writes "~> skadate9.sql (9 MiB) [unchanged]\n"' do
+            expect(io_probe.string).to eq "~> skadate9.sql (9 MiB) [unchanged]\n"
+          end
+        end
+
+        context 'for the `/path/to/nonexistent.php` (0) [error]' do
+
+          class TestError < StandardError; end
+
+          it 'prints "~> nonexistent.php (0 B) [error]\n"' do
+            @stdout = $stdout
+            $stdout = StringIO.new
+
+            begin
+              file = remote_file('/path/to/nonexistent.php', 0)
+              logger.entry(file) { raise TestError }
+            rescue TestError
+              # just be quiet...
+            ensure
+              expect($stdout.string).to eq "~> nonexistent.php (0 B) ... [error]\n"
+              $stdout = @stdout
+            end
+          end
+
+          it 'writes "~> nonexistent.php (0 B) [error]\n"' do
+            begin
+              file = remote_file('/path/to/nonexistent.php', 0)
+              push!(file) { raise TestError, 'Uh! Ogh!' }
+            rescue TestError
+              # ...
+            ensure
+              expect(io_probe.string).to eq <<-ERROR
+~> nonexistent.php (0 B) [error]
+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+[SkadateGems::Dev::Remote::TestError]: Uh! Ogh!
+------------------------------
+              ERROR
+            end
+          end
+
+        end
+      end
+    end
+
+  end
+end