kontena-cli 1.4.0.pre6 → 1.4.0.pre7

data/spec/kontena/cli/stacks/remove_command_spec.rb

@@ -6,12 +6,14 @@ describe Kontena::Cli::Stacks::RemoveCommand do
 
   describe '#execute' do
     it 'sends remove command to master' do
+      allow(subject).to receive(:fetch_stack).and_return({})
       allow(subject).to receive(:wait_stack_removal)
       expect(client).to receive(:delete).with('stacks/test-grid/test-stack')
       subject.run(['--force', 'test-stack'])
     end
 
     it 'waits until service is removed' do
+      allow(subject).to receive(:fetch_stack).and_return({})
       allow(client).to receive(:delete).with('stacks/test-grid/test-stack')
       expect(client).to receive(:get).with('stacks/test-grid/test-stack')
         .and_raise(Kontena::Errors::StandardError.new(404, 'Not Found'))
@@ -19,6 +21,7 @@ describe Kontena::Cli::Stacks::RemoveCommand do
     end
 
     it 'raises exception on server error' do
+      allow(subject).to receive(:fetch_stack).and_return({})
       expect(client).to receive(:delete).with('stacks/test-grid/test-stack')
       expect(client).to receive(:get).with('stacks/test-grid/test-stack')
         .and_raise(Kontena::Errors::StandardError.new(500, 'internal error'))
@@ -26,5 +29,41 @@ describe Kontena::Cli::Stacks::RemoveCommand do
         subject.run(['--force', 'test-stack'])
       }.to exit_with_error
     end
+
+    describe 'with stack dependencies' do
+      context 'when stack has a parent' do
+        let(:stack_response_with_parent) do
+          { 'parent' => { 'name' => 'foofoo' } }
+        end
+
+        it 'warns' do
+          expect(client).to receive(:get).with('stacks/test-grid/test-stack').and_return(
+            stack_response_with_parent
+          )
+          expect(subject).to receive(:confirm_command).and_raise "foo"
+          expect{subject.run(['test-stack'])}.to exit_with_error.and output(/depends on/).to_stdout
+        end
+      end
+
+      context 'when stack has children' do
+        let(:stack_response_with_children) do
+          { 'children' => [ { 'name' => 'foofoo' }, { 'name' => 'foobar' } ] }
+        end
+
+        it 'removes the children' do
+          allow(subject).to receive(:wait_stack_removal)
+
+          expect(client).to receive(:get).with('stacks/test-grid/test-stack').and_return(
+            stack_response_with_children
+          )
+
+          expect(Kontena).to receive(:run!).with(['stack', 'remove', '--force', 'foofoo'])
+          expect(Kontena).to receive(:run!).with(['stack', 'remove', '--force', 'foobar'])
+
+          expect(subject).to receive(:remove_stack).with('test-stack')
+          expect{subject.run(['--force', 'test-stack'])}.not_to exit_with_error
+        end
+      end
+    end
   end
 end

data/spec/kontena/cli/stacks/show_command_spec.rb

@@ -9,5 +9,21 @@ describe Kontena::Cli::Stacks::ShowCommand do
       expect(client).to receive(:get).with('stacks/test-grid/test-stack').and_return(spy())
       subject.run(['test-stack'])
     end
+
+    context '--values option' do
+      let(:stack_response) do
+        {
+          'name' => 'stack-a',
+          'stack' => 'foo/stack-a',
+          'services' => [],
+          'variables' => { 'foo' => 'bar' }
+        }
+      end
+
+      it 'outputs a yaml of the stack variables and values' do
+        expect(client).to receive(:get).with('stacks/test-grid/test-stack').and_return(stack_response)
+        expect{subject.run(['--values', 'test-stack'])}.to output(/^foo: bar$/).to_stdout
+      end
+    end
   end
 end

data/spec/kontena/cli/stacks/stack_name_spec.rb

@@ -0,0 +1,21 @@
+require 'kontena/cli/stacks/stack_name'
+
+describe Kontena::Cli::Stacks::StackName do
+  it 'can parse a stack string' do
+    expect(described_class.new('user/stack').to_s).to eq 'user/stack'
+    expect(described_class.new('user/stack:0.1.0').to_s).to eq 'user/stack:0.1.0'
+    expect(described_class.new('user/stack', '0.1.0').to_s).to eq 'user/stack:0.1.0'
+  end
+
+  it 'can take a hash' do
+    expect(described_class.new(user: 'foo', stack: 'stack', version: '0.1.0').to_s).to eq 'foo/stack:0.1.0'
+  end
+
+  it 'has accessors' do
+    result = described_class.new('user/stack:0.1.0')
+    expect(result.stack_name).to eq 'user/stack'
+    expect(result.user).to eq 'user'
+    expect(result.stack).to eq 'stack'
+    expect(result.version).to eq '0.1.0'
+  end
+end

data/spec/kontena/cli/stacks/upgrade_command_spec.rb

@@ -1,108 +1,125 @@
 require "kontena/cli/stacks/upgrade_command"
+require 'json'
 
 describe Kontena::Cli::Stacks::UpgradeCommand do
 
   include ClientHelpers
   include RequirementsHelper
+  include FixturesHelpers
 
   mock_current_master
 
-  describe '#execute' do
+  before(:each) do
+    ENV['STACK'] = nil
+  end
 
-    let(:stack) do
-      {
-        'name' => 'stack-a',
-        'stack' => 'foo/stack-a',
-        'services' => []
-      }
-    end
+  describe '#execute' do
 
-    let(:stack_with_different_stack_name) do
+    let(:stack_expectation) do
       {
-        'name' => 'stack-a',
-        'stack' => 'foo/stack-z',
-        'services' => []
+        'name' => 'stack-name',
+        'stack' => 'user/stackname',
+        'version' => '0.1.1',
+        'registry' => 'file://',
+        'services' => array_including(hash_including('name', 'image')),
+        'variables' => {},
+        'volumes' => [],
+        'dependencies' => nil,
+        'source' => /stack:/,
+        'expose' => nil
       }
     end
 
-    let(:defaults) do
-      { 'foo' => 'bar' }
-    end
-
     let(:stack_response) do
-      {
-        'name' => 'stack-a',
-        'stack' => 'foo/stack-a',
-        'services' => [],
-        'variables' => defaults
-      }
+      stack_expectation.merge('services' => [{'name' => 'foo', 'image' => 'bar'}], 'source' => 'foo')
     end
 
     before(:each) do
-      allow(File).to receive(:exist?).with('./path/to/kontena.yml').and_return(true)
+      allow(File).to receive(:read).with('kontena.yml').and_return(fixture('kontena_v3.yml'))
+      allow(File).to receive(:exist?).with('kontena.yml').and_return(true)
+      allow(subject.loader_class).to receive(:for).and_call_original
     end
 
     expect_to_require_current_master
     expect_to_require_current_master_token
 
     it 'uses kontena.yml as default stack file' do
-      expect(client).to receive(:get).with('stacks/test-grid/stack-name').and_return(stack_response)
-      expect(subject).to receive(:stack_read_and_dump).with('kontena.yml', name: 'stack-name', values: nil, defaults: defaults).and_return(stack)
-      expect(client).to receive(:put).with('stacks/test-grid/stack-name', stack)
-      subject.run(['stack-name'])
+      expect(subject.instance(['stack-name']).source).to eq 'kontena.yml'
+      expect(subject.instance(['stack-name']).stack_name).to eq 'stack-name'
     end
 
     it 'sends stack to master' do
       expect(client).to receive(:get).with('stacks/test-grid/stack-a').and_return(stack_response)
-      allow(subject).to receive(:require_config_file).with('./path/to/kontena.yml').and_return(true)
-      allow(subject).to receive(:stack_read_and_dump).with('./path/to/kontena.yml', name: 'stack-a', values: nil, defaults: defaults).and_return(stack)
-      expect(client).to receive(:put).with(
-        'stacks/test-grid/stack-a', anything
-      )
-      subject.run(['stack-a', './path/to/kontena.yml'])
-    end
-
-    it 'allows to override stack name' do
-      expect(client).to receive(:get).with('stacks/test-grid/stack-b').and_return(stack_response)
-      allow(subject).to receive(:require_config_file).with('./path/to/kontena.yml').and_return(true)
-      allow(subject).to receive(:stack_read_and_dump).with('./path/to/kontena.yml', name: 'stack-b', values: nil, defaults: defaults).and_return(stack)
-      stack_b = stack
-      stack_b[:name] = 'stack-b'
-      expect(client).to receive(:put).with(
-        'stacks/test-grid/stack-b', anything
-      )
-      subject.run(['stack-b',  './path/to/kontena.yml'])
+      expect(client).to receive(:put).with('stacks/test-grid/stack-a', hash_including(stack_expectation.merge('name' => 'stack-a'))).and_return(true)
+      subject.run(['--no-deploy', 'stack-a', fixture_path('kontena_v3.yml')])
     end
 
     it 'requires confirmation when master stack is different than input stack' do
-      expect(client).to receive(:get).with('stacks/test-grid/stack-b').and_return(stack_response)
-      allow(subject).to receive(:require_config_file).with('./path/to/kontena.yml').and_return(true)
-      allow(subject).to receive(:stack_read_and_dump).with('./path/to/kontena.yml', name: 'stack-b', values: nil, defaults: defaults).and_return(stack_with_different_stack_name)
-      expect(subject).to receive(:confirm).and_call_original
-      expect{subject.run(['stack-b',  './path/to/kontena.yml'])}.to exit_with_error
+      expect(client).to receive(:get).with('stacks/test-grid/stack-b').and_return(stack_response.merge('stack' => 'foo/otherstack'))
+      expect(subject).to receive(:confirm).with(/Replacing stack foo\/otherstack on master with user\/stackname/).and_call_original
+      expect{subject.run(['stack-b',  fixture_path('kontena_v3.yml')])}.to exit_with_error
     end
 
     it 'triggers deploy by default' do
       expect(client).to receive(:get).with('stacks/test-grid/stack-a').and_return(stack_response)
-      allow(subject).to receive(:require_config_file).with('./path/to/kontena.yml').and_return(true)
-      allow(subject).to receive(:stack_read_and_dump).with('./path/to/kontena.yml', name: 'stack-a', values: nil, defaults: defaults).and_return(stack)
       allow(client).to receive(:put).with(
         'stacks/test-grid/stack-a', anything
       ).and_return({})
       expect(Kontena).to receive(:run!).with(['stack', 'deploy', 'stack-a']).once
-      subject.run(['stack-a', './path/to/kontena.yml'])
+      subject.run(['stack-a', fixture_path('kontena_v3.yml')])
     end
 
     context '--no-deploy option' do
       it 'does not trigger deploy' do
         expect(client).to receive(:get).with('stacks/test-grid/stack-a').and_return(stack_response)
-        allow(subject).to receive(:require_config_file).with('./path/to/kontena.yml').and_return(true)
-        allow(subject).to receive(:stack_read_and_dump).with('./path/to/kontena.yml', name: 'stack-a', values: nil, defaults: defaults).and_return(stack)
         allow(client).to receive(:put).with(
           'stacks/test-grid/stack-a', anything
         ).and_return({})
         expect(Kontena).not_to receive(:run!).with(['stack', 'deploy', 'stack-a'])
-        subject.run(['--no-deploy', 'stack-a', './path/to/kontena.yml'])
+        subject.run(['--no-deploy', 'stack-a', fixture_path('kontena_v3.yml')])
+      end
+    end
+
+    context 'with a stack including dependencies' do
+
+      let(:expectation)     {{ 'name' => 'deptest', 'stack' => 'user/depstack1' }}
+      let(:expectation_1)   {{ 'name' => 'deptest-dep_1', 'stack' => 'user/depstack1child1' }}
+      let(:expectation_1_1) {{ 'name' => 'deptest-dep_1-dep_1', 'stack' => 'user/depstack1child1child1', 'services' => array_including(hash_including('image' => 'image:2')) }}
+      let(:expectation_2)   {{ 'name' => 'deptest-dep_2', 'stack' => 'user/depstack1child2', 'services' => array_including(hash_including('image' => 'image:1')), 'variables' => hash_including('dep_var' => 1) }}
+
+      let(:response)     { expectation.merge('parent' => nil, 'children' => [{'name' => 'deptest-dep_1'}, {'name' => 'deptest-dep_2'}]) }
+      let(:response_1)   { expectation_1.merge('parent' => { 'name' => 'deptest' }, 'children' => [{'name' => 'deptest-dep_1-dep_1'}]) }
+      let(:response_1_1) { expectation_1_1.merge('parent' => { 'name' => 'deptest-dep_1' }, 'children' => []) }
+      let(:response_2)   { expectation_2.merge('parent' => { 'name' => 'deptest' }, 'children' => [], 'variables' => {}, 'services' => []) }
+
+      before  do
+        allow(subject).to receive(:fetch_master_data).with('deptest').and_return(response)
+        allow(subject).to receive(:fetch_master_data).with('deptest-dep_1').and_return(response_1)
+        allow(subject).to receive(:fetch_master_data).with('deptest-dep_1-dep_1').and_return(response_1_1)
+        allow(subject).to receive(:fetch_master_data).with('deptest-dep_2').and_return(response_2)
+      end
+
+      it 'upgrades all dependencies' do
+        expect(client).to receive(:put).with('stacks/test-grid/deptest-dep_2', hash_including(expectation_2)).and_return(true)
+        expect(client).to receive(:put).with('stacks/test-grid/deptest-dep_1-dep_1', hash_including(expectation_1_1)).and_return(true)
+        expect(client).to receive(:put).with('stacks/test-grid/deptest-dep_1', hash_including(expectation_1)).and_return(true)
+        expect(client).to receive(:put).with('stacks/test-grid/deptest', hash_including(expectation)).and_return(true)
+        subject.run(['--no-deploy', '-v', 'dep_2.dep_var=1', 'deptest', fixture_path('stack-with-dependencies.yml')])
+      end
+
+      context 'when a dependency has been removed' do
+        it 'warns if a stack no longer in the dependency chain would be removed' do
+          expect(subject).to receive(:confirm).and_call_original
+          expect{subject.run(['--no-deploy', 'deptest', fixture_path('stack-with-dependencies-dep_2-removed.yml')])}.to exit_with_error.and output(/- deptest-dep_2.*data will be lost/m).to_stdout
+        end
+      end
+
+      context 'when a dependency has been added' do
+        it 'installs any new stacks in the dependency chain' do
+          allow(client).to receive(:put).and_return(true)
+          expect(Kontena).to receive(:run!).with(["stack", "install", "--name", "deptest-dep_3", "--parent-name", "deptest", "--no-deploy", fixture_path('stack-with-dependencies-dep-3.yml')]).and_return(true)
+          subject.run(['--no-deploy', '-v', 'dep_2.dep_var=1', 'deptest', fixture_path('stack-with-dependencies-dep_3-added.yml')])
+        end
       end
     end
   end

data/spec/kontena/cli/stacks/validate_command_spec.rb

@@ -0,0 +1,81 @@
+require "kontena/cli/stacks/upgrade_command"
+
+describe Kontena::Cli::Stacks::UpgradeCommand do
+
+  include ClientHelpers
+  include RequirementsHelper
+  include FixturesHelpers
+
+  context 'without dependencies' do
+    before do
+      [:read, :exist?].each do |meth|
+        allow(File).to receive(meth).with(fixture_path('kontena_v3.yml')).and_call_original
+        allow(File).to receive(meth).with(fixture_path('docker-compose_v2.yml')).and_call_original
+      end
+    end
+
+    it 'validates a yaml file' do
+      expect{Kontena.run!('stack', 'validate', fixture_path('kontena_v3.yml'))}.not_to exit_with_error
+      expect{Kontena.run!('stack', 'validate', fixture_path('kontena_v3.yml'))}.to output(/stack:.*version:.*services:.*variables:/m).to_stdout
+    end
+  end
+
+  context 'with dependencies' do
+    before do
+      Dir.glob(File.join(File.dirname(fixture_path('stack-with-dependencies.yml')), 'stack-with-dependencies*yml')).each do |file|
+        [:read, :exist?].each do |meth|
+          allow(File).to receive(meth).with(file).and_call_original
+        end
+      end
+    end
+
+    it 'validates all depended yaml files' do
+      output = OutputHelpers::CaptureStdoutLines.capture(proc {Kontena.run!('stack', 'validate', fixture_path('stack-with-dependencies.yml'))})
+      expect{Kontena.run!('stack', 'validate', fixture_path('stack-with-dependencies.yml'))}.not_to exit_with_error
+      expect(output.select { |line| line.start_with?('---') }.size).to eq 4
+      expect(output).to include('stack: user/depstack1')
+      expect(output).to include('stack: user/depstack1child1')
+      expect(output).to include('stack: user/depstack1child1child1')
+      expect(output).to include('stack: user/depstack1child2')
+      expect(output.select { |line| line.start_with?('stack') }.size).to eq 4
+    end
+
+    describe '--dependency-tree' do
+      let(:expectation) do
+        {
+          "name" => "depstack1",
+          "stack" => /stack-with-dependencies.yml$/,
+          "depends" => [
+            {
+              "name" => "dep_1",
+              "stack" => /stack-with-dependencies-dep-1.yml$/,
+              "variables" => {},
+              "depends" => [
+                {
+                  "name" => "dep_1",
+                  "stack" => /stack-with-dependencies-dep-1-1.yml$/,
+                  "variables" => {
+                    "dep_var" => 2
+                  }
+                }
+              ]
+            },
+            {
+              "name" => "dep_2",
+              "stack" => /stack-with-dependencies-dep-2.yml$/,
+              "variables" => {
+                "dep_var" => 1
+              }
+            }
+          ]
+        }
+      end
+
+      it 'outputs the dependency tree' do
+        output = OutputHelpers::CaptureStdoutLines.capture(proc {Kontena.run!('stack', 'validate', '--dependency-tree', fixture_path('stack-with-dependencies.yml'))})
+        yaml = ::YAML.safe_load(output.join("\n"))
+        expect(yaml).to match hash_including(expectation)
+      end
+    end
+  end
+end

data/spec/kontena/cli/stacks/yaml/custom_validators/affinities_validator_spec.rb

@@ -0,0 +1,22 @@
+require 'kontena/cli/stacks/yaml/validator_v3'
+require 'kontena/cli/stacks/yaml/custom_validators/affinities_validator'
+
+describe Kontena::Cli::Stacks::YAML::Validations::CustomValidators::AffinitiesValidator do
+
+  let(:errors) { Hash.new }
+
+  it 'accepts valid affinity' do
+    subject.validate('affinity', ['foo==bar'], [], errors)
+    expect(errors.size).to eq(0)
+  end
+
+  it 'accepts valid soft affinity' do
+    subject.validate('affinity', ['foo==~bar'], [], errors)
+    expect(errors.size).to eq(0)
+  end
+
+  it 'does not accept invalid affinity' do
+    subject.validate('affinity', ['foo=bar'], [], errors)
+    expect(errors.size).to eq(1)
+  end
+end

data/spec/kontena/cli/stacks/yaml/reader_spec.rb

@@ -1,12 +1,9 @@
 require 'kontena/cli/stacks/yaml/reader'
-require 'liquid'
 
 describe Kontena::Cli::Stacks::YAML::Reader do
   include FixturesHelpers
 
-  let(:service_extender) do
-    spy
-  end
+  let(:service_extender) { spy("Kontena::Cli::Stacks::YAML::ServiceExtender") }
 
   let(:env_file) do
     ['APIKEY=12345
@@ -14,34 +11,9 @@ describe Kontena::Cli::Stacks::YAML::Reader do
 ', 'WP_ADMIN_PASSWORD=verysecret']
   end
 
-  let(:valid_v3_result) do
-    {
-      'stack' => 'user/stackname',
-      'version' => '2',
-      'services' => {
-        'wordpress' => {
-          'image' => 'wordpress:4.1',
-          'ports' => ['80:80'],
-          'depends_on' => ['mysql'],
-          'stateful' => true,
-          'environment' => ['WORDPRESS_DB_PASSWORD=test_secret'],
-          'instances' => 2,
-          'deploy' => { 'strategy' => 'ha' },
-          'secrets' => []
-        },
-        'mysql' => {
-          'image' => 'mysql:5.6',
-          'stateful' => true,
-          'environment' => ['MYSQL_ROOT_PASSWORD=test_secret'],
-          'secrets' => []
-        }
-      }
-    }
-  end
-
   before(:each) do
     allow_any_instance_of(described_class).to receive(:env)
-      .and_return( { 'STACK' => 'test', 'GRID' => 'test-grid' } )
+      .and_return( { 'STACK' => 'test', 'GRID' => 'test-grid', 'PLATFORM' => 'test-grid' } )
   end
 
   describe '#initialize' do
@@ -76,85 +48,118 @@ describe Kontena::Cli::Stacks::YAML::Reader do
     end
 
     it 'returns error' do
-      outcome = subject.execute
-      expect(outcome[:errors].size).to eq(1)
+      subject.execute
+      expect(subject.errors.size).to eq(1)
     end
   end
 
   describe '#execute' do
-    subject do
+
+    let(:subject) do
       described_class.new(fixture_path('kontena_v3.yml'))
     end
 
-    context 'when extending services' do
-      it 'extends services from external file' do
-        docker_compose_yml = YAML.load(fixture('docker-compose_v2.yml'))
-        wordpress_options = {
-          'extends' => {
-            'file' => 'docker-compose_v2.yml',
-            'service' => 'wordpress'
-          },
-          'stateful' => true,
-          'environment' => ['WORDPRESS_DB_PASSWORD=test_secret'],
-          'instances' => 2,
-          'deploy' => { 'strategy' => 'ha' }
-        }
-        mysql_options = {
-          'extends' => {
-            'file' => 'docker-compose_v2.yml',
-            'service' => 'mysql'
-          },
-          'stateful' => true,
-          'environment' => ['MYSQL_ROOT_PASSWORD=test_secret']
-        }
-        expect(Kontena::Cli::Stacks::YAML::ServiceExtender).to receive(:new)
-          .with(wordpress_options)
-          .once
-          .and_return(service_extender)
-        expect(Kontena::Cli::Stacks::YAML::ServiceExtender).to receive(:new)
-          .with(mysql_options)
-          .once
-          .and_return(service_extender)
-        expect(service_extender).to receive(:extend_from).with(docker_compose_yml['services']['wordpress'])
-        expect(service_extender).to receive(:extend_from).with(docker_compose_yml['services']['mysql'])
-
-        subject.execute
+    it 'returns result hash' do
+      result = subject.execute
+      expect(result).to be_kind_of(Hash)
+      %w(
+        stack
+        version
+        name
+        registry
+        expose
+        services
+        volumes
+        dependencies
+        source
+        variables
+        parent_name
+      ).each do |k|
+        expect(result.key?(k)).to be_truthy
       end
+    end
 
-      it 'extends services from the same file' do
-        subject = described_class.new(fixture_path('stack-internal-extend.yml'))
+    context 'when extending services' do
+      context 'from external file' do
+        let(:subject) do
+          described_class.new(fixture_path('kontena_v3.yml'))
+        end
 
-        kontena_yml = YAML.load(fixture('stack-internal-extend.yml'))
+        before do
+          [:exist?, :read].each do |meth|
+            allow(File).to receive(meth).with(fixture_path('docker-compose_v2.yml')).and_call_original
+            allow(File).to receive(meth).with(fixture_path('kontena_v3.yml')).and_call_original
+          end
+        end
 
-        expect(Kontena::Cli::Stacks::YAML::ServiceExtender).to receive(:new)
-          .with(kontena_yml['services']['app'])
-          .once
-          .and_return(service_extender)
-        expect(service_extender).to receive(:extend_from).with(kontena_yml['services']['base'])
-        subject.execute
-      end
+        it 'extends services from an external file' do
+          expect(File).to receive(:read).with(fixture_path('docker-compose_v2.yml')).and_call_original
+          expect(subject.execute['services']).to match array_including(
+            hash_including(
+              "instances"=>2,
+              "image"=>"wordpress:4.1",
+              "env"=>["WORDPRESS_DB_PASSWORD=test_secret"],
+              "links"=>[{"name"=>"mysql", "alias"=>"mysql"}],
+              "ports"=>[{"ip"=>"0.0.0.0", "container_port"=>80, "node_port"=>80, "protocol"=>"tcp"}],
+              "stateful"=>true,
+              "strategy"=>"ha",
+              "name"=>"wordpress"
+            ),
+            hash_including(
+              "instances"=>nil,
+              "image"=>"mysql:5.6",
+              "env"=>["MYSQL_ROOT_PASSWORD=test_secret"],
+              "links"=>[],
+              "ports"=>[],
+              "stateful"=>true,
+              "name"=>"mysql"
+            )
+          )
+        end
 
-      it 'merges validation errors' do
-        allow(File).to receive(:read)
-          .with(fixture_path('kontena_v3.yml'))
-          .and_return(fixture('kontena_v3.yml'))
-        allow(File).to receive(:read)
-          .with(fixture_path('docker-compose_v2.yml'))
-          .and_return(fixture('docker-compose-invalid.yml'))
-        outcome = subject.execute
-        expect(outcome[:errors]).to eq([{
-          'docker-compose_v2.yml' =>[
-            {
-              'services' => {
-                'wordpress' => {
-                  'networks' => 'key not expected'
+        it 'merges validation errors' do
+          expect(File).to receive(:read).with(fixture_path('docker-compose_v2.yml')).and_return(fixture('docker-compose-invalid.yml'))
+          outcome = subject.execute
+          expect(outcome['errors']).to eq([{
+            'docker-compose_v2.yml' =>[
+              {
+                'services' => {
+                  'wordpress' => {
+                    'networks' => 'key not expected'
+                  }
                 }
               }
-            }
-          ]
-        }])
+            ]
+          }])
+        end
       end
 
+      context 'from the same file' do
+        subject do
+          described_class.new(fixture_path('stack-internal-extend.yml'))
+        end
+
+        before do
+          [:exist?, :read].each do |meth|
+            allow(File).to receive(meth).with(fixture_path('stack-internal-extend.yml')).and_call_original
+          end
+        end
+
+        it 'extends services from the same file' do
+          app_svc = subject.execute['services'].find { |s| s['name'] == 'app' }
+          expect(app_svc).not_to be_nil
+          puts app_svc.inspect
+          expect(app_svc).to match hash_including(
+            "image" => "base:latest",
+            "instances" => 2,
+            "env" => [
+              "TEST1=test1",
+              "TEST2=changed"
+            ],
+            "stateful" => true
+          )
+        end
+      end
     end
 
     context 'variable interpolation' do
@@ -174,6 +179,7 @@ describe Kontena::Cli::Stacks::YAML::Reader do
           {
             'STACK' => 'test',
             'GRID' => 'test-grid',
+            'PLATFORM' => 'test-grid',
             'TAG' => '4.1'
           }
         )
@@ -183,15 +189,21 @@ describe Kontena::Cli::Stacks::YAML::Reader do
       end
 
       it 'interpolates $VAR variables' do
-        result = subject.execute
-        services = result[:services]
-        expect(services['wordpress']['image']).to eq('wordpress:4.1')
+        expect(subject.execute['services']).to match array_including(hash_including('image' => 'wordpress:4.1'))
+      end
+
+      it 'interpolates default variables' do
+        expect(subject.execute['services']).to match array_including(
+          hash_including(
+            'name' => 'wordpress', 'env' => array_including(
+              'STACK=test', 'GRID=test-grid', 'PLATFORM=test-grid'
+            )
+          )
+        )
       end
 
       it 'interpolates ${VAR} variables' do
-        result = subject.execute
-        services = result[:services]
-        expect(services['mysql']['image']).to eq('mariadb:latest')
+        expect(subject.execute['services']).to match array_including(hash_including('name' => 'mysql', 'image' => 'mariadb:latest'))
       end
 
       it 'warns about empty variables' do
@@ -217,8 +229,22 @@ describe Kontena::Cli::Stacks::YAML::Reader do
         allow(ENV).to receive(:[]).with('TAG').and_return('4.1')
         allow(ENV).to receive(:[]).with('TEST_ENV_VAR').and_return('foo')
         allow(ENV).to receive(:[]).with('MYSQL_IMAGE').and_return('foo')
-        services = subject.execute[:services]
-        expect(services['mysql']['environment'].first).to eq('INTERNAL_VAR=$INTERNAL_VAR')
+
+        expect(subject.execute['services']).to match array_including(
+          hash_including('name' => 'mysql', 'env' => array_including('INTERNAL_VAR=$INTERNAL_VAR'))
+        )
+      end
+
+      it 'raises runtime error for undeclared variables' do
+        subject.variables.delete(subject.variables.option('test_var'))
+        expect{subject.execute}.to raise_error(RuntimeError, /Undeclared variable 'test_var'/)
+      end
+
+      it 'considers variables declared when they are listed as to: env targets' do
+        subject.variables.option('tag').to[:env] = "BAG"
+        expect{subject.execute}.to raise_error(RuntimeError, /Undeclared variable 'TAG'/)
+        subject.variables.option('tag').to[:env] = "TAG"
+        expect{subject.execute}.not_to raise_error
       end
     end
 
@@ -233,13 +259,13 @@ describe Kontena::Cli::Stacks::YAML::Reader do
         end
 
         it 'converts env hash to array' do
-          result = subject.execute[:services]
-          expect(result['wordpress']['environment']).to eq(['WORDPRESS_DB_PASSWORD=test_secret'])
+          expect(subject.execute['services']).to match array_including(hash_including('name' => 'wordpress', 'env' => ['WORDPRESS_DB_PASSWORD=test_secret']))
         end
 
         it 'does nothing to env array' do
-          result = subject.execute[:services]
-          expect(result['mysql']['environment']).to eq(['MYSQL_ROOT_PASSWORD=test_secret'])
+          expect(subject.execute['services']).to match array_including(
+            hash_including('name' => 'mysql', 'env' => ['MYSQL_ROOT_PASSWORD=test_secret'])
+          )
         end
       end
 
@@ -275,31 +301,18 @@ describe Kontena::Cli::Stacks::YAML::Reader do
         end
 
         it 'merges variables' do
-          result = subject.execute[:services]
-          expect(result['wordpress']['environment']).to eq([
-            'WORDPRESS_DB_PASSWORD=test_secret',
-            'APIKEY=12345',
-            'MYSQL_ROOT_PASSWORD=secret',
-            'WP_ADMIN_PASSWORD=verysecret'
-            ])
+          expect(subject.execute['services']).to match array_including(
+            hash_including(
+              'name' => 'wordpress',
+              'env' => [
+                'WORDPRESS_DB_PASSWORD=test_secret',
+                'APIKEY=12345',
+                'MYSQL_ROOT_PASSWORD=secret',
+                'WP_ADMIN_PASSWORD=verysecret'
+              ]
+            )
+          )
         end
-
-      end
-    end
-
-    it 'returns result hash' do
-      outcome = subject.execute
-      expect(outcome[:services]).to eq(valid_v3_result['services'])
-    end
-
-    context "For an invalid stack file" do
-      subject do
-        described_class.new(fixture_path('stack-invalid.yml'))
-      end
-
-      it 'returns validation errors' do
-        outcome = subject.execute
-        expect(outcome[:errors].size).to eq(1)
       end
     end
   end
@@ -311,7 +324,7 @@ describe Kontena::Cli::Stacks::YAML::Reader do
 
     it 'expands build option to absolute path' do
       outcome = subject.execute
-      expect(outcome[:services]['webapp']['build']['context']).to eq(fixture_path(''))
+      expect(outcome['services']['webapp']['build']['context']).to eq(fixture_path(''))
     end
   end
 
@@ -322,7 +335,7 @@ describe Kontena::Cli::Stacks::YAML::Reader do
 
     it 'expands build context to absolute path' do
       outcome = subject.execute
-      expect(outcome[:services]['webapp']['build']['context']).to eq(fixture_path(''))
+      expect(outcome['services']['webapp']['build']['context']).to eq(fixture_path(''))
     end
   end
 
@@ -370,7 +383,7 @@ describe Kontena::Cli::Stacks::YAML::Reader do
         }
 
         subject.send(:normalize_build_args, options)
-        expect(options.dig('build', 'args')).to eq({
+        expect(options['build']['args']).to eq({
           'foo' => 'bar'
         })
       end
@@ -383,53 +396,42 @@ describe Kontena::Cli::Stacks::YAML::Reader do
     end
 
     it 'returns name for v3' do
-      name = subject.stack_name
+      name = subject.loader.stack_name.stack
       expect(name).to eq('stackname')
     end
   end
 
   context 'origins' do
     before do
-      allow(File).to receive(:read)
-        .with(fixture_path('kontena_v3.yml'))
-        .and_return(fixture('kontena_v3.yml'))
+      ['docker-compose_v2.yml', 'kontena_v3.yml'].each do |file|
+        [:exist?, :read].each do |meth|
+          allow(File).to receive(meth)
+            .with(fixture_path(file))
+            .and_call_original
+        end
+      end
     end
 
     it 'can read from a file' do
-      allow(File).to receive(:read)
-        .with(fixture_path('docker-compose_v2.yml'))
-        .and_return(fixture('docker-compose-invalid.yml'))
-
       subject = described_class.new(fixture_path('kontena_v3.yml'))
-
-      expect(subject.from_file?).to be_truthy
-      expect(subject.execute[:registry]).to eq 'file://'
+      expect(subject.loader.origin).to eq 'file'
+      expect(subject.execute['registry']).to eq 'file://'
     end
 
     it 'can read from the registry' do
-      allow(File).to receive(:read)
-        .with(File.expand_path('docker-compose_v2.yml'))
-        .and_return(fixture('docker-compose-invalid.yml'))
-
-      stack_double = double
-      allow_any_instance_of(Kontena::StacksCache::RegistryClientFactory).to receive(:cloud_auth?).and_return(true)
-      expect(Kontena::StacksCache).to receive(:cache).with('foo/foo', nil).and_return(stack_double)
-      expect(stack_double).to receive(:read).and_return(fixture('kontena_v3.yml'))
+      allow(File).to receive(:exist?)
+        .with(/foo\/foo$/)
+        .and_return(false)
       instance = described_class.new('foo/foo')
-      expect(instance.from_registry?).to be_truthy
-      expect(instance.execute[:registry]).to eq instance.current_account.stacks_url
+      expect(instance.loader.origin).to eq 'registry'
     end
 
     it 'can read from an url' do
-      allow(File).to receive(:read)
-        .with(File.expand_path('docker-compose_v2.yml'))
-        .and_return(fixture('docker-compose-invalid.yml'))
-
-      stub_request(:get, "http://foo.example.com/foo").to_return(:status => 200, :body => fixture('stack-with-liquid.yml'), :headers => {})
-      allow_any_instance_of(described_class).to receive(:load_from_url).and_return(fixture('stack-with-liquid.yml'))
+      allow(File).to receive(:exist?)
+        .with(/\/foo$/)
+        .and_return(false)
       instance = described_class.new('http://foo.example.com/foo')
-      expect(instance.from_url?).to be_truthy
-      expect(instance.execute[:registry]).to eq 'file://'
+      expect(instance.loader.origin).to eq 'uri'
     end
   end
 
@@ -444,7 +446,7 @@ describe Kontena::Cli::Stacks::YAML::Reader do
       end
 
       it 'interpolates variables into services' do
-        expect(subject.execute[:services].size).to eq 5
+        expect(subject.execute['services'].size).to eq 5
       end
     end
 
@@ -479,10 +481,11 @@ describe Kontena::Cli::Stacks::YAML::Reader do
     end
 
     it "omits the env" do
-      outcome = subject.execute
-
-      expect(outcome[:variables]).to eq('asdf' => nil), subject.variables.inspect
-      expect(outcome[:services]['test']['environment']).to eq nil
+      result = subject.execute
+      expect(result['variables']).to match hash_including('asdf' => nil)
+      expect(result['services']).to match array_including(
+        hash_including('name' => 'test', 'env' => nil)
+      )
     end
   end
 
@@ -497,9 +500,10 @@ describe Kontena::Cli::Stacks::YAML::Reader do
 
     it "defines the env" do
       outcome = subject.execute
-
-      expect(outcome[:variables]).to eq 'asdf' => 'test'
-      expect(outcome[:services]['test']['environment']).to eq ['ASDF=test']
+      expect(outcome['variables']).to match hash_including('asdf' => 'test')
+      expect(outcome['services']).to match array_including(
+        hash_including('name' => 'test', 'env' => ['ASDF=test'])
+      )
     end
   end
 end