kumo_dockercloud 1.0.0

data/spec/kumo_dockercloud/environment_config_spec.rb

@@ -0,0 +1,109 @@
+require 'kumo_dockercloud/environment_config'
+require 'kumo_dockercloud/docker_cloud_api'
+
+describe KumoDockerCloud::EnvironmentConfig do
+  let(:env_name) { 'test' }
+  let(:config_path) { File.join(__dir__, '../fixtures/config') }
+  subject(:instance) { described_class.new(app_name: 'application-stack-name', env_name: env_name, config_path: config_path) }
+
+  let(:docker_cloud_api) { instance_double('KumoDockerCloud::DockerCloudApi') }
+
+  describe '#get_binding' do
+    let(:services_for_stack) { [] }
+
+    # Ruby binding can only be tested by
+    # evaluating strings against the binding
+    subject { eval(string, instance.get_binding) }
+
+    describe '@env_name' do
+      let(:string) { '@env_name' }
+
+      it 'is taken from the given parameter' do
+        expect(subject).to eq env_name
+      end
+    end
+
+    describe '#plain_text_secrets' do
+      context 'with no encrypted secrets' do
+        let(:secrets_data) do
+          {
+            'testkey'  => 'someval',
+            'moretest' => 'otherval'
+          }
+        end
+
+        let(:string) { 'plain_text_secrets' }
+
+        it do
+          expect(subject).to eq secrets_data
+        end
+      end
+
+      context 'with some encrypted secrets' do
+        let(:env_name) { 'test_encrypted' }
+        let(:plain_value) { 'otherval' }
+
+        let(:kms) { double('KumoKi::KMS') }
+
+        let(:plain_data) do
+          {
+            'testkey' => 'someval',
+            'enctest' => plain_value
+          }
+        end
+
+        let(:string) { 'plain_text_secrets' }
+
+        before do
+          allow(KumoKi::KMS).to receive(:new).and_return(kms)
+          allow(kms).to receive(:decrypt).with('ZW5jcnlwdGVkIGJpbmFyeSBkYXRh').and_return(plain_value)
+        end
+
+        it do
+          expect(subject).to eq plain_data
+        end
+      end
+    end
+
+    context 'with API mocked' do
+      before do
+        allow(KumoDockerCloud::DockerCloudApi).to receive(:new).and_return docker_cloud_api
+        allow(docker_cloud_api).to receive(:services_by_stack_name).with("application-stack-name-#{env_name}").and_return(services_for_stack)
+      end
+
+      describe '#image_name' do
+        let(:string) { 'image_name' }
+
+        context 'when there is a service for the given stack' do
+          let(:image_name) { 'redbubble/application-stack-name:1234' }
+          let(:services_for_stack) { [ double(DockerCloud::Service, image_name: image_name) ] }
+
+          it 'uses the pre-exisiting image name' do
+            expect(subject).to eq image_name
+          end
+        end
+
+        context 'when there is no service for the given stack' do
+          let(:services_for_stack) { [] }
+
+          it { expect(subject).to eq 'redbubble/application-stack-name:master' }
+        end
+      end
+
+      describe '#image_tag' do
+        let(:services_for_stack) { [ double(DockerCloud::Service, image_name: image_name)] }
+
+        subject { instance.image_tag }
+
+        context "when the image name is 'redbubble/assete-wala:latest'" do
+          let(:image_name) { 'redbubble/application-stack-name:latest' }
+          it { expect(subject).to eq 'latest' }
+        end
+        context "when the image name is 'some-registry/mything:9999'" do
+          let(:image_name) { 'some-registry/mything:9999' }
+          it { expect(subject).to eq '9999' }
+        end
+      end
+    end
+  end
+end

data/spec/kumo_dockercloud/environment_spec.rb

@@ -0,0 +1,95 @@
+require 'kumo_dockercloud/environment'
+require 'kumo_dockercloud/environment_config'
+
+describe KumoDockerCloud::Environment do
+  let(:env_vars) { {app_name => {'KEY' => 'VALUE'}} }
+  let(:app_name) { 'application-stack-name' }
+  let(:config) { KumoDockerCloud::EnvironmentConfig.new(app_name: app_name, env_name: 'test', config_path: 'a path') }
+
+  let(:stack_file) {
+    {
+      'application-stack-name': {
+        image: 'a-thing',
+        environment: {
+          TEST_ENV: 'FAKE',
+          MORE: 'ANOTHER',
+          KEY: 'VALUE'
+        }
+      }
+    }
+  }
+
+  let(:stack_template_path) { File.join(__dir__, '../fixtures/stack.yml.erb') }
+
+  let(:params) { {name: 'test', env_vars: env_vars, app_name: app_name, config_path: 'a path', stack_template_path: stack_template_path} }
+
+  subject(:env) { described_class.new(params) }
+
+  before do
+    allow(KumoDockerCloud::EnvironmentConfig).to receive(:new).and_return(config)
+    allow(KumoDockerCloud::StackFile).to receive(:create_from_template).and_return(stack_file)
+  end
+
+  describe "#apply" do
+    subject { env.apply }
+
+    let(:full_stack_name) { "#{app_name}-test" }
+
+    before do
+      allow(config).to receive(:image_tag).and_return('latest')
+      allow(env).to receive(:evaluate_command).and_return app_name
+      allow(env).to receive(:run_command)
+      docker_cloud_api = double("DockerCloudApi", stack_by_name: {"#{full_stack_name}": 'stack stuff'})
+      allow(KumoDockerCloud::DockerCloudApi).to receive(:new).and_return docker_cloud_api
+      allow_any_instance_of(KumoDockerCloud::StateValidator).to receive(:wait_for_state)
+    end
+
+    it "writes a stack file" do
+      expect_any_instance_of(Tempfile).to receive(:write).with(stack_file.to_yaml)
+
+      subject
+    end
+
+    it 'runs the stack command' do
+      expect(env).to receive(:run_command).with(%r{^docker-cloud stack create -f .* -n #{full_stack_name}$})
+
+      subject
+    end
+
+    it 'runs the redeploy command' do
+      expect(env).to receive(:run_command).with("docker-cloud stack redeploy #{full_stack_name}")
+
+      subject
+    end
+
+    describe "waiting for running" do
+
+      let(:state_validator) { double(KumoDockerCloud::StateValidator, wait_for_state: nil) }
+
+      before do
+        allow(KumoDockerCloud::StateValidator).to receive(:new).exactly(3).times.and_return(state_validator)
+      end
+
+      it "makes sure it waits until it's running" do
+        expect(state_validator).to receive(:wait_for_state).with(anything, 120).exactly(3).times
+        subject
+      end
+
+      context "setting a different timeout value" do
+        let(:params) { {name: 'test', env_vars: env_vars, app_name: app_name, config_path: 'a path', stack_template_path: stack_template_path, timeout: 240} }
+
+        it "sends the timeout value to the StateValidator" do
+          expect(state_validator).to receive(:wait_for_state).with(anything, 240).exactly(3).times
+          subject
+        end
+      end
+
+    end
+
+    it 'uses the StackFile class' do
+      expect(KumoDockerCloud::StackFile).to receive(:create_from_template).with(File.read(stack_template_path), config, env_vars)
+
+      subject
+    end
+  end
+end

data/spec/kumo_dockercloud/stack_file_spec.rb

@@ -0,0 +1,168 @@
+require_relative '../../lib/kumo_dockercloud/environment_config'
+require_relative '../../lib/kumo_dockercloud/stack_file'
+
+describe KumoDockerCloud::StackFile do
+
+  let(:app_name) { 'application-stack-name' }
+  let(:config) { KumoDockerCloud::EnvironmentConfig.new(app_name: app_name, env_name: 'test', config_path: 'a path') }
+  let(:env_vars) { {app_name => {'KEY' => 'VALUE'}} }
+  let(:plain_text_secrets) do
+    {
+      'TEST_ENV' => 'FAKE',
+      'MORE' => 'ANOTHER'
+    }
+  end
+
+  before do
+    allow(KumoDockerCloud::EnvironmentConfig).to receive(:new).and_return(config)
+    allow(config).to receive(:plain_text_secrets).and_return(plain_text_secrets)
+  end
+
+  describe '.create_from_template' do
+    subject { described_class.create_from_template(stack_template, config, env_vars) }
+
+    let(:stack_template) do
+      <<-eos
+        application-stack-name:
+          image: a-thing
+      eos
+    end
+
+    it 'adds environment variables to stack config' do
+      expect(subject).to eq(app_name => {
+        'image' => 'a-thing',
+        'environment' => {
+          'TEST_ENV' => 'FAKE',
+          'MORE' => 'ANOTHER',
+          'KEY' => 'VALUE'
+        }
+      })
+    end
+
+    context 'with some existing environment' do
+      let(:stack_template) do
+        <<-eos
+          application-stack-name:
+            image: a-thing
+            environment:
+              TEST: thing
+        eos
+      end
+      it 'should add new secrets to the environment' do
+        expect(subject).to eq(app_name => {
+          'image' => 'a-thing',
+          'environment' => {
+            'TEST' => 'thing',
+            'TEST_ENV' => 'FAKE',
+            'MORE' => 'ANOTHER',
+            'KEY' => 'VALUE'
+          }
+        })
+      end
+    end
+
+    context 'without any existing environment' do
+      let(:stack_template) do
+        <<-eos
+          application-stack-name:
+            image: a-thing
+        eos
+      end
+      it 'should create the environment with secrets in it' do
+        expect(subject).to eq(app_name => {
+          'image' => 'a-thing',
+          'environment' => {
+            'TEST_ENV' => 'FAKE',
+            'MORE' => 'ANOTHER',
+            'KEY' => 'VALUE'
+          }
+        })
+      end
+    end
+
+    context 'no app name env var' do
+      let(:env_vars) do
+        { }
+      end
+
+      let(:stack_template) do
+        <<-eos
+          application-stack-name:
+            image: a-thing
+        eos
+      end
+
+      it 'should create the environment with secrets in it' do
+        expect(subject).to eq(app_name => {
+          'image' => 'a-thing',
+          'environment' => {
+            'TEST_ENV' => 'FAKE',
+            'MORE' => 'ANOTHER'
+          }
+        })
+      end
+    end
+
+    context 'with other services' do
+      let(:env_vars) do
+        {
+          app_name => {'KEY' => 'VALUE'},
+          "another_service" => {'KEY2' => 'VALUE2'}
+        }
+      end
+
+      let(:stack_template) do
+        <<-eos
+        application-stack-name:
+          image: a-thing
+        another_service:
+          image: another
+          environment:
+            KEY: thing
+            KEY2: OLD_VALUE
+        third_service:
+          image: third
+        eos
+      end
+
+      let(:expected_stack_file) do
+        {
+          app_name => {
+            'image' => 'a-thing',
+            'environment' => {
+              'TEST_ENV' => 'FAKE',
+              'MORE' => 'ANOTHER',
+              'KEY' => 'VALUE'
+            }},
+          'another_service' => {
+            'image' => 'another',
+            'environment' => {
+              'KEY' => 'thing',
+              'KEY2' => 'VALUE2',
+            }
+          },
+          'third_service' => {
+            'image' => 'third'
+          }
+        }
+      end
+
+      it 'should create the environment with variables for other services' do
+        expect(subject).to eq(expected_stack_file)
+      end
+
+      context 'the key is a symbol' do
+        let(:env_vars) do
+          {
+            app_name => {'KEY' => 'VALUE'},
+            another_service: {'KEY2' => 'VALUE2'}
+          }
+        end
+
+        it 'handles symbols the same way as strings' do
+          expect(subject).to eq(expected_stack_file)
+        end
+      end
+    end
+  end
+end

data/spec/kumo_dockercloud/stack_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe KumoDockerCloud::Stack do
+  describe '#deploy' do
+    subject { described_class.new(app_name, environment_name).deploy(app_version) }
+
+    let(:app_name) { 'test_app' }
+    let(:environment_name) { 'environment' }
+    let(:app_version) { '1' }
+    let(:uuid) { 'foo' }
+    let(:client) { instance_double(DockerCloud::Client, stacks: stacks, services: service_api) }
+    let(:service_api) { instance_double(DockerCloud::ServiceAPI) }
+    let(:stacks) { double('stacks', all: [stack]) }
+    let(:stack) { instance_double(DockerCloud::Stack, name: "#{app_name}-#{environment_name}", services: [service]) }
+    let(:service) { instance_double(DockerCloud::Service, uuid: uuid, containers: []) }
+    let(:state_validator) { instance_double(KumoDockerCloud::StateValidator, wait_for_state: nil) }
+
+    before do
+      allow(::DockerCloud::Client).to receive(:new).and_return(client)
+      allow(KumoDockerCloud::StateValidator).to receive(:new).and_return(state_validator)
+    end
+
+    it 'uses the service api to update the image and redeploy' do
+      expect(service_api).to receive(:update).with(uuid, {image: "redbubble/#{app_name}:#{app_version}"})
+      expect(service_api).to receive(:redeploy).with(uuid)
+      subject
+    end
+  end
+end

data/spec/kumo_dockercloud/state_validator_spec.rb

@@ -0,0 +1,29 @@
+require 'rspec'
+require 'spec_helper'
+
+describe KumoDockerCloud::StateValidator do
+  describe '#wait_for_state' do
+    subject { state_validator.wait_for_state('done', 1) }
+    let(:state_validator) { described_class.new(state_provider) }
+    let(:state_provider) { double('state_provider', call: service) }
+    let(:service) { { state: service_state, name: 'service name' } }
+
+    context 'the right state' do
+      let(:service_state) { 'done' }
+
+      it 'succeeds immediately if the state is right' do
+        subject
+      end
+    end
+
+    context 'the wrong state' do
+      let(:service_state) { 'not quite done' }
+
+      it 'fails after the timeout value is reached' do
+        expect { subject }.to raise_error(Timeout::Error)
+      end
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'kumo_dockercloud'

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification
+name: kumo_dockercloud
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Redbubble
+- Delivery
+- Engineering
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httpi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: docker_cloud
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: kumo_ki
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.22'
+description: Use to create Redbubble environments on the DockerCloud platform
+email:
+- delivery-engineering@redbubble.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".buildkite/pipeline.yml"
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- kumo_dockercloud.gemspec
+- lib/kumo_dockercloud.rb
+- lib/kumo_dockercloud/deployment.rb
+- lib/kumo_dockercloud/docker_cloud_api.rb
+- lib/kumo_dockercloud/environment.rb
+- lib/kumo_dockercloud/environment_config.rb
+- lib/kumo_dockercloud/stack.rb
+- lib/kumo_dockercloud/stack_file.rb
+- lib/kumo_dockercloud/state_validator.rb
+- lib/kumo_dockercloud/version.rb
+- script/build.sh
+- script/release-gem
+- script/unit_test.sh
+- spec/fixtures/config/test.yml
+- spec/fixtures/config/test_encrypted_secrets.yml
+- spec/fixtures/config/test_secrets.yml
+- spec/fixtures/stack.yml.erb
+- spec/kumo_docker_cloud_spec.rb
+- spec/kumo_dockercloud/docker_cloud_api_spec.rb
+- spec/kumo_dockercloud/environment_config_spec.rb
+- spec/kumo_dockercloud/environment_spec.rb
+- spec/kumo_dockercloud/stack_file_spec.rb
+- spec/kumo_dockercloud/stack_spec.rb
+- spec/kumo_dockercloud/state_validator_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- mit
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Use to create Redbubble environments on the DockerCloud platform
+test_files:
+- spec/fixtures/config/test.yml
+- spec/fixtures/config/test_encrypted_secrets.yml
+- spec/fixtures/config/test_secrets.yml
+- spec/fixtures/stack.yml.erb
+- spec/kumo_docker_cloud_spec.rb
+- spec/kumo_dockercloud/docker_cloud_api_spec.rb
+- spec/kumo_dockercloud/environment_config_spec.rb
+- spec/kumo_dockercloud/environment_spec.rb
+- spec/kumo_dockercloud/stack_file_spec.rb
+- spec/kumo_dockercloud/stack_spec.rb
+- spec/kumo_dockercloud/state_validator_spec.rb
+- spec/spec_helper.rb