gordon 0.0.11 → 0.0.12

data/spec/gordon/cli_spec.rb

@@ -2,10 +2,70 @@ require 'spec_helper'
 
 describe Gordon::CLI do
   describe 'running a recipe' do
-    pending
+    it 'cooks a recipe based on options' do
+      options = instance_double Gordon::Options
+      expect(options).to receive(:app_source=).with(Dir.pwd)
+      expect(options).to receive(:output_dir=).with(Dir.pwd)
+      expect(Gordon::Options).to receive(:new).and_return(options)
+
+      recipe = instance_double Gordon::Recipe
+      expect(Gordon::Recipe).to receive(:new).with(options).and_return(recipe)
+
+      cooker = instance_double Gordon::Cooker
+      expect(cooker).to receive(:cook)
+      expect(Gordon::Cooker).to receive(:new).with(recipe).and_return(cooker)
+
+      described_class.run
+    end
   end
 
-  describe 'getting a option parser' do
-    pending
+  describe 'parsing options' do
+    let(:options) { instance_double Gordon::Options }
+
+    let(:options_map) do
+      [
+        [ %w(-N --app-name),          "gordon" ],
+        [ %w(-D --app-description),   "a packager" ],
+        [ %w(-G --app-homepage),      "https://github.com/salizzar/gordon" ],
+        [ %w(-V --app-version),       Gordon::VERSION ],
+        [ %w(-S --app-source),        "." ],
+        [ %w(-T --app-type),          "ruby_web_app" ],
+        [ %w(-X --runtime-name),      "ruby" ],
+        [ %w(-R --runtime-version),   "2.2.0" ],
+        [ %w(-H --http-server-type),  "nginx" ],
+        [ %w(-W --web-server-type),   "unicorn" ],
+        [ %w(-I --init-type),         "systemd" ],
+        [ %w(-P --package-type),      "rpm" ],
+        [ %w(-O --output-dir),        "pkg" ],
+        [ %w(-d --debug),             true ],
+      ]
+    end
+
+    let(:abbreviated) do
+      options_map.map { |item| [ item.first.first, item.last ] }
+    end
+
+    let(:detailed) do
+      options_map.map { |item| [ item.first.last, item.last ] }
+    end
+
+    before :each do
+      options_map.each do |item|
+        attr = item.first.last.gsub(/^--/, '').tr('-', '_')
+
+        expect(options).to receive("#{attr}=").with(item.last)
+      end
+    end
+
+    it 'maps abbreviated options' do
+      parser = described_class.create_option_parser(options)
+      parser.parse!(abbreviated.flatten)
+    end
+
+    it 'maps detailed options' do
+      parser = described_class.create_option_parser(options)
+      parser.parse!(detailed.flatten)
+    end
   end
 end
+

data/spec/gordon/cooker_spec.rb

@@ -1,13 +1,90 @@
 require 'spec_helper'
 
 describe Gordon::Cooker do
+  let(:options) do
+    attrs = {
+      app_type:         "web",
+      app_name:         "gordon",
+      app_description:  "a packager",
+      app_homepage:     "https://github.com/salizzar/gordon",
+      app_version:      Gordon::VERSION,
+      app_source:       ".",
+      runtime_name:     "ruby",
+      runtime_version:  "2.2.0",
+      http_server_type: "nginx",
+      web_server_type:  "unicorn",
+      init_type:        "systemd",
+      package_type:     "rpm",
+      output_dir:       "pkg",
+      debug:            true,
+    }
+
+    instance_double(Gordon::Options, attrs)
+  end
+
+  let(:recipe) do
+    instance_double(Gordon::Recipe, options: options, application_template_path: '/a/path')
+  end
+
+  let(:env_vars) do
+    Gordon::EnvVars.from_cook(options)
+  end
+
+  subject { described_class.new(recipe) }
+
+  before :each do
+    expect(subject).to receive(:debug)
+  end
+
   describe 'cooking a package' do
-    describe 'cleans fpm-cookery working directory' do
-      pending
+    it 'cleans fpm-cookery working directory' do
+      clean_command = %W{
+        #{env_vars.join " "}
+        fpm-cook
+        --debug
+        --target
+        #{options.package_type}
+        --pkg-dir
+        #{File.expand_path(options.output_dir)}
+        --cache-dir
+        #{File.expand_path(described_class::FPM_COOKERY_CACHE_DIR)}
+        --tmp-root
+        #{File.expand_path(described_class::FPM_COOKERY_BUILD_DIR)}
+        --no-deps
+        clean
+        #{recipe.application_template_path}
+      }
+
+      expect(Gordon::Process).to receive(:run).with(clean_command.join " ")
+
+      expect(subject).to receive(:package)
+
+      subject.cook
     end
 
-    describe 'packages calling fpm-cookery' do
-      pending
+    it 'packages calling fpm-cookery' do
+      package_command = %W{
+        #{env_vars.join " "}
+        fpm-cook
+        --debug
+        --target
+        #{options.package_type}
+        --pkg-dir
+        #{File.expand_path(options.output_dir)}
+        --cache-dir
+        #{File.expand_path(described_class::FPM_COOKERY_CACHE_DIR)}
+        --tmp-root
+        #{File.expand_path(described_class::FPM_COOKERY_BUILD_DIR)}
+        --no-deps
+        package
+        #{recipe.application_template_path}
+      }
+
+      expect(Gordon::Process).to receive(:run).with(package_command.join " ")
+
+      expect(subject).to receive(:clean)
+
+      subject.cook
     end
   end
 end

data/spec/gordon/cookery/application_user_spec.rb

@@ -1,11 +1,68 @@
 require 'spec_helper'
 
 describe Gordon::Cookery::ApplicationUser do
+  subject do
+    class MyApplicationUser
+      include Gordon::Cookery::ApplicationUser
+    end.new
+  end
+
+  let(:app_name)              { "gordon" }
+  let(:app_description)       { "a packager" }
+  let(:build_path)            { 'tmp-build' }
+  let(:preinstall_file_name)  { '.gordon-before-install' }
+  let(:postinstall_file_name) { '.gordon-after-install' }
+  let(:preinstall_path)       { File.join(build_path, preinstall_file_name) }
+  let(:postinstall_path)      { File.join(build_path, preinstall_file_name) }
+  let(:file)                  { instance_double File }
+  let(:env_vars)              { instance_double Gordon::EnvVars, app_name: app_name, app_description: app_description }
+  let(:home_path)             { '/usr/share/nginx/html' }
+
   describe 'creating user and group' do
-    pending
+    it 'installs script to create user on system' do
+      expect(subject).to receive(:builddir).with(preinstall_file_name).and_return(preinstall_path)
+
+      expect(File).to receive(:open).with(preinstall_path, 'w', 0755).and_yield(file)
+      allow(file).to receive(:path).and_return(preinstall_path)
+
+      bash = <<-__BASH
+#!/bin/sh
+
+set -e
+
+/usr/bin/getent group  #{env_vars.app_name} >/dev/null || /usr/sbin/groupadd --system #{env_vars.app_name};
+/usr/bin/getent passwd #{env_vars.app_name} >/dev/null || /usr/sbin/useradd  --system --gid #{env_vars.app_name} --home-dir #{home_path} --shell /sbin/nologin --comment "#{env_vars.app_description}" #{env_vars.app_name} >/dev/null || :;
+      __BASH
+
+      expect(file).to receive(:write).with(bash)
+
+      expect(subject.class).to receive(:pre_install).with(File.expand_path(file.path))
+
+      subject.create_user_and_group(env_vars, home_path)
+    end
   end
 
   describe 'setting user permissions' do
-    pending
+    it 'install script to recursively own all files from home path' do
+      expect(subject).to receive(:builddir).with(postinstall_file_name).and_return(postinstall_path)
+
+      expect(File).to receive(:open).with(postinstall_path, 'w', 0755).and_yield(file)
+      allow(file).to receive(:path).and_return(postinstall_path)
+
+      bash = <<-__BASH
+#!/bin/sh
+
+set -e
+
+/usr/bin/chown -R #{env_vars.app_name}:#{env_vars.app_name} #{home_path}
+      __BASH
+
+      expect(file).to receive(:write).with(bash)
+
+      expect(subject.class).to receive(:post_install).with(File.expand_path(file.path))
+
+      subject.setup_user_permissions(env_vars, home_path)
+    end
   end
 end
+

data/spec/gordon/cookery/common_spec.rb

@@ -1,16 +1,83 @@
 require 'spec_helper'
 
 describe Gordon::Cookery::Common do
+  subject do
+    class MyCommonExample
+      include Gordon::Cookery::Common
+    end.new
+  end
+
   describe 'getting skeleton path from type' do
-    pending
+    let(:env_vars)  { instance_double Gordon::EnvVars, app_name: 'gordon' }
+    let(:skeleton)  { instance_double 'Gordon::Skeleton::Types::Anything', get_default_path: '/a/path' }
+    let(:type)      { :anything }
+
+    it 'responds from class' do
+      expect(subject.class).to respond_to(:get_skeleton_path_from_type)
+    end
+
+    context 'returning based on app name' do
+      before :each do
+        expect(Gordon::Skeleton::Factory).to receive(:create).with(type).and_return(skeleton)
+      end
+
+      it 'returns skeleton path without app name' do
+        expect(skeleton).to receive(:requires_app_name?).and_return(false)
+        expect(skeleton).to receive(:path).with('').and_return('/a/path')
+
+        result = subject.get_skeleton_path_from_type(env_vars, :anything)
+
+        expect(result).to eq('/a/path')
+      end
+
+      it 'returns skeleton path with app name' do
+        expect(skeleton).to receive(:requires_app_name?).and_return(true)
+        expect(skeleton).to receive(:path).with('gordon').and_return('/a/path/gordon')
+
+        result = subject.get_skeleton_path_from_type(env_vars, type)
+
+        expect(result).to eq('/a/path/gordon')
+      end
+    end
   end
 
   describe 'getting all files with blacklist' do
-    pending
-  end
+    it 'returns all files except that are blacklisted on default map plus custom' do
+      files = %w{
+        .
+        ..
+        .bundle
+        .git
+        .gitignore
+        .pki
+        Procfile
+        Vagrantfile
+        app
+        config
+        cruise-output
+        db
+        lib
+        log
+        public
+        spec
+        tmp
+      }
+
+      expected = %w{
+        .bundle
+        Procfile
+        app
+        config
+        db
+        lib
+        public
+      }
+
+      expect(Dir).to receive(:[]).with('{*,.*}').and_return(files)
 
-  describe 'creating skeleton type' do
-    pending
+      result = subject.all_files_except_blacklisted(%w(log spec tmp))
+      expect(result).to eq(expected)
+    end
   end
 end
 

data/spec/gordon/cookery/dependency_resolver_spec.rb

@@ -1,8 +1,65 @@
 require 'spec_helper'
 
 describe Gordon::Cookery::DependencyResolver do
+  subject do
+    class MyDependencyResolver
+      include Gordon::Cookery::DependencyResolver
+    end.new
+  end
+
+  let(:env_vars) { instance_double Gordon::EnvVars }
+
   describe 'resolving dependencies' do
-    pending
+    context 'given a ruby app' do
+      it 'returns all dependencies for web' do
+        expect(env_vars).to receive(:app_type).and_return("ruby_web_app")
+        expect(env_vars).to receive(:runtime_version).and_return("2.2.0")
+        allow(env_vars).to receive(:http_server_type).and_return("apache")
+        expect(env_vars).to receive(:web_server_type).and_return("")
+        allow(env_vars).to receive(:init_type).and_return("systemd")
+
+        expected = [
+          "ruby = 2.2.0",
+          "httpd",
+          "systemd",
+        ]
+
+        expect(subject.resolve_dependencies(env_vars)).to eq(expected)
+      end
+
+      it 'returns all dependencies for standalone' do
+        expect(env_vars).to receive(:app_type).and_return("ruby_standalone_app")
+        expect(env_vars).to receive(:runtime_version).and_return("2.1.5")
+        expect(env_vars).to receive(:http_server_type).and_return("")
+        expect(env_vars).to receive(:web_server_type).and_return("")
+        allow(env_vars).to receive(:init_type).and_return("systemd")
+
+        expected = [
+          "ruby = 2.1.5",
+          "systemd",
+        ]
+
+        expect(subject.resolve_dependencies(env_vars)).to eq(expected)
+      end
+    end
+
+    context 'given a java standalone app' do
+      it 'returns all dependencies for web' do
+        expect(env_vars).to receive(:app_type).and_return("java_web_app")
+        allow(env_vars).to receive(:http_server_type).and_return("apache")
+        expect(env_vars).to receive(:runtime_version).and_return("1.7.0_60")
+        allow(env_vars).to receive(:web_server_type).and_return("tomcat")
+        expect(env_vars).to receive(:init_type).and_return("")
+
+        expected = [
+          "jre1.7.0_60",
+          "httpd",
+          "tomcat",
+        ]
+
+        expect(subject.resolve_dependencies(env_vars)).to eq(expected)
+      end
+    end
   end
 end
 

data/spec/gordon/cookery/http_server_spec.rb

@@ -1,8 +1,33 @@
 require 'spec_helper'
 
 describe Gordon::Cookery::HttpServer do
+  subject do
+    class MyHttpServer
+      include Gordon::Cookery::HttpServer
+    end.new
+  end
+
+  let(:app_name)          { "gordon" }
+  let(:http_server_type)  { :apache }
+  let(:env_vars)          { double Gordon::EnvVars, app_name: app_name, http_server_type: http_server_type }
+  let(:skeleton)          { Gordon::Skeleton::Types::Apache.new }
+  let(:all_files)         { %w(index.php pimp_my_system.php) }
+  let(:blacklist)         { %w(.git) }
+
+  before :each do
+    expect(Gordon::Skeleton::Types::Apache).to receive(:new).and_return(skeleton)
+  end
+
   describe 'installing files' do
-    pending
+    it 'install files based on http server path' do
+      expect(subject).to receive(:all_files_except_blacklisted).with(blacklist).and_return(all_files)
+
+      installer = double 'a path helper'
+      expect(subject).to receive(:root).with(skeleton.path).and_return(installer)
+      expect(installer).to receive(:install).with(all_files)
+
+      subject.install_http_server_files(env_vars, blacklist)
+    end
   end
 end
 

data/spec/gordon/cookery/init_spec.rb

@@ -1,11 +1,61 @@
 require 'spec_helper'
 
 describe Gordon::Cookery::Init do
+  subject do
+    class MyInit
+      include Gordon::Cookery::Init
+    end.new
+  end
+
+  let(:app_name)    { "gordon" }
+  let(:init_type)   { :systemd }
+  let(:build_path)  { '/tmp/gordon/tmp-build/systemd' }
+  let(:skeleton)    { Gordon::Skeleton::Types::Systemd.new }
+  let(:env_vars)    { instance_double Gordon::EnvVars, app_name: app_name, init_type: init_type }
+
+  before :each do
+    expect(subject).to receive(:builddir).with(env_vars.init_type).and_return(build_path)
+
+    expect(Gordon::Skeleton::Types::Systemd).to receive(:new).and_return(skeleton)
+  end
+
   describe 'creating init files' do
-    pending
+    it 'creates init calling foreman' do
+      command = %W{
+        foreman
+        export
+        --procfile
+        Procfile
+        --root
+        #{skeleton.path}
+        --app
+        #{env_vars.app_name}
+        --user
+        #{env_vars.app_name}
+        #{env_vars.init_type}
+        #{build_path}
+      }
+
+      expect(subject).to receive(:safesystem).with(command.join " ")
+
+      subject.create_init(env_vars, init_type)
+    end
   end
 
   describe 'installing init files' do
-    pending
+    it 'installs all generated files' do
+      files = %w(app.target app.service app-web-1.service).map do |file|
+        File.join(build_path, file)
+      end
+
+      expect(Dir).to receive(:[]).with("#{build_path}/*").and_return(files)
+
+      installer = double 'a path helper'
+      expect(subject).to receive(:root).with(skeleton.path).and_return(installer)
+      expect(installer).to receive(:install).with(files)
+
+      subject.install_init(env_vars)
+    end
   end
 end
+

data/spec/gordon/cookery/java/common_spec.rb

@@ -1,8 +1,12 @@
 require 'spec_helper'
 
 describe Gordon::Cookery::Java::Common do
-  describe 'default blacklist files' do
-    pending
+  describe 'default blacklist' do
+    it 'maps common files' do
+      expected = %w()
+
+      expect(described_class::JAVA_BLACKLIST_FILES).to eq(expected)
+    end
   end
 end
 

data/spec/gordon/cookery/java/web_app_spec.rb

@@ -1,8 +1,40 @@
 require 'spec_helper'
 
 describe Gordon::Cookery::Java::WebApp do
+  subject do
+    class MyJavaWebApp
+      include Gordon::Cookery::Java::WebApp
+    end.new
+  end
+
+  let(:env_vars)              { instance_double Gordon::EnvVars }
+  let(:workdir_path)          { '/var/lib/tomcat/webapps/myapp' }
+  let(:build_path)            { 'tmp-build' }
+  let(:preinstall_file_name)  { '.gordon-before-install' }
+  let(:preinstall_path)       { File.join(build_path, preinstall_file_name) }
+  let(:file)                  { instance_double File }
+
   describe 'cleaning web app workdir before install package' do
-    pending
+    it 'removes old application folder' do
+      expect(subject).to receive(:builddir).with(preinstall_file_name).and_return(preinstall_path)
+
+      expect(File).to receive(:open).with(preinstall_path, 'w', 0755).and_yield(file)
+      allow(file).to receive(:path).and_return(preinstall_path)
+
+      bash = <<-__BASH
+#!/bin/sh
+
+set -e
+
+/usr/bin/rm -rf #{workdir_path}
+      __BASH
+
+      expect(file).to receive(:write).with(bash)
+
+      expect(subject.class).to receive(:pre_install).with(File.expand_path(file.path))
+
+      subject.clean_java_web_workdir(env_vars, workdir_path)
+    end
   end
 end
 

data/spec/gordon/cookery/ruby/common_spec.rb

@@ -1,8 +1,12 @@
 require 'spec_helper'
 
 describe Gordon::Cookery::Ruby::Common do
-  describe 'vendorizing gems' do
-    pending
+  describe 'default blacklist' do
+    it 'maps common files' do
+      expected = %w(.rspec coverage log spec tmp)
+
+      expect(described_class::RUBY_BLACKLIST_FILES).to eq(expected)
+    end
   end
 end
 

data/spec/gordon/cookery/standalone_spec.rb

@@ -1,8 +1,32 @@
 require 'spec_helper'
 
 describe Gordon::Cookery::Standalone do
+  subject do
+    class MyStandalone
+      include Gordon::Cookery::Standalone
+    end.new
+  end
+
+  let(:app_name)  { "gordon" }
+  let(:env_vars)  { instance_double Gordon::EnvVars, app_name: app_name }
+  let(:skeleton)  { Gordon::Skeleton::Types::Misc.new }
+  let(:all_files) { %w(.bundle app config lib .ruby-version .ruby-gemset) }
+  let(:blacklist) { %w(.git) }
+
+  before :each do
+    expect(Gordon::Skeleton::Types::Misc).to receive(:new).and_return(skeleton)
+  end
+
   describe 'installing files' do
-    pending
+    it 'install all files based on misc skeleton' do
+      expect(subject).to receive(:all_files_except_blacklisted).with(blacklist).and_return(all_files)
+
+      installer = double 'a path helper'
+      expect(subject).to receive(:root).with(skeleton.path(app_name)).and_return(installer)
+      expect(installer).to receive(:install).with(all_files)
+
+      subject.install_standalone_files(env_vars, blacklist)
+    end
   end
 end
 

data/spec/gordon/cookery/web_server_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Gordon::Cookery::WebServer do
+  subject do
+    class MyWebServer
+      include Gordon::Cookery::WebServer
+    end.new
+  end
+
+  let(:app_name)        { "gordon" }
+  let(:web_server_type) { :tomcat }
+  let(:env_vars)        { double Gordon::EnvVars, app_name: app_name, web_server_type: web_server_type }
+  let(:skeleton)        { Gordon::Skeleton::Types::Tomcat.new }
+  let(:all_files)       { %w(gordon.war) }
+  let(:blacklist)       { %w(gordon.class) }
+
+  before :each do
+    expect(Gordon::Skeleton::Types::Tomcat).to receive(:new).and_return(skeleton)
+  end
+
+  describe 'installing web server files' do
+    it 'install files based on web server path' do
+      expect(subject).to receive(:all_files_except_blacklisted).with(blacklist).and_return(all_files)
+
+      installer = double 'a path helper'
+      expect(subject).to receive(:root).with(skeleton.path).and_return(installer)
+      expect(installer).to receive(:install).with(all_files)
+
+      subject.install_web_server_files(env_vars, blacklist)
+    end
+  end
+end
+

data/spec/gordon/env_vars_spec.rb

@@ -3,12 +3,13 @@ require 'spec_helper'
 describe Gordon::EnvVars do
   let(:attributes) do
     {
-      app_type:         :ruby_web_app,
-      app_name:         :xirubiru,
-      app_desc:         "a nice description",
-      app_repo:         "http://some.github.repo",
+      app_type:         "web",
+      app_name:         "xirubiru",
+      app_description:  "a nice description",
+      app_homepage:     "http://some.github.repo",
       app_version:      "2.0.0",
-      app_source_dir:   ".",
+      app_source:       ".",
+      runtime_name:     "ruby",
       runtime_version:  "2.2.0",
       http_server_type: "nginx",
       web_server_type:  "tomcat",
@@ -23,10 +24,11 @@ describe Gordon::EnvVars do
       expected = [
         "GORDON_APP_TYPE='#{options.app_type}'",
         "GORDON_APP_NAME='#{options.app_name}'",
-        "GORDON_APP_DESC='#{options.app_desc}'",
-        "GORDON_APP_REPO='#{options.app_repo}'",
+        "GORDON_APP_DESCRIPTION='#{options.app_description}'",
+        "GORDON_APP_HOMEPAGE='#{options.app_homepage}'",
         "GORDON_APP_VERSION='#{options.app_version}'",
-        "GORDON_APP_SOURCE_DIR='#{File.expand_path(options.app_source_dir)}'",
+        "GORDON_APP_SOURCE='#{File.expand_path(options.app_source)}'",
+        "GORDON_RUNTIME_NAME='#{options.runtime_name}'",
         "GORDON_RUNTIME_VERSION='#{options.runtime_version}'",
         "GORDON_HTTP_SERVER_TYPE='#{options.http_server_type}'",
         "GORDON_WEB_SERVER_TYPE='#{options.web_server_type}'",
@@ -42,10 +44,11 @@ describe Gordon::EnvVars do
       env = {
         'GORDON_APP_TYPE'         => options.app_type,
         'GORDON_APP_NAME'         => options.app_name,
-        'GORDON_APP_DESC'         => options.app_desc,
-        'GORDON_APP_REPO'         => options.app_repo,
+        'GORDON_APP_DESCRIPTION'  => options.app_description,
+        'GORDON_APP_HOMEPAGE'     => options.app_homepage,
         'GORDON_APP_VERSION'      => options.app_version,
-        'GORDON_APP_SOURCE_DIR'   => options.app_source_dir,
+        'GORDON_APP_SOURCE'       => options.app_source,
+        'GORDON_RUNTIME_NAME'     => options.runtime_name,
         'GORDON_RUNTIME_VERSION'  => options.runtime_version,
         'GORDON_HTTP_SERVER_TYPE' => options.http_server_type,
         'GORDON_WEB_SERVER_TYPE'  => options.web_server_type,