kuby-core 0.7.2 → 0.10.0

data/lib/kuby/version.rb

@@ -1,3 +1,3 @@
 module Kuby
-  VERSION = '0.7.2'
+  VERSION = '0.10.0'
 end

data/spec/docker/metadata_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+require 'timecop'
+
+describe Kuby::Docker::Metadata do
+  let(:metadata) { definition.environment.docker.metadata }
+
+  describe '#image_url' do
+    subject { metadata.image_url }
+
+    it { is_expected.to eq(docker_image_url) }
+
+    context 'when no image URL is configured' do
+      let(:docker_image_url) { nil }
+      it { is_expected.to eq(definition.app_name) }
+    end
+  end
+
+  describe '#image_host' do
+    subject { metadata.image_host }
+
+    it { is_expected.to eq(described_class::DEFAULT_REGISTRY_HOST) }
+
+    context 'when the image URL contains an explicit host' do
+      let(:docker_image_url) { 'registry.foo.com/foo/testapp' }
+
+      it { is_expected.to eq('https://registry.foo.com') }
+    end
+
+    context 'when the image URL contains an explicit host with scheme' do
+      let(:docker_image_url) { 'http://registry.foo.com/foo/testapp' }
+
+      it { is_expected.to eq('http://registry.foo.com') }
+    end
+  end
+
+  describe '#image_repo' do
+    subject { metadata.image_repo }
+
+    it { is_expected.to eq('foo/testapp') }
+
+    context 'when the image URL contains an explicit host' do
+      let(:docker_image_url) { 'registry.foo.com/foo/testapp' }
+
+      it { is_expected.to eq('foo/testapp') }
+    end
+  end
+
+  describe '#image_hostname' do
+    subject { metadata.image_hostname }
+
+    it { is_expected.to eq('www.docker.com') }
+
+    context 'when the image URL contains an explicit host' do
+      let(:docker_image_url) { 'registry.foo.com/foo/testapp' }
+
+      it { is_expected.to eq('registry.foo.com') }
+    end
+  end
+
+  describe '#tags' do
+    subject { metadata.tags }
+
+    it 'specifies the current timestamp tag and the default tag' do
+      Timecop.freeze do
+        expect(subject).to eq([
+          Time.now.strftime('%Y%m%d%H%M%S'),
+          Kuby::Docker::Metadata::LATEST_TAG
+        ])
+      end
+    end
+  end
+
+  describe '#distro' do
+    subject { metadata.distro }
+
+    it { is_expected.to eq(Kuby::Docker::Metadata::DEFAULT_DISTRO) }
+
+    context 'with a distro set manually' do
+      before { metadata.distro = :alpine }
+
+      it { is_expected.to eq(:alpine) }
+    end
+  end
+end

data/spec/docker/spec_spec.rb

@@ -0,0 +1,266 @@
+require 'spec_helper'
+require 'timecop'
+
+describe Kuby::Docker::Spec do
+  let(:spec) { definition.environment.docker }
+
+  describe '#base_image' do
+    subject { spec.to_dockerfile.to_s }
+
+    it 'uses the default base image for Debian' do
+      expect(subject).to include("FROM ruby:#{RUBY_VERSION}\n")
+    end
+
+    context 'when the distro is set to Alpine' do
+      before { spec.distro(:alpine) }
+
+      it 'uses the Alpine base image' do
+        expect(subject).to include("FROM ruby:#{RUBY_VERSION}-alpine\n")
+      end
+    end
+
+    context 'when the base image is set to something custom' do
+      before { spec.base_image('foo/bar') }
+
+      it 'uses the base image as given' do
+        expect(subject).to include("FROM foo/bar\n")
+      end
+    end
+  end
+
+  describe '#working_dir' do
+    let(:default_working_dir) do
+      Kuby::Docker::SetupPhase::DEFAULT_WORKING_DIR
+    end
+
+    subject { spec.to_dockerfile.to_s }
+
+    it 'uses the default working dir' do
+      expect(subject).to(
+        include("WORKDIR #{default_working_dir}\n")
+      )
+    end
+
+    context 'when the working dir is set to something custom' do
+      before { spec.working_dir('/foo/bar') }
+
+      it 'uses the working dir as given' do
+        expect(subject).to include("WORKDIR /foo/bar\n")
+      end
+    end
+  end
+
+  describe '#rails_env' do
+    subject { spec.to_dockerfile.to_s }
+
+    it 'uses the name of the current Kuby environment' do
+      expect(subject).to include("ENV RAILS_ENV=#{spec.environment.name}\n")
+      expect(subject).to include("ENV KUBY_ENV=#{spec.environment.name}\n")
+    end
+
+    context 'when the environment is set to something custom' do
+      before { spec.rails_env('foobar') }
+
+      it 'uses the environment as given' do
+        expect(subject).to include("ENV RAILS_ENV=foobar\n")
+      end
+
+      it "doesn't change the Kuby env" do
+        expect(subject).to include("ENV KUBY_ENV=#{spec.environment.name}\n")
+      end
+    end
+  end
+
+  describe '#bundler_version' do
+    subject { spec.to_dockerfile.to_s }
+
+    it 'installs the current bundler version' do
+      expect(subject).to(
+        include("RUN gem install bundler -v #{Bundler::VERSION}\n")
+      )
+    end
+
+    context 'when the bundler version is set to something custom' do
+      before { spec.bundler_version('1.17.3') }
+
+      it 'installs the given version' do
+        expect(subject).to include("RUN gem install bundler -v 1.17.3\n")
+      end
+    end
+  end
+
+  describe '#gemfile' do
+    subject { spec.to_dockerfile.to_s }
+
+    it 'uses the default Gemfile' do
+      expect(subject).to include("COPY Gemfile .\n")
+      expect(subject).to include("COPY Gemfile.lock .\n")
+      expect(subject).to match(/RUN bundle install .* --gemfile Gemfile/)
+    end
+
+    context 'when the gemfile path is set to something custom' do
+      before { spec.gemfile('foo/bar/Gemfile') }
+
+      it 'uses the given gemfile' do
+        expect(subject).to include("COPY foo/bar/Gemfile .\n")
+        expect(subject).to include("COPY foo/bar/Gemfile.lock .\n")
+        expect(subject).to match(/RUN bundle install .* --gemfile foo\/bar\/Gemfile/)
+      end
+    end
+  end
+
+  describe '#package' do
+    subject { spec.to_dockerfile.to_s }
+
+    it 'installs the given package' do
+      # configured in spec_helper.rb
+      spec.package(:fake_package)
+
+      expect(subject).to match(/apt-get install .* fake_package/m)
+    end
+  end
+
+  describe '#files' do
+    subject { spec.to_dockerfile.to_s }
+
+    it 'copies the current directory contents by default' do
+      expect(subject).to include("COPY ./ .\n")
+    end
+
+    context 'when given a custom path to copy' do
+      before { spec.files('./foo/bar') }
+
+      it 'copies the given paths only' do
+        expect(subject).to include("COPY ./foo/bar .\n")
+      end
+    end
+  end
+
+  describe '#port' do
+    let(:default_port) do
+      Kuby::Docker::WebserverPhase::DEFAULT_PORT
+    end
+
+    subject { spec.to_dockerfile.to_s }
+
+    it 'exposes the default port' do
+      expect(subject).to include("EXPOSE #{default_port}\n")
+    end
+
+    context 'when given a custom port' do
+      before { spec.port(5555) }
+
+      it 'exposes the given port' do
+        expect(subject).to include("EXPOSE 5555\n")
+      end
+    end
+  end
+
+  describe '#tag' do
+    let(:tag) { make_ts_tag(Time.now) }
+
+    subject { spec.tag }
+
+    context 'with no local or remote tags' do
+      it 'raises an error' do
+        expect { subject }.to raise_error(Kuby::Docker::MissingTagError)
+      end
+    end
+
+    context 'with an available remote tag' do
+      before { docker_remote_client.tags << tag }
+
+      it { is_expected.to eq(tag) }
+    end
+
+    context 'with an available local tag' do
+      before do
+        docker_cli.build(
+          dockerfile: nil,
+          image_url: docker_image_url,
+          tags: [tag]
+        )
+      end
+
+      it { is_expected.to eq(tag) }
+    end
+
+    context 'with multiple remote tags' do
+      let(:time) { Time.now }
+
+      before do
+        docker_remote_client.tags +=
+          [time - 5, time + 10, time - 10, time + 15].map do |t|
+            make_ts_tag(t)
+          end
+      end
+
+      it { is_expected.to eq(make_ts_tag(time + 15)) }
+    end
+
+    context 'with multiple local and remote tags' do
+      let(:time) { Time.now }
+
+      before do
+        docker_remote_client.tags +=
+          [time - 5, time + 10, time - 10, time + 15].map do |t|
+            make_ts_tag(t)
+          end
+
+        docker_cli.build(
+          dockerfile: nil,
+          image_url: docker_image_url,
+          tags: [time - 3, time + 6, time - 6, time + 18].map do |t|
+            make_ts_tag(t)
+          end
+        )
+      end
+
+      it { is_expected.to eq(make_ts_tag(time + 18)) }
+    end
+  end
+
+  describe '#previous_tag' do
+    let(:time) { Time.now }
+    let(:current_tag) { make_ts_tag(time) }
+
+    before do
+      docker_remote_client.tags << current_tag
+      docker_cli.build(
+        dockerfile: nil,
+        image_url: docker_image_url,
+        tags: [current_tag]
+      )
+    end
+
+    subject { spec.previous_tag(current_tag) }
+
+    context 'with no previous local or remote tag' do
+      it 'raises an error' do
+        expect { subject }.to raise_error(Kuby::Docker::MissingTagError)
+      end
+    end
+
+    context 'with an available previous remote tag' do
+      let(:previous_tag) { make_ts_tag(time - 5) }
+
+      before { docker_remote_client.tags << previous_tag }
+
+      it { is_expected.to eq(previous_tag) }
+    end
+
+    context 'with an available previous local tag' do
+      let(:previous_tag) { make_ts_tag(time - 5) }
+
+      before do
+        docker_cli.build(
+        dockerfile: nil,
+        image_url: docker_image_url,
+        tags: [previous_tag]
+        )
+      end
+
+      it { is_expected.to eq(previous_tag) }
+    end
+  end
+end

data/spec/docker/timestamp_tag_spec.rb

@@ -1,11 +1,61 @@
 require "spec_helper"
 
 describe Kuby::Docker::TimestampTag do
-  context ".try_parse" do
-    it "returns a new timestamp tag" do
-      tag = described_class.try_parse("20200810165134")
+  context '.try_parse' do
+    let(:tag_str) { '20200810165134' }
 
-      expect(tag).to be_kind_of(described_class)
+    it 'creates a new timestamp tag' do
+      tag = described_class.try_parse(tag_str)
+      expect(tag).to be_a(described_class)
+    end
+
+    it 'correctly parses the timestamp contained in the tag' do
+      time = described_class.try_parse(tag_str).time
+      expect([time.year, time.month, time.day, time.hour, time.min, time.sec]).to(
+        eq([2020, 8, 10, 16, 51, 34])
+      )
+    end
+
+    context 'with an invalid tag' do
+      let(:tag_str) { 'abc123' }
+
+      it 'returns nil' do
+        expect(described_class.try_parse(tag_str)).to eq(nil)
+      end
+    end
+  end
+
+  context '#to_s' do
+    it 'serializes the tag as a timestamp' do
+      tag = described_class.new(Time.new(2020, 8, 10, 16, 51, 34))
+      expect(tag.to_s).to eq('20200810165134')
+    end
+  end
+
+  context 'comparison' do
+    it 'ensures tags can be compared by their timestamp values' do
+      seed_time = Time.now
+      times = [seed_time, seed_time + 5, seed_time + 10, seed_time + 15].shuffle
+      tags = times.map { |t| described_class.new(t) }
+      expect(tags.sort.map(&:time)).to eq(times.sort)
+    end
+  end
+
+  context 'equality' do
+    it 'ensures tags with equal times are considered equal' do
+      time = Time.now
+      tag1 = described_class.new(time)
+      tag2 = described_class.new(time)
+      expect(tag1).to eq(tag2)
+      expect(tag1.hash).to eq(tag2.hash)
+    end
+
+    it 'ensures tags with inequal times are not considered equal' do
+      time = Time.now
+      tag1 = described_class.new(time)
+      tag2 = described_class.new(time + 5)
+      expect(tag1).to_not eq(tag2)
+      expect(tag1.hash).to_not eq(tag2.hash)
     end
   end
 end

data/spec/dummy/Gemfile

@@ -0,0 +1,54 @@
+source 'https://rubygems.org'
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+ruby '2.5.8'
+
+# Bundle edge Rails instead: gem 'rails', github: 'rails/rails'
+gem 'rails', '~> 6.0.3', '>= 6.0.3.2'
+# Use sqlite3 as the database for Active Record
+gem 'sqlite3', '~> 1.4'
+# Use Puma as the app server
+gem 'puma', '~> 4.1'
+# Use SCSS for stylesheets
+gem 'sass-rails', '>= 6'
+# Transpile app-like JavaScript. Read more: https://github.com/rails/webpacker
+gem 'webpacker', '~> 4.0'
+# Turbolinks makes navigating your web application faster. Read more: https://github.com/turbolinks/turbolinks
+gem 'turbolinks', '~> 5'
+# Build JSON APIs with ease. Read more: https://github.com/rails/jbuilder
+gem 'jbuilder', '~> 2.7'
+# Use Redis adapter to run Action Cable in production
+# gem 'redis', '~> 4.0'
+# Use Active Model has_secure_password
+# gem 'bcrypt', '~> 3.1.7'
+
+# Use Active Storage variant
+# gem 'image_processing', '~> 1.2'
+
+# Reduces boot times through caching; required in config/boot.rb
+gem 'bootsnap', '>= 1.4.2', require: false
+
+group :development, :test do
+  # Call 'byebug' anywhere in the code to stop execution and get a debugger console
+  gem 'byebug', platforms: [:mri, :mingw, :x64_mingw]
+end
+
+group :development do
+  # Access an interactive console on exception pages or by calling 'console' anywhere in the code.
+  gem 'web-console', '>= 3.3.0'
+  gem 'listen', '~> 3.2'
+  # Spring speeds up development by keeping your application running in the background. Read more: https://github.com/rails/spring
+  gem 'spring'
+  gem 'spring-watcher-listen', '~> 2.0.0'
+end
+
+group :test do
+  # Adds support for Capybara system testing and selenium driver
+  gem 'capybara', '>= 2.15'
+  gem 'selenium-webdriver'
+  # Easy installation and use of web drivers to run system tests with browsers
+  gem 'webdrivers'
+end
+
+# Windows does not include zoneinfo files, so bundle the tzinfo-data gem
+gem 'tzinfo-data', platforms: [:mingw, :mswin, :x64_mingw, :jruby]