docker-dev 0.0.1

data/lib/docker.rb

@@ -0,0 +1,124 @@
+require_relative 'docker/rake'
+require_relative 'docker/helpers'
+require_relative 'docker/interactive'
+require_relative 'docker/equality'
+require_relative 'docker/path'
+require_relative 'docker/id'
+
+require_relative 'docker/image'
+require_relative 'docker/repository'
+require_relative 'docker/tag'
+require_relative 'docker/container'
+require_relative 'docker/inspect'
+
+require_relative 'docker/rails'
+require_relative 'docker/rails/server'
+require_relative 'docker/rails/console'
+require_relative 'docker/ruby'
+require_relative 'docker/postgres'
+
+module Docker
+
+  extend Helpers
+  extend self 
+
+  USER_NAME    = 'jphager2'
+
+  def ID(input)
+    case input
+    when String
+      Id.create(input)
+    when ->(obj){obj.respond_to?(:id)}
+      Id.create(input.id)
+    end
+  end
+
+  def PATH(input)
+    case input
+    when String
+      Path.new(input)
+    when Path
+      input
+    end
+  end
+
+  # delegate to Image
+  def build(app_path, image_tag = nil)
+    path = PATH(app_path)
+    image_tag ||= path.name
+    Image.build(path, image_tag)
+  end
+
+  # delegate to Container
+  def run(image, options = "", command = "")
+    Container.run(image.to_s, options, command)
+  end
+
+  def images(response_type = :image)
+    images = `docker images`.split("\n")[1..-1]
+    images.map do |image|
+      id    = image.match(/^[^\s]+\s+[^\s]+\s+([^\s]+)/)[1]
+      repo  = image.match(/^[a-zA-Z0-9\/\-_\.<>]+/)[0]
+      tag   = image.match(/^[^\s]+\s+([^\s]+)/)[1]
+      case response_type
+      when :repository
+        Repository.new(id, repo)
+      when :tag
+        Tag.new(id, repo, tag)
+      when :image
+        Image.new(id)
+      end
+    end
+  end
+
+  def inspekt(id)
+    inspekt = Inspect.new(id.to_s)
+    inspekt.inspekt ? inspekt : NullInspect.new
+  end
+
+  def find_container(options = {})
+    containers.find do |container|
+      found = true 
+      options.each do |option,value| 
+        found = false unless container.send(option) == value 
+      end
+      found
+    end
+  end
+
+  def find_containers(options = {})
+    klass = options.delete(:klass)
+    kontainers = containers
+    kontainers.map! { |container| klass.load_from(container) } if klass
+    kontainers.select { |container|
+      found = true 
+      options.each do |option, value|
+        found = false unless container.send(option) === value
+      end
+      found
+    }.compact 
+  end
+
+  def containers(mode = :all)
+    containers = case mode
+    when :all
+      all_containers
+    when :stopped
+      all_containers.select { |container| container =~ /Exited/ }
+    when :paused
+      all_containers.select { |container| container =~ /(Paused)/ }
+    when :running
+      `docker ps`.split("\n")[1..-1]
+        .select { |container| container !~ /(Paused)/}
+    else
+      raise ArgumentError, "Bad Argument: #{mode}" 
+    end
+    containers.map do |container| 
+      Container.new(container[0..11]).to_klass 
+    end 
+  end
+
+  def all_containers
+    `docker ps -a`.split("\n")[1..-1]
+  end
+end

data/rakefile

@@ -0,0 +1,6 @@
+load 'helpers.rake'
+
+desc 'Run all docker tests'
+task :tests do
+  Dir['test/docker*_test.rb'].each { |file| puts `ruby #{file}` }
+end

data/test/app_cleanup_test.rb

@@ -0,0 +1,27 @@
+require_relative 'test_helper'
+
+class CleanupTest < Minitest::Test
+
+  def setup
+    Docker::App.run(TEST_APP_PATH)
+    Docker::App.cleanup!
+    @running = `docker ps`
+    @stopped = `docker ps -s`
+  end
+
+  def test_app_is_stopped
+    refute_match /rails-server-app/, @running 
+  end
+
+  def test_postgres_is_stopped
+    refute_match /\sdb\s/, @running
+  end
+
+  def test_app_is_removed
+    refute_match /rails-server-app/, @stopped 
+  end
+
+  def test_postgres_is_removed
+    refute_match /\sdb\s/, @stopped
+  end
+end

data/test/app_run_test.rb

@@ -0,0 +1,38 @@
+require_relative 'test_helper'
+require 'stringio'
+
+class AppRunTest < Minitest::Test
+
+  def test_can_run_a_rails_app
+    assert Docker::App.run(TEST_APP_PATH), 
+      'Docker::App.run should return something truthy'
+  end
+
+  def test_a_running_app_prints_out_the_rails_app_ip
+    skip
+    out, $stdout = $stdout, StringIO.new
+    Docker::App.run(TEST_APP_PATH)
+    out.rewind
+    assert_match /\s\d+\.\d+\.\d+\.\d+\.:\d+\s/, out.read
+    $stdout = out
+  end
+
+  def test_a_running_app_results_in_a_running_docker_container
+    Docker::App.run(TEST_APP_PATH)
+    containers = `docker ps`
+    assert_match /rails-server-app/, containers
+  end
+
+  def test_a_running_app_starts_a_postgres_container
+    Docker::App.run(TEST_APP_PATH)
+    containers = `docker ps`
+    assert_match /postgres/, containers
+    assert_match /\sdb/, containers
+  end
+
+  def teardown
+    TestHelper.remove_containers
+    `docker run --rm -v /home/john/projects/docker/rails/app:/usr/src/app jphager2/rails-app chmod -R a+rw /usr/src/app`
+    `rm -rf #{TEST_APP_PATH}/tmp/*`
+  end
+end

data/test/app_stop_test.rb

@@ -0,0 +1,34 @@
+require_relative 'test_helper'
+
+
+class AppStopTest < Minitest::Test
+
+  def setup
+    Docker::App.run(TEST_APP_PATH)
+    Docker::App.stop(TEST_APP_PATH)
+    @running = `docker ps`
+    @stopped = `docker ps -s`
+  end
+
+  def test_app_is_stopped
+    refute_match /rails-server-app/, @running
+  end
+
+  def test_app_is_removed
+    refute_match /rails-server-app/, @stopped
+  end
+
+  def test_postgres_is_still_running
+    assert_match /\spostgres/, @running
+  end
+
+  def test_tmp_directory_is_empty
+    assert_empty Dir["#{TEST_APP_PATH}/tmp/*"]
+  end
+
+  def teardown
+    TestHelper.remove_containers
+  end 
+end
+
+

data/test/docker_build_test.rb

@@ -0,0 +1,28 @@
+require_relative 'test_helper'
+
+class BuildTest < MiniTest::Unit::TestCase
+
+  def self.before_suite
+  end
+
+  def self.after_suite
+  end
+
+  def setup
+    if `docker images` =~ /#{Docker::USER_NAME}\/app/
+      `docker rmi #{Docker::USER_NAME}/app`   
+    end
+  end
+  
+  def test_can_build_a_rails_app
+    assert_kind_of Docker::Image, Docker.build(TEST_APP_PATH) 
+  end
+
+  def test_building_app_results_in_a_docker_image
+    Docker.build(TEST_APP_PATH)
+    images = `docker images` 
+    assert_match(/#{Docker::USER_NAME}\/app/, images)
+  end
+end
+
+

data/test/docker_container_test.rb

@@ -0,0 +1,115 @@
+require_relative 'test_helper'
+
+class ContainerTest < MiniTest::Unit::TestCase
+  
+  def self.before_suite 
+    @@name = 'posty-post'
+    @@container = TestHelper.setup_posty(@@name)
+  end 
+
+  def self.after_suite
+    TestHelper.teardown_posty(@@name)
+  end
+
+  def test_a_container_that_exits_has_an_id
+    container = Docker.run('ubuntu:14.04',nil,'/bin/bash')
+    assert_match /[a-z0-9]+/, container.id
+    refute_match /[^a-z0-9]/, container.id
+    container.remove!
+  end
+
+  def test_a_container_run_with_rm_flag_that_exits_returns_removed
+    container = Docker.run('ubuntu:14.04', '--rm', '/bin/bash')
+    assert_equal "REMOVED", container.id
+  end
+
+  def test_a_container_that_echos_to_stdout_has_an_id
+    container = Docker.run('ubuntu:14.04',nil,'echo "hello"')
+    assert_match /[a-z0-9]+/, container.id
+    refute_match /[^a-z0-9]/, container.id
+    container.remove!
+  end
+
+  def test_container_has_an_id
+    assert_match /[a-z0-9]+/, @@container.id
+    refute_match /[^a-z0-9]/, @@container.id
+    assert_equal 12, @@container.id.length
+  end
+
+  def test_stopped_container_is_stopped
+    @@container.stop!
+    assert @@container.stopped?
+    `docker start #{@@name}`
+  end
+
+  def test_container_is_up
+    assert @@container.up?
+  end
+
+  def test_container_is_not_up_when_stopped
+    @@container.stop!
+    refute @@container.up?
+    `docker start #{@@name}`
+  end
+
+  def test_container_is_not_up_when_paused
+    @@container.pause!
+    refute @@container.up?
+    `docker unpause #{@@name}`
+  end
+
+  def test_container_is_paused
+    @@container.pause!
+    assert @@container.paused?
+    `docker unpause #{@@name}`
+  end
+
+  def test_stopped_container_starts
+    @@container.stop!
+    @@container.start!
+    assert @@container.up?
+  end
+
+  def test_running_container_restarts
+    @@container.restart!
+    assert @@container.up?
+  end
+
+  def test_container_unpauses
+    @@container.pause!
+    @@container.unpause!
+    assert @@container.up?
+  end
+
+  def test_docker_inspect_returns_inspect_object
+    assert_instance_of Docker::Inspect, @@container.inspekt
+  end
+
+  def test_container_remove_removes_the_container
+    shorty = TestHelper.setup_posty('shorty')
+    shorty.remove!
+    refute Docker.containers.any? { |container| container == shorty }
+  end
+
+  def test_container_can_add_removal_instructions
+    shorty = TestHelper.setup_posty('shorty')
+    shorty.add_removal_instructions do |container|
+      ENV["SHORTY_IP"] = container.ip
+    end
+    assert shorty.removal_instructions, 
+      'Shorty should have removal instructions'
+    shorty.remove!
+    assert ENV["SHORTY_IP"], 'ENV["SHORTY_IP"] should by truthy'
+  end
+
+  def test_removed_container_has_methods_disabled
+    shorty = TestHelper.setup_posty('shorty')
+    shorty.remove!
+    [:stop!, :start!, :restart!, :pause!, :unpause!, :remove!]
+      .each do |method|
+        assert_raises(NoMethodError) do 
+          shorty.send(method)
+        end
+      end
+  end
+end

data/test/docker_image_test.rb

@@ -0,0 +1,26 @@
+require_relative 'test_helper'
+
+class ImageTest < MiniTest::Unit::TestCase
+
+  def self.before_suite
+    @@images = Docker.images
+  end
+  
+  def self.after_suite
+  end
+
+  def test_image_has_id
+    @@images.each do |image|
+      refute_match /[\W\.\s\/\|:]/, image.id
+      refute_match /[A-Z]/, image.id
+    end
+  end
+
+  def test_image_can_be_removed
+    image = Docker.build(TEST_APP_PATH)
+    id = image.id
+    image.remove!
+    images = `docker images`
+    refute_match /#{id}/, images
+  end
+end

data/test/docker_inspect_test.rb

@@ -0,0 +1,39 @@
+require_relative 'test_helper'
+
+class InspectTest < MiniTest::Unit::TestCase
+  
+  def self.before_suite
+    @@name = 'posty-post'
+    @@container = TestHelper.setup_posty(@@name)
+    @@inspect = Docker.inspekt(@@container.id)
+  end
+
+  def self.after_suite
+    TestHelper.teardown_posty(@@name)
+  end
+
+  def test_inspect_gives_container_ip
+    assert_match /\d+\.\d+\.\d\.\d/, @@inspect.ip_address 
+  end
+
+  def test_inspect_gives_ports
+    ports = @@inspect.ports
+    assert_instance_of Hash, ports 
+    refute_empty ports
+  end
+
+  def test_inspect_gives_name
+    assert_match /#{@@name}/, @@inspect.name
+  end
+
+  def test_inspect_gives_state
+    assert @@inspect.state["Running"]
+  end
+
+  def test_inspect_gives_state_of_stopped_container
+    @@container.stop!
+    inspect = Docker.inspekt(@@container.id)
+    refute inspect.state["Running"]
+    @@container.start!
+  end
+end

data/test/docker_postgres_test.rb

@@ -0,0 +1,22 @@
+require_relative 'test_helper'
+
+class PostgresTest < MiniTest::Unit::TestCase
+
+  def self.before_suite
+    @@posty = Docker::Postgres.run('posty')
+  end
+
+  def self.after_suite
+    @@posty.remove!
+  end
+
+  def test_can_run_a_postgres_container
+    assert @@posty.up?
+  end
+
+  def test_gets_current_postgres_contianer_if_one_exists
+    posty2 = Docker::Postgres.run('posty')
+    assert_equal @@posty, posty2
+    # Do not need to remove posty2 here because posty2 == posty
+  end
+end

data/test/docker_rails_test.rb

@@ -0,0 +1,40 @@
+require_relative 'test_helper'
+require 'stringio'
+
+class RailsTest < MiniTest::Unit::TestCase
+  def self.before_suite
+    Docker::Rails.build(TEST_APP_PATH)
+    @@app_name = TEST_APP_PATH.match(/(\/(\w+))?$/)[2]
+    @@server_name = "rails-server-#{@@app_name}"
+    @@container = Docker::Rails.run_server(TEST_APP_PATH)
+  end
+
+  def self.after_suite
+    # @@container.remove!
+  end
+
+  def test_docker_can_build_a_rails_app_image
+    assert_match /jphager2\/rails-#{@@app_name}/, `docker images`
+  end
+
+  def test_docker_can_start_a_rails_app_container
+    assert_equal @@server_name, @@container.name 
+    assert_includes Docker.containers(:running), @@container 
+  end
+
+  def test_docker_run_rails_app_starts_postgres 
+    assert Docker.containers(:running).any? { |c| c.name == 'db' }
+  end
+
+  def test_docker_can_start_a_rails_console_session
+    TestHelper.assert_match_stderr(/rails-console-app/, self) do
+      Docker::Rails.run_console(TEST_APP_PATH)
+    end 
+  end
+
+  def test_docker_can_run_a_command_in_a_rails_app
+    container = Docker::Rails.run(TEST_APP_PATH, "", "ls")
+    assert_match /Gemfile/, container.logs
+    container.remove!
+  end
+end

data/test/docker_ruby_test.rb

@@ -0,0 +1,24 @@
+require_relative 'test_helper'
+require 'stringio'
+
+class RubyTest < MiniTest::Unit::TestCase
+  def self.before_suite
+    Docker::Ruby.build(RUBY_APP_PATH)
+    @@app_name = RUBY_APP_PATH.match(/(\/(\w+))?$/)[2]
+    @@container_name = "ruby-irb-#{@@app_name}"
+  end
+
+  def self.after_suite
+    #@@container.remove!
+  end
+
+  def test_docker_can_build_a_ruby_app_image
+    assert_match /jphager2\/ruby-#{@@app_name}/, `docker images`
+  end
+
+  def test_docker_can_start_a_ruby_app_container
+    TestHelper.assert_match_stderr(/ruby-irb-#{@@app_name}/, self) do
+      Docker::Ruby.run_irb(RUBY_APP_PATH)
+    end
+  end
+end

data/test/docker_test.rb

@@ -0,0 +1,119 @@
+require_relative 'test_helper'
+
+class ImagesTest < MiniTest::Unit::TestCase
+  def self.before_suite
+  end
+
+  def self.after_suite
+  end
+
+  def test_images_returns_a_collection_of_images
+    Docker.images.each do |image|
+      assert_instance_of Docker::Image, image 
+    end
+  end
+
+  def test_images_returns_a_collection_of_tags
+    Docker.images(:tag).each do |tag|
+      assert_instance_of Docker::Tag, tag 
+    end
+  end
+
+  def test_images_returns_a_collection_of_repos
+    Docker.images(:repository).each do |repo|
+      assert_instance_of Docker::Repository, repo 
+    end
+  end
+end
+
+class ContainersTest < MiniTest::Unit::TestCase
+
+  def self.before_suite
+    TestHelper.setup_postgres_containers
+    @@rails_server = Docker::Rails.run_server(TEST_APP_PATH)
+    #@@rails_console = Docker::Rails.run_console(TEST_APP_PATH)
+    #@@ruby_irb      = Docker::Ruby.run_irb(RUBY_APP_PATH)
+    @@postgres     = Docker::Postgres.run('posty-5')
+    @@gem_server   = Docker.run('ruby:2.1.2', '-d', 'gem server')
+
+    @@all     = `docker ps -a`
+    @@running = `docker ps`
+    @@stopped = `docker ps -a | grep "Exited"`
+    @@paused  = `docker ps | grep "(Paused)"`
+  end
+
+  def self.after_suite
+    TestHelper.teardown_postgres_containers
+    @@rails_server.remove! 
+    #@@rails_console.remove!
+    #@@ruby_irb.remove!   
+    @@postgres.remove!   
+    @@gem_server.remove!
+  end
+
+  def test_containers_is_not_empty
+    refute_empty Docker.containers
+  end
+
+  def test_containers_returns_a_collection_of_containers
+    Docker.containers.each do |container|
+      assert_kind_of Docker::Container, container 
+    end
+  end
+
+  def test_containers_returns_a_collection_of_all_containers
+    Docker.containers.each do |container|
+      assert_match /#{container.id}/, @@all 
+    end
+  end
+
+  def test_containers_with_option_running_returns_only_running
+    Docker.containers(:running).each do |container|
+      assert_match /#{container.id}/, @@running
+      refute_match /#{container.id}/, @@stopped
+    end
+  end
+
+  def test_containers_with_option_stopped_returns_stopped_containers
+    Docker.containers(:stopped).each do |container|
+      refute_match /#{container.id}/, @@running
+      assert_match /#{container.id}/, @@stopped
+    end    
+  end
+
+  def test_containers_with_option_paused_returns_paused_containers
+    Docker.containers(:paused).each do |container|
+      assert_match /#{container.id}/, @@paused
+    end
+  end
+
+  def test_running_not_equal_to_paused
+    refute_equal Docker.containers(:paused),
+      Docker.containers(:running)
+  end
+
+  def test_containers_accepts_the_all_argument
+    assert Docker.containers(:all), 
+      'Docker.containers(:all) should return something truthy'
+  end
+
+  def test_containers_raises_exception_for_other_arguments
+    words = %w{ the red fox jumped over the redhat } 
+    assert_raises(ArgumentError) do 
+      Docker.containers(words.take.to_sym)
+    end
+  end
+
+  def test_can_get_a_collection_of_containers_based_on_class
+    klasses = [
+      Docker::Rails::Server, Docker::Postgres, Docker::Container
+    ]
+    klasses.each do |klass|
+      servers = Docker.find_containers(klass: klass)
+      refute_empty servers
+      servers.each do |server| 
+        assert_instance_of klass, server
+      end 
+    end
+  end
+end