phoebo 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b51f88a605d5610ffe5ad9a116133f1bfbd827a6
-  data.tar.gz: 5eab25352327affc5cd992d7992665ccaef95550
+  metadata.gz: 31be5faeea137754c6c0047c9f1bc0da857512df
+  data.tar.gz: db94bcf4c396136cf0838d1273b75cc8acd7beda
 SHA512:
-  metadata.gz: 9ab14f8c74e16a695d331ad31beb983b43e7b84506802861ab6fa177d69f2ad6193a7b212c8e06dd7605c9c55701d6f535583ab1770f69cc9d72848f5796b72b
-  data.tar.gz: ebf9b8b8d13cf6b8897e1a03aa0d39adedbad4d8c279001d13a0a839c045c654f1a0a82841cca73d769bd73466f3a4362dcca865dc47dbfe491a39f7bcb8a45e
+  metadata.gz: 08325e381ee53679aac752bd2809b0fd2a27b81ee7a511cfdd8605d716342cc029d2241e30d4efb39cd2854eb593c035f4e32e7febfec81f0cc994c08685de6d
+  data.tar.gz: 71b3afc4d20ff1c830e68901a725ca09608f3e8cc091d529aef847c520e78a66b46521cb3d001daffc8fc1e4cec4f3d4b46634fa7b6eeed2eb724b02ce99750d

data/README.md

@@ -1,11 +1,95 @@
-# Run
+# Phoebo
 
-```bash
-$ bundle exec bin/phoebo
-```
+## DSL example
 
-# Run tests
+~~~ruby
+Phoebo.configure(1) {
 
-```bash
-rspec
-```
+  # Create image based on Apache + mod_php
+  image('phoebo/nette-example', 'phoebo/simple-apache-php') {
+    # Copy all application data
+    add('.', '/app/')
+
+    # Install dependencies
+    run('composer', 'install', '--prefer-dist')
+
+    # Set document root
+    run('ln', '-s', '/app/www', '/var/www')
+  }
+
+  # Deploy image and keep it runing (default CMD: apache)
+  task('deploy', 'phoebo/nette-example')
+
+  # Run tests on image
+  task('test', 'phoebo/nette-example', '/app/bin/tester', '/app/tests')
+}
+~~~
+
+## Usage
+
+~~~bash
+sudo docker pull phoebo/phoebo:latest
+sudo docker run -ti --privileged -v ~/nette-example-keys:/root/deploy-keys phoebo/phoebo:latest phoebo \
+   --repository ssh://gitlab.fit.cvut.cz/phoebo/nette-example.git \
+   --ssh-key /root/deploy-keys/key \
+   --ssh-public /root/deploy-keys/key.pub \
+   --docker-user joe \
+   --docker-password secret123 \
+   --docker-email joe@domain.tld
+~~~
+
+### Process request from URL
+
+For better integration into your CI workflow you can specify build job by URL instead of verbose CLI arguments.
+
+~~~bash
+phoebo --from-url http://domain.tld/api/requests/2e2996fe8420
+~~~
+
+URL should return JSON formatted payload with following structure:
+
+~~~javascript
+{
+	"id": "2e2996fe8420",
+	"repo_url": "ssh://gitlab.fit.cvut.cz/phoebo/nette-example.git",
+	"ssh_public": "ssh-rsa AAAAB3NzaC1yc2E...",
+	"ssh_private": "-----BEGIN RSA PRIVATE KEY----- ...",
+	"docker_user": "joe",
+	"docker_password": "secret123",
+	"docker_email": "joe@domain.tld"
+}
+~~~
+
+If other CLI arguments are present they will override those loaded from URL.
+
+### Ping back
+
+You can optionally let Phoebo notify you when the build is ready.
+
+~~~bash
+phoebo --ping-url http://domain.tld/api/notify
+~~~
+
+Notification is sent as JSON formatted HTTP POST request with structure bellow.
+The payload contains the same ID you've passed to application with your JSON request.
+Other than that payload contains list of tasks with arguments and image on which they should be run.
+
+~~~javascript
+{
+   "id": "2e2996fe8420",
+   "tasks":[
+      {
+         "name":"deploy",
+         "image":"phoebo/nette-example"
+      },
+      {
+         "name":"test",
+         "image":"phoebo/nette-example",
+         "cmd":[
+            "/app/bin/tester",
+            "/app/tests"
+         ]
+      }
+   ]
+}
+~~~

data/lib/phoebo.rb

@@ -1,12 +1,16 @@
 require 'phoebo/version'
 
 module Phoebo
-  autoload :Application, 'phoebo/application'
-  autoload :Config,      'phoebo/config'
-  autoload :Console,     'phoebo/console'
-  autoload :Docker,      'phoebo/docker'
-  autoload :Environment, 'phoebo/environment'
-  autoload :Util,        'phoebo/util'
+  autoload :Application,        'phoebo/application'
+  autoload :Config,             'phoebo/config'
+  autoload :Console,            'phoebo/console'
+  autoload :Docker,             'phoebo/docker'
+  autoload :Environment,        'phoebo/environment'
+  autoload :Git,                'phoebo/git'
+  autoload :Ping,               'phoebo/ping'
+  autoload :Request,            'phoebo/request'
+  autoload :Util,               'phoebo/util'
+  autoload :Worker,             'phoebo/worker'
 
   class PhoeboError < StandardError
     def self.status_code(code)
@@ -15,6 +19,7 @@ module Phoebo
   end
 
   class InvalidArgumentError < PhoeboError; status_code(4) ; end
+  class InvalidRequestError < InvalidArgumentError ; end
   class IOError < PhoeboError; status_code(5) ; end
   class ExternalError < PhoeboError; status_code(6) ; end
 
@@ -28,7 +33,7 @@ module Phoebo
   # Configure Phoebo environment from Phoebofile
   def self.configure(version, &block)
     raise ConfigError, "Configuration version #{version} not supported" if version != 1
-    Config.load_from_block(block)
+    Config.new_from_block(block)
   end
 
 end

data/lib/phoebo/application.rb

@@ -1,7 +1,5 @@
 require 'optparse'
 require 'colorize'
-require 'docker'
-require 'rugged'
 require 'pathname'
 
 module Phoebo
@@ -23,6 +21,8 @@ module Phoebo
   class Application
     include Console
 
+    attr_writer :environment, :temp_file_manager
+
     # Creates application
     def initialize(args = [])
       @args = args
@@ -55,7 +55,7 @@ module Phoebo
         stderr.puts
       end
 
-      send(('run_' + options[:mode].to_s).to_sym, options).to_i || result
+      [send(('run_' + options[:mode].to_s).to_sym, options).to_i, result].max
     end
 
     # Cleanup sequence
@@ -72,93 +72,69 @@ module Phoebo
     # Run in normal mode
     def run_normal(options)
 
-      # Default project path, is PWD
-      project_path = Dir.pwd
-
-      # If we are building image from Git repository
-      if options[:repository]
+      request = Request.new
+      request.load_from_hash!(options[:request])
 
-        # Prepare SSH credentials if necessary
-        if options[:ssh_key]
-          private_path = Pathname.new(options[:ssh_key])
-
-          raise InvalidArgumentError, "SSH key not found" unless private_path.exist?
-          raise InvalidArgumentError, "Missing public SSH key" unless options[:ssh_public]
+      if options[:request_file]
+        stdout.puts "Loading request from file: " + options[:request_file].cyan
+        request.load_from_file!(options[:request_file])
+      end
 
-          public_path = Pathname.new(options[:ssh_public])
-          raise InvalidArgumentError, "Public SSH key not found" unless public_path.exist?
+      if options[:request_url]
+        stdout.puts "Fetching request from URL: " + options[:request_url].cyan + "...".light_black
+        request.load_from_url!(options[:request_url])
+      end
 
-          cred = Rugged::Credentials::SshKey.new(
-            username: options[:ssh_user],
-            publickey: public_path.realpath.to_s,
-            privatekey: private_path.realpath.to_s
-          )
-        else
-          cred = nil
-        end
+      # Raises InvalidRequestError if invalid
+      request.validate
 
-        # Create temp dir.
+      # Prepare project directory
+      if request.repo_url
+        # Create temp dir & clone
         project_path = temp_file_manager.path('project')
+        stdout.puts "Cloning remote repository " + "...".light_black
+        Git.clone(request, project_path)
 
-        # Clone remote repository
-        begin
-          stdout.puts "Cloning remote repository " + "...".light_black
-          Rugged::Repository.clone_at options[:repository],
-            project_path, credentials: cred
-
-        rescue Rugged::SshError => e
-          raise unless e.message.include?('authentication')
-          raise IOError, "Unable to clone remote repository. SSH authentication failed."
-        end
-      end
-
-      # Prepare Docker credentials
-      if options[:docker_username]
-        raise InvalidArgumentError, "Missing docker password." unless options[:docker_password]
-        raise InvalidArgumentError, "Missing docker e-mail." unless options[:docker_email]
-
-        pusher = Docker::ImagePusher.new(
-          options[:docker_username],
-          options[:docker_password],
-          options[:docker_email]
-        )
       else
-        pusher = nil
+        project_path = Dir.pwd
       end
 
-      # Exit code
+      # Worker
+      worker = Worker.new(request)
       result = 0
+      configs = []
 
-      # Process all the files
+      # Process all
       options[:files] << '.' if options[:files].empty?
       options[:files].each do |rel_path|
+        path = (Pathname.new(project_path) + rel_path)
 
-        path = (Pathname.new(project_path) + rel_path).realpath.to_s
-
-        # Prepare config path
-        config_filename = 'Phoebofile'
-        config_path = "#{path}#{File::SEPARATOR}#{config_filename}"
-
-        # Check if config exists -> resumable error
-        unless File.exists?(config_path)
-          stderr.puts "No #{config_filename} found in #{path}".red
+        # Directory does not exist -> resume with next dir.
+        if path.exist?
+          path = path.realpath.to_s
+        else
+          stderr.puts "Directory #{path.to_s} does not exist".red
           result = 1
           next
         end
 
-        # Load config
-        config = Config.load_from_file(config_path)
-
-        # Build & push image
-        builder = Docker::ImageBuilder.new(path)
-        config.images.each do |image|
-          image_id = builder.build(image)
-          pusher.push(image_id) if pusher
+        # Directory does not have any config -> nothing to do -> resume with next dir.
+        unless config = worker.process(path)
+          stderr.puts "No config found in #{path}".red
+          result = 1
+          next
         end
+
+        configs << config
       end
 
-      puts "Everything done :-)".green
+      # Ping
+      if request.ping_url
+        stdout.puts "Notifying URL: " + request.ping_url.cyan + "...".light_black
+        Ping.send(request, configs)
+      end
 
+      stdout.puts "Everything done :-)".green
       result
     end
 
@@ -176,7 +152,7 @@ module Phoebo
 
     # Parse passed command-line options
     def parse_options
-      options = { error: nil, mode: :normal, files: [], ssh_user: 'git' }
+      options = { error: nil, mode: :normal, request: {}, files: [], ssh_user: 'git' }
 
       unless @option_parser
         @option_parser = OptionParser.new
@@ -184,31 +160,43 @@ module Phoebo
           "Usage: #{@option_parser.program_name} [options] file"
 
         @option_parser.on_tail('-rURL', '--repository=URL', 'Repository URL') do |value|
-          options[:repository] = value
+          options[:request][:repo_url] = value
         end
 
         @option_parser.on_tail('--ssh-user=USERNAME', 'Username for Git over SSH (Default: git)') do |value|
-          options[:ssh_user] = value
+          options[:request][:ssh_user] = value
         end
 
         @option_parser.on_tail('--ssh-public=PATH', 'Path to public SSH key for Git repository') do |value|
-          options[:ssh_public] = value
+          options[:request][:ssh_public_file] = value
         end
 
         @option_parser.on_tail('--ssh-key=PATH', 'Path to SSH key for Git repository') do |value|
-          options[:ssh_key] = value
+          options[:request][:ssh_private_file] = value
         end
 
         @option_parser.on_tail('--docker-user=USERNAME', 'Username for Docker Registry') do |value|
-          options[:docker_username] = value
+          options[:request][:docker_user] = value
         end
 
         @option_parser.on_tail('--docker-password=PASSWORD', 'Password for Docker Registry') do |value|
-          options[:docker_password] = value
+          options[:request][:docker_password] = value
         end
 
         @option_parser.on_tail('--docker-email=EMAIL', 'E-mail for Docker Registry') do |value|
-          options[:docker_email] = value
+          options[:request][:docker_email] = value
+        end
+
+        @option_parser.on_tail('--ping-url=REQUEST_URL', 'URL will be notified after build') do |value|
+          options[:request][:ping_url] = value
+        end
+
+        @option_parser.on_tail('-U', '--from-url=REQUEST_URL', 'Process build request from URL') do |value|
+          options[:request_url] = value
+        end
+
+        @option_parser.on_tail('-f', '--from-file=PATH', 'Process build request from local file') do |value|
+          options[:request_file] = value
         end
 
         @option_parser.on_tail('--version', 'Show version info') do

data/lib/phoebo/config.rb

@@ -3,14 +3,14 @@ module Phoebo
     autoload :Image, 'phoebo/config/image'
     autoload :ImageCommands, 'phoebo/config/image_commands'
 
-    attr_accessor :images
+    attr_accessor :images, :tasks
 
     # Loads config from file
     # @see Phoebo.configure()
-    def self.load_from_file(file_path)
+    def self.new_from_file(file_path)
       begin
         @instance = nil
-        Kernel.load File.expand_path(file_path), true
+        Kernel.load file_path, true
         @instance
 
       rescue ::SyntaxError => e
@@ -18,7 +18,7 @@ module Phoebo
       end
     end
 
-    def self.load_from_block(block)
+    def self.new_from_block(block)
       @instance = self.new
       @instance.dsl_eval(block)
     end
@@ -26,6 +26,7 @@ module Phoebo
     # Instance initialization
     def initialize
       @images = []
+      @tasks = []
     end
 
     # Evaluate block within DSL context
@@ -42,10 +43,20 @@ module Phoebo
       end
 
       def image(name, from, &block)
-        @config.images << (img_instance = Image.new(name, from))
-        img_instance.dsl_eval(block)
+        @config.images << (img_instance = Image.new(name, from, block))
         img_instance
       end
+
+      def task(name, image, *args)
+        task = {
+          name: name,
+          image: image
+        }
+
+        task[:cmd] = args unless args.empty?
+        @config.tasks << task
+        task
+      end
     end
 
   end

data/lib/phoebo/config/image.rb

@@ -3,10 +3,11 @@ module Phoebo
     class Image
       attr_accessor :actions, :name, :from
 
-      def initialize(name, from)
+      def initialize(name, from, block = nil)
         @actions = []
         @name = name
         @from = from
+        dsl_eval(block) if block
       end
 
       # Evaluate block within DSL context

data/lib/phoebo/docker/image_builder.rb

@@ -1,4 +1,6 @@
 require 'rubygems/package'
+require 'docker'
+require 'colorize'
 
 module Phoebo
   module Docker

data/lib/phoebo/docker/image_pusher.rb

@@ -1,3 +1,5 @@
+require 'docker'
+
 module Phoebo
   module Docker
     class ImagePusher

data/lib/phoebo/git.rb

@@ -0,0 +1,28 @@
+require 'rugged'
+
+module Phoebo
+  class Git
+    def self.clone(request, clone_path)
+      # Use passed SSH keys or fallback to system authentication
+      if request.ssh_private_file
+        cred = Rugged::Credentials::SshKey.new(
+          username: request.ssh_user,
+          publickey: request.ssh_public_file,
+          privatekey: request.ssh_private_file
+        )
+      else
+        cred = Rugged::Credentials::Default.new
+      end
+
+      # Clone remote repository
+      begin
+        Rugged::Repository.clone_at request.repo_url,
+          clone_path, credentials: cred
+
+      rescue Rugged::SshError => e
+        raise unless e.message.include?('authentication')
+        raise IOError, "Unable to clone remote repository. SSH authentication failed."
+      end
+    end
+  end
+end

data/lib/phoebo/ping.rb

@@ -0,0 +1,24 @@
+require 'uri'
+require 'net/http'
+
+module Phoebo
+  class Ping
+    def self.send(request, configs)
+      payload = {
+        id: request.id,
+        tasks: []
+      }
+
+      configs.each do |config|
+        payload[:tasks] += config.tasks
+      end
+
+      uri = URI(request.ping_url)
+      req = Net::HTTP::Post.new(uri, {'Content-Type' =>'application/json'})
+      req.body = payload.to_json
+      res = Net::HTTP.start(uri.hostname, uri.port) do |http|
+        http.request(req)
+      end
+    end
+  end
+end

data/lib/phoebo/request.rb

@@ -0,0 +1,132 @@
+require 'uri'
+require 'net/http'
+require 'json'
+
+module Phoebo
+  # Application request
+  # Class is used as a container for user input and to perform easy merging user
+  # input from multiple sources (HTTP request, CLI options) and provides data
+  # validation with human-readable error messages.
+  class Request
+    attr_accessor :repo_url, :ssh_user, :ssh_private_file, :ssh_public_file
+    attr_accessor :docker_user, :docker_password, :docker_email
+    attr_accessor :id, :ping_url
+    attr_writer :temp_file_manager
+
+    def initialize
+      @ssh_user = 'git'
+    end
+
+    # Temporary file manager
+    def temp_file_manager
+      @temp_file_manager ||= Application.instance.temp_file_manager
+    end
+
+    # Allows to use SSH content instead of SSH key file
+    # (We need to place it into temporary file because Rugged needs it)
+    def ssh_private=(key_content)
+      @ssh_private_file = temp_file_manager.path('key')
+      IO.write(@ssh_private_file, key_content)
+    end
+
+    # Allows to use SSH content instead of SSH key file
+    # (We need to place it into temporary file because Rugged needs it)
+    def ssh_public=(key_content)
+      @ssh_public_file = temp_file_manager.path('key.pub')
+      IO.write(@ssh_public_file, key_content)
+    end
+
+    # Loads request with data from hash
+    def load_from_hash!(hash)
+      hash.each do |k, v|
+        m = (k.to_s + '=').to_sym
+        raise InvalidRequestError, "Invalid key #{k.inspect}" unless respond_to?(m)
+        send(m, v)
+      end
+
+      self
+    end
+
+    # Loads request from JSON string
+    def load_from_json!(raw_data)
+      begin
+        hash = JSON.parse(raw_data)
+      rescue JSON::ParserError => e
+        raise InvalidRequestError, "Malformed JSON data."
+      end
+
+      load_from_hash!(hash)
+    end
+
+    # Loads request fro local file
+    def load_from_file!(file_path)
+      raise IOError, "File #{file_path} not exist" unless File.exist?(file_path)
+      raw_data = IO.read(file_path)
+      load_from_json!(raw_data)
+    end
+
+    # Loads request from URL
+    def load_from_url!(url)
+      uri = URI(url)
+      req = Net::HTTP::Get.new(uri)
+      req['Accept'] = 'application/json'
+
+      res = Net::HTTP.start(uri.hostname, uri.port) do |http|
+        http.request(req)
+      end
+
+      # TODO: handle redirects
+      raise IOError, "Unable to load URL #{url}" unless res.code == 200
+
+      load_from_json!(res.body)
+    end
+
+    # Validates request and returns array of error messages
+    # or empty array if there are none
+    def errors
+      errors = []
+
+      if repo_url
+        begin
+          uri = URI(repo_url)
+          errors << "Invalid repository URL. Only SSH supported at the moment. Expected format: ssh://host/path/to/repo.git" \
+             unless uri.scheme == 'ssh'
+        rescue URI::InvalidURIError
+          errors << "Invalid repository URL. Expected format: ssh://host/path/to/repo.git"
+        end
+      end
+
+      unless [ssh_private_file, ssh_public_file].select { |v| v } .empty?
+        errors << "Missing SSH user." unless ssh_user
+        errors << "Missing private SSH key." unless ssh_private_file
+        errors << "Missing public SSH key." unless ssh_public_file
+      end
+
+      unless [docker_user, docker_password, docker_email].select { |v| v } .empty?
+        errors << "Missing Docker user." unless docker_user
+        errors << "Missing Docker password." unless docker_password
+        errors << "Missing Docker email." unless docker_email
+      end
+
+      if ping_url
+        begin
+          uri = URI(ping_url)
+          errors << "Invalid ping URL. Only HTTP / HTTPS supported at the moment. Expected format: https://domain.tld/api/notify" \
+             unless uri.scheme == 'http' || uri.scheme == 'https'
+        rescue URI::InvalidURIError
+          errors << "Invalid ping URL. Expected format: https://domain.tld/api/notify"
+        end
+      end
+
+      errors
+    end
+
+    # Validate request and raises first discovered error as an exception
+    def validate
+      unless (e = errors).empty?
+        raise InvalidRequestError, e.first
+      end
+    end
+
+  end
+end

data/lib/phoebo/version.rb

@@ -1,3 +1,3 @@
 module Phoebo
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/lib/phoebo/worker.rb

@@ -0,0 +1,38 @@
+module Phoebo
+  class Worker
+    def initialize(request)
+      @request = request
+    end
+
+    def pusher
+      @pusher ||= Docker::ImagePusher.new(
+        @request.docker_user,
+        @request.docker_password,
+        @request.docker_email
+      )
+    end
+
+    def process(path)
+
+      # Prepare config path
+      config_filename = 'Phoebofile'
+      config_path = "#{path}#{File::SEPARATOR}#{config_filename}"
+
+      if File.exists?(config_path)
+        # Load config
+        config = Config.new_from_file(config_path)
+
+        # Build & push image
+        builder = Docker::ImageBuilder.new(path)
+        config.images.each do |image|
+          image_id = builder.build(image)
+          pusher.push(image_id) if @request.docker_user
+        end
+
+        config
+      else
+        false
+      end
+    end
+  end
+end

data/spec/phoebo/application_spec.rb

@@ -48,4 +48,64 @@ describe Phoebo::Application do
     end
   end
 
+  context '--help argument' do
+    subject(:app) { described_class.new(['--help']) }
+
+    it 'returns 0' do
+      expect(app.run).to eq 0
+    end
+
+    it 'shows usage' do
+      app.run
+      expect(app.stdout.string).to include('Usage:')
+    end
+  end
+
+  context 'normal run with all arguments' do
+    let(:args) {[
+       '--repository', 'ssh://host/path/to/repo.git',
+       '--ssh-user', 'git',
+       '--ssh-key', './key',
+       '--ssh-public', './key.pub',
+       '--docker-user', 'joe',
+       '--docker-password', 'secret123',
+       '--docker-email', 'joe@domain.tld',
+       'dir1', 'dir2'
+    ]}
+
+    subject(:app) {
+      app = described_class.new(args)
+      app.temp_file_manager = instance_double(Phoebo::Util::TempFileManager)
+      allow(app.temp_file_manager).to receive(:path) { |*args| "/tmp/random/#{args.join('/')}" }
+      allow(app.temp_file_manager).to receive(:need_cleanup?).and_return(true)
+      app
+    }
+
+    before(:each) {
+      allow(Phoebo::Git).to receive(:clone).and_return(nil)
+    }
+
+    it 'returns 1 if no files were processed' do
+      expect(app.run).to eq 1
+    end
+
+    it 'cleans temporary files' do
+      expect(app.temp_file_manager).to receive(:cleanup)
+      app.cleanup
+    end
+  end
+
+  context 'bad arguments' do
+    subject(:app) { described_class.new(['--foobar']) }
+
+    it 'returns 1' do
+      expect(app.run).to eq 1
+    end
+
+    it 'shows usage' do
+      app.run
+      expect(app.stdout.string).to include('Usage:')
+    end
+  end
+
 end

data/spec/phoebo/config/image_spec.rb

@@ -0,0 +1,19 @@
+require_relative '../../spec_helper'
+
+describe Phoebo::Config::Image do
+
+  let(:dsl) {
+    Proc.new {
+      add('.', '/app/')
+      run('composer', 'install', '--prefer-dist')
+    }
+  }
+
+  subject { described_class.new('image-name', 'base-image-name') }
+
+  it 'processes commands' do
+    expect(Phoebo::Config::ImageCommands::Add).to receive(:action).with('.', '/app/')
+    expect(Phoebo::Config::ImageCommands::Run).to receive(:action).with('composer', 'install', '--prefer-dist')
+    subject.dsl_eval(dsl)
+  end
+end

data/spec/phoebo/config_spec.rb

@@ -0,0 +1,57 @@
+require_relative '../spec_helper'
+
+describe Phoebo::Config do
+
+  subject { described_class }
+
+  context 'loading DSL' do
+    subject { described_class }
+
+    let(:dsl_content) { Proc.new { } }
+
+    it 'loads block' do
+      allow(Kernel).to receive(:load).with('./Phoebofile', true) do
+        Phoebo.configure(1, &dsl_content)
+      end
+
+      # It goes like this:
+      # 1) Config.new_from_file('./Phoebofile')
+      # 2) It loads file using Kernel.load (immediatly interprets it's content)
+      # 3) Inside of this file there is call Phoebo.configure(version) { DSL BLOCK }
+      #    which introduces our DSL.
+      # 4) When Phoebo.configure() is called it passes DSL BLOCK to Config.new_from_block()
+      # 5) Config.new_from_block() saves instance internally
+      # 6) Config.new_from_file() returns saved instance
+
+      expect(subject).to receive(:new_from_block).with(dsl_content).and_call_original
+      expect(subject.new_from_file('./Phoebofile').is_a?(described_class)).to eq true
+    end
+
+    it 'raises human readable message on syntax error' do
+      allow(Kernel).to receive(:load).with('./Phoebofile', true) do
+        raise ::SyntaxError
+      end
+
+      expect { subject.new_from_file('./Phoebofile') }.to raise_error(Phoebo::SyntaxError)
+    end
+  end
+
+  context 'images' do
+    subject { described_class.new }
+    let(:image_dsl_block) { Proc.new { } }
+    let(:dsl) {
+      child_block = image_dsl_block
+      Proc.new {
+        image('image-name', 'base-image-name', &child_block)
+      }
+    }
+
+    it 'processes images' do
+      image = instance_double(Phoebo::Config::Image)
+      expect(Phoebo::Config::Image).to receive(:new).with('image-name', 'base-image-name', image_dsl_block).and_return(image)
+
+      subject.dsl_eval(dsl)
+      expect(subject.images).to include(image)
+    end
+  end
+end

data/spec/phoebo/docker/image_builder_spec.rb

@@ -0,0 +1,45 @@
+require_relative '../../spec_helper'
+
+describe Phoebo::Docker::ImageBuilder do
+
+  # Set output stream before test
+  before(:all) {
+    described_class.stdout = StringIO.new
+    described_class.stderr = StringIO.new
+  }
+
+  # Clean output streams before each run
+  before(:each) {
+    described_class.stdout.truncate(0)
+    described_class.stderr.truncate(0)
+  }
+
+  subject { described_class.new('./somedir') }
+
+  let(:image) {
+    actions = [
+      Phoebo::Config::ImageCommands::Add.action('.', '/app/'),
+      Phoebo::Config::ImageCommands::Run.action('composer', 'install', '--prefer-dist')
+    ]
+
+    image = instance_double(Phoebo::Config::Image)
+    allow(image).to receive(:name).and_return('image-name')
+    allow(image).to receive(:from).and_return('debian')
+    allow(image).to receive(:actions).and_return(actions)
+
+    image
+  }
+
+  let(:docker_image) {
+    image = instance_double(Docker::Image)
+    allow(image).to receive(:id).and_return('c90d655b99b2')
+    allow(image).to receive(:tag).and_return(image)
+    allow(image).to receive(:json).and_return({'VirtualSize' => 123, 'Size' => 123})
+    image
+  }
+
+  it 'processes commands' do
+    expect(Docker::Image).to receive(:build_from_tar).and_return(docker_image)
+    subject.build(image)
+  end
+end

data/spec/phoebo/git_spec.rb

@@ -0,0 +1,35 @@
+require_relative '../spec_helper'
+
+describe Phoebo::Git do
+
+  subject { described_class }
+
+  context 'without credentials' do
+    let(:request) do
+      Phoebo::Request.new do
+        repo_url = 'ssh://somehost.tld/user/repo.git'
+        ssh_private_file = 'key'
+        ssh_public_file = 'key.pub'
+      end
+    end
+
+    it 'clones' do
+      expect(Rugged::Repository).to receive(:clone_at)
+      subject.clone(request, '/tmp/somepath')
+    end
+  end
+
+  context 'with SSH credentials' do
+    let(:request) do
+      Phoebo::Request.new do
+        repo_url = 'ssh://somehost.tld/user/repo.git'
+      end
+    end
+
+    it 'clones' do
+      expect(Rugged::Repository).to receive(:clone_at)
+      subject.clone(request, '/tmp/somepath')
+    end
+  end
+
+end

data/spec/phoebo/ping_spec.rb

@@ -0,0 +1,37 @@
+require_relative '../spec_helper'
+
+describe Phoebo::Ping do
+
+  subject { described_class }
+
+  let(:request) do
+    request = double(Phoebo::Request)
+    allow(request).to receive(:id).and_return('2e2996fe8420')
+    allow(request).to receive(:ping_url).and_return('http://domain.tld/api/notify')
+    request
+  end
+
+  let(:configs) do
+    tasks = [{
+      name: 'test',
+      image: 'someimage',
+      cmd: ['do_something', '--with', 'that']
+    }]
+
+    configs = [ config = double(Phoebo::Config) ]
+    allow(config).to receive(:tasks).and_return(tasks)
+    configs
+  end
+
+  let(:http_response) do
+    response = double
+    allow(response).to receive(:code).and_return(200)
+    response
+  end
+
+  it 'pings' do
+    allow(Net::HTTP).to receive(:start).and_return(http_response)
+    subject.send(request, configs)
+  end
+
+end

data/spec/phoebo/request_spec.rb

@@ -0,0 +1,141 @@
+require_relative '../spec_helper'
+
+describe Phoebo::Request do
+
+  subject { described_class.new }
+
+  context 'request validation' do
+    it 'defaults are valid' do
+      expect(subject.errors).to be_empty
+    end
+
+    # Unix like format is not accepted and should produce human-readable message
+    it 'returns error on invalid repo URL' do
+      subject.repo_url = '@host:a.git'
+      expect(subject.errors.select { |e| e.include?('Invalid repository URL.') }).not_to be_empty
+    end
+
+    # Non SSH repos not supported at the moment
+    it 'returns error when non SSH repo is requested' do
+      subject.repo_url = 'http://host/repo.git'
+      expect(subject.errors.select { |e| e.include?('Invalid repository URL.') }).not_to be_empty
+    end
+
+    it 'returns error on invalid ping URL' do
+      subject.ping_url = '@host:a.git'
+      expect(subject.errors.select { |e| e.include?('Invalid ping URL.') }).not_to be_empty
+    end
+
+    it 'valid repo url returns no errors' do
+      subject.repo_url = 'ssh://host/path/to/repo.git'
+      expect(subject.errors.select { |e| e.include?('Invalid repository URL.') }).to be_empty
+    end
+
+    it 'validates private SSH key if required' do
+      subject.ssh_public_file = 'secret.pub'
+      expect(subject.errors.select { |e| e.include?('private') && e.include?('SSH') }).not_to be_empty
+    end
+
+    it 'validates public SSH key  if required' do
+      subject.ssh_private_file = 'secret'
+      expect(subject.errors.select { |e| e.include?('public') && e.include?('SSH') }).not_to be_empty
+    end
+
+    it 'no error with both SSH keys valid' do
+      subject.repo_url = 'ssh://host/path/to/repo.git'
+      subject.ssh_private_file = 'secret'
+      subject.ssh_public_file = 'secret.pub'
+      expect(subject.errors.select { |e| e.include?('SSH') }).to be_empty
+    end
+
+    it 'enforces none or all docker parameters' do
+      subject.docker_user = 'user'
+      expect(subject.errors.select { |e| e.include?('Docker') }.size).to be 2
+      subject.docker_password = 'password'
+      expect(subject.errors.select { |e| e.include?('Docker') }.size).to be 1
+      subject.docker_email = 'email'
+      expect(subject.errors.select { |e| e.include?('Docker') }).to be_empty
+    end
+
+    it 'raises exception' do
+      subject.repo_url = '@host:a.git'
+      expect { subject.validate }.to raise_error(Phoebo::InvalidRequestError)
+    end
+  end
+
+  context 'loading from hash' do
+    let(:valid_hash) do
+      {
+        ssh_private_file: 'secret',
+        ssh_public_file: 'secret.pub'
+      }
+    end
+
+    it 'raises error on unknown argument' do
+      expect { subject.load_from_hash!({ a: 13 }) }.to raise_error(Phoebo::InvalidRequestError)
+    end
+
+    it 'applies arguments' do
+      expect(subject.load_from_hash!(valid_hash).is_a?(described_class)).to eq true
+      expect(subject.ssh_private_file).to be valid_hash[:ssh_private_file]
+      expect(subject.ssh_public_file).to be valid_hash[:ssh_public_file]
+    end
+  end
+
+  let(:json) do
+    <<-EOS
+    {
+      "repo_url": "ssh://somehost.tld/user/repo.git"
+    }
+    EOS
+  end
+
+  let(:malformed_json) do
+    <<-EOS
+    {
+      "repo_url
+    }
+    EOS
+  end
+
+  context 'loading from JSON' do
+    it 'raises error on malformed data' do
+      expect { subject.load_from_json!(malformed_json) }.to raise_error(Phoebo::InvalidRequestError)
+    end
+
+    it 'applies arguments' do
+      subject.load_from_json!(json)
+      expect(subject.repo_url).to eql('ssh://somehost.tld/user/repo.git')
+    end
+  end
+
+  context 'loading from file' do
+    it 'raises error if file does not exist' do
+      allow(File).to receive(:exist?).and_return(false)
+      expect { subject.load_from_file!('somefile.json') }.to raise_error(Phoebo::IOError)
+    end
+
+    it 'loads data' do
+      allow(File).to receive(:exist?).and_return(true)
+      allow(IO).to receive(:read).and_return(json)
+      expect(subject).to receive(:load_from_json!).with(json)
+      subject.load_from_file!('somefile.json')
+    end
+  end
+
+  # TODO: cover all possible states
+  context 'loading from url' do
+    let(:http_response) do
+      response = double
+      allow(response).to receive(:code).and_return(200)
+      allow(response).to receive(:body).and_return(json)
+      response
+    end
+
+    it 'loads data' do
+      allow(Net::HTTP).to receive(:start).and_return(http_response)
+      expect(subject).to receive(:load_from_json!).with(json)
+      subject.load_from_url!('http://test')
+    end
+  end
+end

data/spec/phoebo/worker_spec.rb

@@ -0,0 +1,30 @@
+require_relative '../spec_helper'
+
+describe Phoebo::Worker do
+
+  let(:path) { './somepath' }
+  let(:request) {
+    image = instance_double(Phoebo::Request)
+  }
+
+  let(:config) {
+    config = instance_double(Phoebo::Config)
+    allow(config).to receive(:images).and_return([])
+    config
+  }
+
+  subject { described_class.new(request) }
+
+  context 'Pheobofile' do
+    before(:each) do
+      allow(File).to receive(:exists?).and_return(true)
+      allow(Phoebo::Config).to receive(:new_from_file).and_return(config)
+    end
+
+    it 'processes directories' do
+      subject.process(path)
+    end
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -4,7 +4,10 @@ require 'bundler/setup'
 Bundler.setup
 
 require 'simplecov'
-SimpleCov.start
+
+SimpleCov.start do
+  add_filter "/spec/"
+end
 
 require 'phoebo'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phoebo
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Adam Staněk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-11 00:00:00.000000000 Z
+date: 2015-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -134,14 +134,25 @@ files:
 - lib/phoebo/docker/image_builder.rb
 - lib/phoebo/docker/image_pusher.rb
 - lib/phoebo/environment.rb
+- lib/phoebo/git.rb
+- lib/phoebo/ping.rb
+- lib/phoebo/request.rb
 - lib/phoebo/util.rb
 - lib/phoebo/util/temp_file_manager.rb
 - lib/phoebo/version.rb
+- lib/phoebo/worker.rb
 - phoebo.gemspec
 - spec/phoebo/application_spec.rb
+- spec/phoebo/config/image_spec.rb
+- spec/phoebo/config_spec.rb
 - spec/phoebo/console_spec.rb
+- spec/phoebo/docker/image_builder_spec.rb
 - spec/phoebo/environment_spec.rb
+- spec/phoebo/git_spec.rb
+- spec/phoebo/ping_spec.rb
+- spec/phoebo/request_spec.rb
 - spec/phoebo/util/temp_file_manager_spec.rb
+- spec/phoebo/worker_spec.rb
 - spec/spec_helper.rb
 homepage: https://gitlab.fit.cvut.cz/phoebo/phoebo
 licenses:
@@ -169,7 +180,14 @@ specification_version: 4
 summary: CI worker for creating Docker images
 test_files:
 - spec/phoebo/application_spec.rb
+- spec/phoebo/config/image_spec.rb
+- spec/phoebo/config_spec.rb
 - spec/phoebo/console_spec.rb
+- spec/phoebo/docker/image_builder_spec.rb
 - spec/phoebo/environment_spec.rb
+- spec/phoebo/git_spec.rb
+- spec/phoebo/ping_spec.rb
+- spec/phoebo/request_spec.rb
 - spec/phoebo/util/temp_file_manager_spec.rb
+- spec/phoebo/worker_spec.rb
 - spec/spec_helper.rb