citrus-core 0.0.1 → 0.0.2

data/lib/citrus/core/test_output.rb

@@ -0,0 +1,19 @@
+module Citrus
+  module Core
+    class TestOutput
+
+      def initialize
+        @output = ""
+      end
+
+      def write(data)
+        @output << data
+      end
+
+      def read
+        @output
+      end
+
+    end
+  end
+end

data/lib/citrus/core/test_runner.rb

@@ -1,5 +1,3 @@
-require 'stringio'
-
 module Citrus
   module Core
     class TestRunner
@@ -7,24 +5,24 @@ module Citrus
 
       include Publisher
 
-      def start(configuration, path)
+      def start(build, configuration, path)
+        output  = build.output
         process = ChildProcess.build(configuration.build_script)
         process.cwd = path.to_s
         r, w = IO.pipe
         process.io.stdout = process.io.stderr = w
         process.start
         w.close
-        output = StringIO.new
         begin
           loop do
             chunk = r.readpartial(CHUNK_SIZE)
             output.write(chunk)
-            publish(:output_received, chunk)
+            publish(:build_output_received, build, chunk)
           end
         rescue EOFError
         end
         process.wait
-        TestResult.new(process.exit_code, output)
+        ExitCode.new(process.exit_code)
       end
 
     end

data/lib/citrus/core/version.rb

@@ -1,5 +1,5 @@
 module Citrus
   module Core
-    VERSION = "0.0.1"
+    VERSION = "0.0.2"
   end
 end

data/lib/citrus/core/workspace_builder.rb

@@ -2,16 +2,16 @@ module Citrus
   module Core
     class WorkspaceBuilder
 
-      attr_reader :root_path, :code_fetcher
+      attr_reader :build_root, :code_fetcher
 
-      def initialize(root_path = Citrus::Core.build_root, code_fetcher = CachedCodeFetcher.new)
-        @root_path    = root_path
+      def initialize(build_root, code_fetcher)
+        @build_root   = build_root
         @code_fetcher = code_fetcher
       end
 
       def create_workspace(build)
-        path = root_path.join(partition, build.uuid)
-        path.mkpath
+        path = File.join(build_root, partition, build.uuid)
+        FileUtils.mkpath(path)
         code_fetcher.fetch(build.changeset, path)
         path
       end

data/lib/citrus/core/world.rb

@@ -0,0 +1,21 @@
+module Citrus
+  module Core
+    class World
+
+      attr_reader :root
+
+      def initialize(root)
+        @root = root
+      end
+
+      def cache_root
+        File.join(root, 'cache')
+      end
+
+      def build_root
+        File.join(root, 'builds')
+      end
+
+    end
+  end
+end

data/spec/citrus/core/build_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'securerandom'
+
+describe Citrus::Core::Build do
+
+  subject { described_class.new(changeset, uuid, output) }
+
+  let(:changeset) { fake(:changeset) }
+  let(:uuid)      { SecureRandom.uuid }
+  let(:output)    { fake(:test_output) }
+
+  specify { expect(subject).to respond_to(:changeset) }
+  specify { expect(subject).to respond_to(:uuid) }
+  specify { expect(subject).to respond_to(:output) }
+
+end

data/spec/{cached_code_fetcher_spec.rb → citrus/core/cached_code_fetcher_spec.rb}

@@ -1,44 +1,47 @@
 require 'spec_helper'
+require 'tmpdir'
+
+class Digester
+  def hexdigest(input); input; end
+end
 
 describe Citrus::Core::CachedCodeFetcher do
 
-  subject { described_class.new(cache_root, vcs_adapter) }
+  subject { described_class.new(cache_root, vcs_adapter, digester) }
 
-  let(:destination)     { fake(:pathname) }
+  let(:destination)     { '/destination' }
   let(:vcs_adapter)     { fake(:git_adapter) }
+  let(:digester)        { fake(:digester, hexdigest: 'dummy') }
   let(:changeset)       { fake(:changeset, head: head_commit_sha, repository_url: repository_url) }
   let(:repository_url)  { 'git://github.com/pawelpacana/citrus-core.git' }
   let(:head_commit_sha) { 'deadbeef' }
+  let(:cache_root)      { Dir.mktmpdir('cache_root') }
+  let(:cache_dir)       { File.join(cache_root, 'dummy') }
 
   context '#fetch' do
-    include FakeFS::SpecHelpers
-
     context 'with empty cache' do
-      let(:cache_root) { fake(:pathname) }
-      let(:cache_dir)  { fake(:pathname) }
 
       before do
-        stub(cache_root).join(any_args) { cache_dir }
-        stub(cache_dir).exist?          { false }
         subject.fetch(changeset, destination)
       end
 
+      it 'should create cache dir' do
+        expect(File.exist?(cache_dir)).to be_true
+      end
+
       it 'should clone repository to cache dir' do
         expect(vcs_adapter).to have_received.clone_repository(repository_url, cache_dir)
       end
 
       it 'should clone updated cache to destination' do
+        mock(digester).hexdigest(repository_url) { cache_dir }
         expect(vcs_adapter).to have_received.clone_repository(cache_dir, destination)
       end
     end
 
     context 'with repository clone in cache' do
-      let(:cache_root) { fake(:pathname) }
-      let(:cache_dir)  { fake(:pathname) }
-
       before do
-        stub(cache_root).join(any_args) { cache_dir }
-        stub(cache_dir).exist?          { true }
+        FileUtils.mkpath(File.join(cache_dir, 'some_file'))
         subject.fetch(changeset, destination)
       end
 
@@ -52,12 +55,10 @@ describe Citrus::Core::CachedCodeFetcher do
     end
 
     context do
-      let(:cache_root) { Pathname.new('/cache_root') }
-
       before { subject.fetch(changeset, destination) }
 
       it 'should create cache dir for repository' do
-        expect(cache_root.children).to have(1).element
+        expect(Pathname.new(cache_root).children).to have(1).element
       end
 
       it 'should checkout head commit from changeset' do

data/spec/citrus/core/clean_ruby_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe 'Ruby syntax' do
+
+  it 'is clean' do
+    expect(citrus_core_warnings).to eq([])
+  end
+
+  def citrus_core_warnings
+    warnings.select { |w| w =~ %r{lib/citrus/core} }
+  end
+
+  def warnings
+    `ruby -Ilib -w lib/citrus/core.rb 2>&1`.split("\n")
+  end
+
+end

data/spec/{cofiguration_loader_spec.rb → citrus/core/configuration_loader_spec.rb}

@@ -5,7 +5,7 @@ describe Citrus::Core::ConfigurationLoader do
   subject { described_class.new(validator) }
 
   let(:validator) { fake(:configuration_validator) }
-  let(:test_root) { Pathname.new(File.dirname(__FILE__)) }
+  let(:test_root) { Pathname.new(File.dirname(__FILE__)).join('../../') }
   let(:repo_root) { test_root.join('fixtures/repo') }
 
   context '#load_from_path' do

data/spec/{execute_build_service_spec.rb → citrus/core/execute_build_spec.rb}

@@ -2,56 +2,61 @@ require 'spec_helper'
 
 class Subscriber
   def build_started(build);           end
-  def build_failed(build, output);    end
-  def build_succeeded(build, output); end
+  def build_failed(build, result);    end
+  def build_succeeded(build, result); end
   def build_aborted(build, reason);   end
 end
 
-describe Citrus::Core::ExecuteBuildService do
+describe Citrus::Core::ExecuteBuild do
 
   subject { described_class.new(workspace_builder, configuration_loader, test_runner) }
 
   let(:workspace_builder)     { fake(:workspace_builder, create_workspace: path) }
-  let(:test_runner)           { fake(:test_runner, start: fake(:test_result, output: result_output)) }
-  let(:build)                 { fake(:build) }
+  let(:test_runner)           { fake(:test_runner, start: exit_code) }
+  let(:build)                 { fake(:build, output: test_output) }
   let(:configuration_loader)  { fake(:configuration_loader, load_from_path: configuration) }
   let(:configuration)         { fake(:configuration) }
   let(:path)                  { fake }
   let(:subscriber)            { fake(:subscriber) }
-  let(:success_result)        { Citrus::Core::TestResult.new(0) }
-  let(:failure_result)        { Citrus::Core::TestResult.new(1) }
-  let(:result_output)         { StringIO.new }
+  let(:exit_code)             { fake(:exit_code) }
+  let(:test_output)           { fake(:test_output) }
 
   context '#start' do
     before { subject.add_subscriber(subscriber) }
 
     context do
-      before { subject.start(build) }
-
       it 'should prepare workspace for build' do
+        subject.start(build)
         expect(workspace_builder).to have_received.create_workspace(build)
       end
 
       it 'should read build configuration from workspace' do
+        subject.start(build)
         expect(configuration_loader).to have_received.load_from_path(path)
       end
 
       it 'should execute build script' do
-        expect(test_runner).to have_received.start(configuration, path)
+        subject.start(build)
+        expect(test_runner).to have_received.start(build, configuration, path)
       end
 
       it 'should publish build_started event when starting build' do
+        subject.start(build)
         expect(subscriber).to have_received.build_started(build)
       end
 
       it 'should publish build_succeeded event when build has succeeded' do
-        stub(test_runner).start(any_args) { success_result }
-        expect(subscriber).to have_received.build_succeeded(build, result_output)
+        stub(exit_code).success? { true }
+        stub(test_runner).start(any_args) { exit_code }
+        subject.start(build)
+        expect(subscriber).to have_received.build_succeeded(build, exit_code)
       end
 
       it 'should publish build_failed event when build has failed' do
-        stub(test_runner).start(any_args) { failure_result }
-        expect(subscriber).to have_received.build_failed(build, result_output)
+        stub(exit_code).failure? { true }
+        stub(test_runner).start(any_args) { exit_code }
+        subject.start(build)
+        expect(subscriber).to have_received.build_failed(build, exit_code)
       end
     end
 

data/spec/{test_result_spec.rb → citrus/core/exit_code_spec.rb}

@@ -1,6 +1,12 @@
 require 'spec_helper'
 
-describe Citrus::Core::TestResult do
+describe Citrus::Core::ExitCode do
+
+  it 'should expose exit code value' do
+    exit_code = 0
+    subject = described_class.new(exit_code)
+    expect(subject.value).to eq(exit_code)
+  end
 
   it 'should be successful for zero exit code value' do
     subject = described_class.new(0)
@@ -12,9 +18,4 @@ describe Citrus::Core::TestResult do
     expect(subject.failure?).to be_true
   end
 
-  it 'should have IO like output' do
-    subject = described_class.new(0)
-    expect(subject.output).to respond_to(:rewind)
-  end
-
 end

data/spec/{github_adapter_spec.rb → citrus/core/github_adapter_spec.rb}

@@ -4,7 +4,7 @@ describe Citrus::Core::GithubAdapter do
 
   subject { described_class.new }
 
-  let(:push_data) { Pathname.new(File.dirname(__FILE__)).join('fixtures/github_push_data.json').read }
+  let(:push_data) { Pathname.new(File.dirname(__FILE__)).join('../../fixtures/github_push_data.json').read }
 
   context '#create_changeset_from_push_data' do
     let(:changeset) { subject.create_changeset_from_push_data(push_data) }

data/spec/{publisher_spec.rb → citrus/core/publisher_spec.rb}

@@ -20,7 +20,7 @@ describe Citrus::Core::Publisher do
     expect {
       subject.add_subscriber(subscriber)
       subject.publish(:foo)
-    }.to_not raise_error(NoMethodError)
+    }.to_not raise_error
   end
 
 end

data/spec/citrus/core/test_output_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Citrus::Core::TestOutput do
+
+  let(:test_output) { described_class.new }
+
+  specify { expect(test_output).to respond_to(:read)  }
+  specify { expect(test_output).to respond_to(:write) }
+
+  it 'should accumulate test output' do
+    chunks = %w(kaka dudu)
+    chunks.each { |c| test_output.write(c) }
+    expect(test_output.read).to eq(chunks.join)
+  end
+
+end

data/spec/citrus/core/test_runner_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+class Subscriber
+  def build_output_received(build, data); end
+end
+
+describe Citrus::Core::TestRunner do
+
+  subject { described_class.new }
+
+  let(:configuration) { fake(:configuration, build_script: 'hostname') }
+  let(:path)          { Pathname.new('/') }
+  let(:process)       { fake(io: process_io, exit_code: exit_code) { ChildProcess::AbstractProcess } }
+  let(:process_io)    { fake { ChildProcess::AbstractIO } }
+  let(:exit_code)     { fake(:fixnum) }
+  let(:subscriber)    { fake(:subscriber) }
+  let(:build)         { fake(:build, output: build_output) }
+  let(:build_output)  { fake(:test_output) }
+
+  context '#start' do
+    context do
+      before { stub(ChildProcess).build(configuration.build_script) { process } }
+
+      it 'spawns child process' do
+        subject.start(build, configuration, path)
+        expect(process).to have_received.start
+      end
+
+      it 'should return test result' do
+        expect(subject.start(build, configuration, path)).to be_kind_of(Citrus::Core::ExitCode)
+      end
+
+      it 'should wait for process to finish' do
+        subject.start(build, configuration, path)
+        expect(process).to have_received.wait
+      end
+    end
+
+    it 'should publish build_output_received event when process produced output' do
+      subject.add_subscriber(subscriber)
+      subject.start(build, configuration, path)
+      expect(subscriber).to have_received.build_output_received(build, `hostname`)
+    end
+
+    it 'should write process output to build' do
+      subject.start(build, configuration, path)
+      expect(build_output).to have_received.write(`hostname`)
+    end
+  end
+
+  it 'should allow adding subscribers' do
+    expect(subject).to respond_to(:add_subscriber)
+  end
+
+end

data/spec/citrus/core/workspace_builder_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'tmpdir'
+
+describe Citrus::Core::WorkspaceBuilder do
+
+  subject { described_class.new(build_root, code_fetcher) }
+
+  let(:build)          { fake(:build, uuid: uuid, changeset: changeset) }
+  let(:uuid)           { SecureRandom.uuid }
+  let(:changeset)      { fake(:changeset) }
+  let(:code_fetcher)   { fake(:cached_code_fetcher) }
+  let(:build_root)     { Dir.mktmpdir('build_root') }
+
+  context '#create_workspace' do
+    let(:result) { subject.create_workspace(build) }
+
+    it 'should create build directory under build root' do
+      expect(result).to start_with(build_root)
+    end
+
+    it 'should create workspace in directories partitioned by date' do
+      expect(File.dirname(result)).to match(%r{/\d{4}/\d{2}/\d{2}\Z})
+    end
+
+    it 'should create workspace named after builds uuid' do
+      expect(File.basename(result)).to eql(uuid)
+    end
+
+    it 'should fetch code needed for build into workspace' do
+      stub(Time).now { Time.at(0) }
+      result
+      expect(code_fetcher).to have_received.fetch(changeset, "#{build_root}/1970/01/01/#{uuid}")
+    end
+
+  end
+
+end