citrus-core 0.0.1

data/lib/citrus/core/git_adapter.rb

@@ -0,0 +1,43 @@
+require 'childprocess'
+require 'shellwords'
+
+module Citrus
+  module Core
+    class GitAdapter
+      TIMEOUT = 600
+
+      def clone_repository(source, destination)
+        run %W(git clone #{shell_quote(source)} #{shell_quote(destination)})
+      end
+
+      def fetch_remote(destination, remote = 'origin')
+        run %W(git fetch #{shell_quote(remote)}), destination
+      end
+
+      def checkout(destination, revision = nil)
+        run %W(git checkout -b build #{shell_quote(revision)}), destination
+      end
+
+      def reset(destination, revision = nil)
+        run %W(git reset origin --hard #{shell_quote(revision)}), destination
+      end
+
+      protected
+
+      def run(command, directory = nil)
+        process = ChildProcess.build(*command)
+        process.cwd = directory.to_s if directory
+        process.start
+        process.poll_for_exit(TIMEOUT)
+      rescue ChildProcess::TimeoutError
+        process.stop
+      end
+
+      def shell_quote(string)
+        return "" unless string
+        Shellwords.escape(string.to_s)
+      end
+
+    end
+  end
+end

data/lib/citrus/core/github_adapter.rb

@@ -0,0 +1,21 @@
+require 'json'
+require 'time'
+
+module Citrus
+  module Core
+    class GithubAdapter
+
+      def create_changeset_from_push_data(push_data)
+        data    = JSON.parse(push_data)
+        commits = data['commits'].map do |commit|
+          changes = CommitChanges.new(commit['added'], commit['removed'], commit['modified'])
+          Commit.new(commit['id'], commit['author']['name'], commit['message'],
+                     Time.parse(commit['timestamp']), changes, commit['url'])
+        end
+        repository = Repository.new(data['repository']['url'])
+        return Changeset.new(repository, commits)
+      end
+
+    end
+  end
+end

data/lib/citrus/core/publisher.rb

@@ -0,0 +1,23 @@
+module Citrus
+  module Core
+    module Publisher
+
+      def add_subscriber(subscriber)
+        subscribers << subscriber
+      end
+
+      def publish(event, *args)
+        subscribers.each do |subscriber|
+          subscriber.public_send(event, *args) if subscriber.respond_to?(event)
+        end
+      end
+
+      protected
+
+      def subscribers
+        @subscribers ||= []
+      end
+
+    end
+  end
+end

data/lib/citrus/core/repository.rb

@@ -0,0 +1,13 @@
+module Citrus
+  module Core
+    class Repository
+
+      attr_reader :url
+
+      def initialize(url)
+        @url = url
+      end
+
+    end
+  end
+end

data/lib/citrus/core/test_result.rb

@@ -0,0 +1,24 @@
+require 'stringio'
+
+module Citrus
+  module Core
+    class TestResult
+
+      attr_reader :value, :output
+
+      def initialize(value, output = StringIO.new)
+        @value  = value.to_i
+        @output = output
+      end
+
+      def success?
+        value == 0
+      end
+
+      def failure?
+        !success?
+      end
+
+    end
+  end
+end

data/lib/citrus/core/test_runner.rb

@@ -0,0 +1,32 @@
+require 'stringio'
+
+module Citrus
+  module Core
+    class TestRunner
+      CHUNK_SIZE = 8192
+
+      include Publisher
+
+      def start(configuration, path)
+        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)
+          end
+        rescue EOFError
+        end
+        process.wait
+        TestResult.new(process.exit_code, output)
+      end
+
+    end
+  end
+end

data/lib/citrus/core/version.rb

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

data/lib/citrus/core/workspace_builder.rb

@@ -0,0 +1,27 @@
+module Citrus
+  module Core
+    class WorkspaceBuilder
+
+      attr_reader :root_path, :code_fetcher
+
+      def initialize(root_path = Citrus::Core.build_root, code_fetcher = CachedCodeFetcher.new)
+        @root_path    = root_path
+        @code_fetcher = code_fetcher
+      end
+
+      def create_workspace(build)
+        path = root_path.join(partition, build.uuid)
+        path.mkpath
+        code_fetcher.fetch(build.changeset, path)
+        path
+      end
+
+      protected
+
+      def partition
+        Time.now.strftime('%Y/%m/%d')
+      end
+
+    end
+  end
+end

data/spec/build_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Citrus::Core::Build do
+
+  subject { described_class.new(changeset, uuid) }
+
+  let(:changeset) { fake(:changeset) }
+  let(:uuid)      { SecureRandom.uuid }
+
+  it { should respond_to(:changeset) }
+  it { should respond_to(:uuid) }
+
+end

data/spec/cached_code_fetcher_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Citrus::Core::CachedCodeFetcher do
+
+  subject { described_class.new(cache_root, vcs_adapter) }
+
+  let(:destination)     { fake(:pathname) }
+  let(:vcs_adapter)     { fake(:git_adapter) }
+  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' }
+
+  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 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
+        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 }
+        subject.fetch(changeset, destination)
+      end
+
+      it 'should fetch repository remote' do
+        expect(vcs_adapter).to have_received.fetch_remote(cache_dir)
+      end
+
+      it 'should reset repository' do
+        expect(vcs_adapter).to have_received.reset(cache_dir)
+      end
+    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
+      end
+
+      it 'should checkout head commit from changeset' do
+        expect(vcs_adapter).to have_received.checkout(destination, head_commit_sha)
+      end
+    end
+
+  end
+end

data/spec/changeset_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Citrus::Core::Changeset do
+
+  subject { described_class.new(repository, commits) }
+
+  let(:repository) { fake(:repository, url: 'file:///repo') }
+  let(:commits)    { [fake(:commit, sha: 'abc'), fake(:commit, sha: 'def')] }
+
+  it { should respond_to(:repository) }
+  it { should respond_to(:commits) }
+  its(:repository_url) { should == 'file:///repo' }
+  its(:head)           { should == 'def' }
+
+end

data/spec/citrus_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Citrus::Core do
+
+  subject { described_class }
+  before  { stub(subject).root { Pathname.new('/dummy') } }
+
+  context '.cache_root' do
+    specify { expect(subject.cache_root.to_s).to match /cache\Z/ }
+    specify { expect(subject.cache_root.to_s).to match /\A#{described_class.root}/ }
+  end
+
+  context '.build_root' do
+    specify { expect(subject.build_root.to_s).to match /builds\Z/ }
+    specify { expect(subject.build_root.to_s).to match /\A#{described_class.root}/ }
+  end
+
+end

data/spec/cofiguration_loader_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Citrus::Core::ConfigurationLoader do
+
+  subject { described_class.new(validator) }
+
+  let(:validator) { fake(:configuration_validator) }
+  let(:test_root) { Pathname.new(File.dirname(__FILE__)) }
+  let(:repo_root) { test_root.join('fixtures/repo') }
+
+  context '#load_from_path' do
+    it 'should return configuration when config file found' do
+      stub(validator).validate(any_args) { true }
+      expect(subject.load_from_path(repo_root)).to be_a_kind_of(Citrus::Core::Configuration)
+    end
+
+    it 'should raise when no configuration can be found' do
+      expect { subject.load_from_path(test_root) }.to raise_error(Citrus::Core::ConfigurationFileNotFoundError)
+    end
+
+    it 'should raise when found configuration is not valid' do
+      stub(validator).validate(any_args) { false }
+      expect { subject.load_from_path(repo_root) }.to raise_error(Citrus::Core::ConfigurationFileInvalidError)
+    end
+  end
+
+end

data/spec/cofiguration_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Citrus::Core::Configuration do
+
+  subject { described_class.new }
+
+  it { should be_a_kind_of(Citrus::Configuration) }
+  it { should respond_to(:build_script)  }
+  it { should respond_to(:build_script=) }
+
+end

data/spec/cofiguration_validator_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Citrus::Core::ConfigurationValidator do
+
+  subject { described_class.new }
+
+  let(:valid_configuration) do
+    Citrus::Core::Configuration.describe do |config|
+      config.build_script = "bundle exec rspec"
+    end
+  end
+
+  context '#validate' do
+    it 'should validate valid example configuration' do
+      expect(subject.validate(valid_configuration)).to be_true
+    end
+
+    it 'should validate class' do
+      expect(subject.validate(Object.new)).to be_false
+    end
+
+    it 'should validate build script presence' do
+      valid_configuration.build_script = ""
+      expect(subject.validate(valid_configuration)).to be_false
+    end
+  end
+
+end

data/spec/commit_changes_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Citrus::Core::CommitChanges do
+
+  subject { described_class.new(added, removed, modified) }
+
+  let(:added)    { %w(spec/dummy_spec.rb lib/dummy.rb) }
+  let(:removed)  { %w(README.md) }
+  let(:modified) { %w(Gemfile Gemfile.lock) }
+
+  it { should respond_to(:added) }
+  it { should respond_to(:removed) }
+  it { should respond_to(:modified) }
+
+end

data/spec/commit_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Citrus::Core::Commit do
+
+  subject { described_class.new(sha, author, message, timestamp, changes, url) }
+
+  let(:author)    { 'John Doe' }
+  let(:sha)       { 'abc' }
+  let(:message)   { 'Fixes, obviously.' }
+  let(:timestamp) { Time.now }
+  let(:url)       { 'https://github.com/octokitty/testing/commit/c441029cf673f84c8b7db52d0a5944ee5c52ff89' }
+  let(:changes)   { fake(:commit_changes) }
+
+  it { should respond_to(:sha) }
+  it { should respond_to(:author) }
+  it { should respond_to(:message) }
+  it { should respond_to(:timestamp) }
+  it { should respond_to(:changes) }
+  it { should respond_to(:url) }
+
+end

data/spec/execute_build_service_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+class Subscriber
+  def build_started(build);           end
+  def build_failed(build, output);    end
+  def build_succeeded(build, output); end
+  def build_aborted(build, reason);   end
+end
+
+describe Citrus::Core::ExecuteBuildService 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(: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 }
+
+  context '#start' do
+    before { subject.add_subscriber(subscriber) }
+
+    context do
+      before { subject.start(build) }
+
+      it 'should prepare workspace for build' do
+        expect(workspace_builder).to have_received.create_workspace(build)
+      end
+
+      it 'should read build configuration from workspace' do
+        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)
+      end
+
+      it 'should publish build_started event when starting build' do
+        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)
+      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)
+      end
+    end
+
+    context 'invalid configuration' do
+      let(:reason) { Citrus::Core::ConfigurationError.new }
+
+      before do
+        stub(configuration_loader).load_from_path(path) { raise reason }
+        expect { subject.start(build) }.to raise_error(Citrus::Core::ConfigurationError)
+      end
+
+      it 'should publish build_aborted event when unable to start build due to invalid configuration' do
+        expect(subscriber).to have_received.build_aborted(build, reason)
+      end
+    end
+  end
+
+  it 'should allow adding subscribers' do
+    expect(subject).to respond_to(:add_subscriber)
+  end
+
+end