marathon-api 0.9.0 → 1.0.0

data/spec/marathon/base_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Marathon::Base do
+
+  describe '#init' do
+    subject { described_class }
+
+    it 'fails with strange input' do
+      expect { subject.new('foo') }.to raise_error(Marathon::Error::ArgumentError)
+      expect { subject.new({}, 'foo') }.to raise_error(Marathon::Error::ArgumentError)
+      expect { subject.new(nil) }.to raise_error(Marathon::Error::ArgumentError)
+      expect { subject.new({}, nil) }.to raise_error(Marathon::Error::ArgumentError)
+      expect { subject.new([], ['foo']) }.to raise_error(Marathon::Error::ArgumentError)
+    end
+  end
+
+  describe '#to_json' do
+    subject { described_class.new({
+        'app' => { 'id' => '/app/foo' },
+        :foo  => 'blubb',
+        :bar  => 1
+      }) }
+
+    let(:expected_string) do
+      '{"app":{"id":"/app/foo"},"foo":"blubb","bar":1}'
+    end
+
+    its(:to_json) { should == expected_string }
+  end
+
+  describe '#attr_readers' do
+    subject { described_class.new({
+        'foo' => 'blubb',
+        :bar  => 1
+      }, [:foo, 'bar']) }
+
+    its(:info) { should == {:foo => 'blubb', :bar => 1} }
+    its(:foo) { should == 'blubb' }
+    its(:bar) { should == 1 }
+  end
+
+  describe '#attr_readers, from string array' do
+    subject { described_class.new({
+        'foo' => 'blubb',
+        :bar  => 1
+      }, %w[foo bar]) }
+
+    its(:info) { should == {:foo => 'blubb', :bar => 1} }
+    its(:foo) { should == 'blubb' }
+    its(:bar) { should == 1 }
+  end
+
+end

data/spec/marathon/connection_spec.rb

@@ -6,7 +6,7 @@ describe Marathon::Connection do
     subject { described_class.new('http://foo:8080') }
 
     let(:expected_string) do
-      "Marathon::Connection { :url => http://foo:8080 }"
+      "Marathon::Connection { :url => http://foo:8080 :options => {} }"
     end
 
     its(:to_s) { should == expected_string }

data/spec/marathon/constraint_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Marathon::Constraint do
+
+  describe '#to_s w/o parameter' do
+    subject { described_class.new(['hostname', 'UNIQUE']) }
+
+    let(:expected_string) do
+      'Marathon::Constraint { :attribute => hostname :operator => UNIQUE }'
+    end
+
+    its(:to_s) { should == expected_string }
+    its(:to_pretty_s) { should == 'hostname:UNIQUE' }
+  end
+
+  describe '#to_s with parameter' do
+    subject { described_class.new(['hostname', 'LIKE', 'foo-host']) }
+
+    let(:expected_string) do
+      'Marathon::Constraint { :attribute => hostname :operator => LIKE :parameter => foo-host }'
+    end
+
+    its(:to_s) { should == expected_string }
+    its(:to_pretty_s) { should == 'hostname:LIKE:foo-host' }
+  end
+
+end

data/spec/marathon/container_docker_port_mapping_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+CONTAINER_DOCKER_PORT_MAPPING_EXAMPLE = {
+    :protocol => 'tcp',
+    :hostPort => 0,
+    :containerPort => 8080
+  }
+
+describe Marathon::ContainerDockerPortMapping do
+
+  describe '#init' do
+    subject { described_class }
+
+    it 'should fail with invalid protocol' do
+      expect { subject.new(:protocol => 'foo', :containerPort => 8080) }
+        .to raise_error(Marathon::Error::ArgumentError, /protocol must be one of /)
+    end
+
+    it 'should fail with invalid containerPort' do
+      expect { subject.new(:containerPort => 'foo') }
+        .to raise_error(Marathon::Error::ArgumentError, /containerPort must be/)
+      expect { subject.new(:containerPort => 0) }
+        .to raise_error(Marathon::Error::ArgumentError, /containerPort must be/)
+      expect { subject.new(:containerPort => -1) }
+        .to raise_error(Marathon::Error::ArgumentError, /containerPort must be/)
+    end
+
+    it 'should fail with invalid hostPort' do
+      expect { subject.new(:hostPort => 'foo', :containerPort => 8080) }
+        .to raise_error(Marathon::Error::ArgumentError, /hostPort must be/)
+      expect { subject.new(:hostPort => -1, :containerPort => 8080) }
+        .to raise_error(Marathon::Error::ArgumentError, /hostPort must be/)
+    end
+  end
+
+  describe '#attributes' do
+    subject { described_class.new(CONTAINER_DOCKER_PORT_MAPPING_EXAMPLE) }
+
+    its(:protocol) { should == 'tcp' }
+    its(:hostPort) { should == 0 }
+    its(:containerPort) { should == 8080 }
+  end
+
+  describe '#to_s' do
+    subject { described_class.new(CONTAINER_DOCKER_PORT_MAPPING_EXAMPLE) }
+
+    let(:expected_string) do
+      'Marathon::ContainerDockerPortMapping { :protocol => tcp :containerPort => 8080 :hostPort => 0 }'
+    end
+
+    its(:to_s) { should == expected_string }
+    its(:to_pretty_s) { should == 'tcp/8080:0' }
+  end
+
+end

data/spec/marathon/container_docker_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+CONTAINER_DOCKER_EXAMPLE = {
+    :network => 'HOST',
+    :image => 'felixb/yocto-httpd'
+  }
+
+describe Marathon::ContainerDocker do
+
+  describe '#init' do
+    subject { described_class }
+
+    it 'should fail with invalid network' do
+      expect { subject.new(:network => 'foo', :image => 'foo') }
+        .to raise_error(Marathon::Error::ArgumentError, /network must be one of /)
+    end
+
+    it 'should fail w/o image' do
+      expect { subject.new({}) }
+        .to raise_error(Marathon::Error::ArgumentError, /image must not be/)
+    end
+  end
+
+  describe '#attributes' do
+    subject { described_class.new(CONTAINER_DOCKER_EXAMPLE) }
+
+    its(:network) { should == 'HOST' }
+    its(:image) { should == 'felixb/yocto-httpd' }
+  end
+
+  describe '#to_s' do
+    subject { described_class.new(CONTAINER_DOCKER_EXAMPLE) }
+
+    let(:expected_string) do
+      'Marathon::ContainerDocker { :image => felixb/yocto-httpd }'
+    end
+
+    its(:to_s) { should == expected_string }
+    its(:to_pretty_s) { should == 'felixb/yocto-httpd' }
+  end
+
+end

data/spec/marathon/container_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+CONTAINER_EXAMPLE = {
+    :type => 'DOCKER',
+    :docker => {
+      :image => 'felixb/yocto-httpd',
+      :portMappings => [{:containerPort => 8080}]
+    },
+    :volumes => [{
+      :containerPath => '/data',
+      :hostPath => '/var/opt/foo'
+    }]
+  }
+
+describe Marathon::Container do
+
+  describe '#attributes' do
+    subject { described_class.new(CONTAINER_EXAMPLE) }
+
+    its(:type) { should == 'DOCKER' }
+    its(:docker) { should be_instance_of(Marathon::ContainerDocker) }
+    its("docker.portMappings") { should be_instance_of(Array) }
+    its("docker.portMappings.first") { should be_instance_of(Marathon::ContainerDockerPortMapping) }
+    its("docker.portMappings.first.containerPort") { should == 8080 }
+    its(:volumes) { should be_instance_of(Array) }
+    its("volumes.first") { should be_instance_of(Marathon::ContainerVolume) }
+    its("volumes.first.containerPath") { should == '/data' }
+  end
+
+  describe '#to_s' do
+    subject { described_class.new(CONTAINER_EXAMPLE) }
+
+    let(:expected_string) do
+      'Marathon::Container { :type => DOCKER :docker => felixb/yocto-httpd :volumes => /data:/var/opt/foo:RW }'
+    end
+
+    its(:to_s) { should == expected_string }
+  end
+
+end

data/spec/marathon/container_volume_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+CONTAINER_VOLUME_EXAMPLE = {
+    :containerPath => '/data',
+    :hostPath => '/var/opt/foo',
+    :mode => 'RO'
+  }
+
+describe Marathon::ContainerVolume do
+
+  describe '#init' do
+    subject { described_class }
+
+    it 'should fail with invalid mode' do
+      expect { subject.new(:containerPath => '/', :hostPath => '/', :mode => 'foo') }
+        .to raise_error(Marathon::Error::ArgumentError, /mode must be one of /)
+    end
+
+    it 'should fail with invalid path' do
+      expect { subject.new(:hostPath => '/') }
+        .to raise_error(Marathon::Error::ArgumentError, /containerPath .* not be nil/)
+      expect { subject.new(:containerPath => 'foo', :hostPath => '/') }
+        .to raise_error(Marathon::Error::ArgumentError, /containerPath .* absolute path/)
+      expect { subject.new(:containerPath => '/') }
+        .to raise_error(Marathon::Error::ArgumentError, /hostPath .* not be nil/)
+      expect { subject.new(:containerPath => '/', :hostPath => 'foo') }
+        .to raise_error(Marathon::Error::ArgumentError, /hostPath .* absolute path/)
+    end
+  end
+
+  describe '#attributes' do
+    subject { described_class.new(CONTAINER_VOLUME_EXAMPLE) }
+
+    its(:containerPath) { should == '/data' }
+    its(:hostPath) { should == '/var/opt/foo' }
+    its(:mode) { should == 'RO' }
+  end
+
+  describe '#to_s' do
+    subject { described_class.new(CONTAINER_VOLUME_EXAMPLE) }
+
+    let(:expected_string) do
+      'Marathon::ContainerVolume { :containerPath => /data :hostPath => /var/opt/foo :mode => RO }'
+    end
+
+    its(:to_s) { should == expected_string }
+    its(:to_pretty_s) { should == '/data:/var/opt/foo:RO' }
+  end
+
+end

data/spec/marathon/deployment_info_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+DEPLOYMENT_INFO_EXAMPLE = {
+  'deploymentId' => 'deployment-123',
+  'version' => 'version-456'
+}
+
+describe Marathon::DeploymentInfo do
+
+  describe '#attributes' do
+    subject { described_class.new(DEPLOYMENT_INFO_EXAMPLE) }
+
+    its(:deploymentId) { should == 'deployment-123' }
+    its(:version) { should == 'version-456' }
+  end
+
+  describe '#to_s' do
+    subject { described_class.new(DEPLOYMENT_INFO_EXAMPLE) }
+
+    let(:expected_string) do
+      'Marathon::DeploymentInfo { :version => version-456 :deploymentId => deployment-123 }'
+    end
+
+    its(:to_s) { should == expected_string }
+  end
+
+  describe '#to_s w/o deploymentId' do
+    subject { described_class.new(:version => 'foo-version') }
+
+    let(:expected_string) do
+      'Marathon::DeploymentInfo { :version => foo-version }'
+    end
+
+    its(:to_s) { should == expected_string }
+  end
+
+  describe '#to_json' do
+    subject { described_class.new(DEPLOYMENT_INFO_EXAMPLE) }
+
+    its(:to_json) { should == DEPLOYMENT_INFO_EXAMPLE.to_json }
+  end
+
+end

data/spec/marathon/deployment_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-EXAMPLE = {
+DEPLOYMENT_EXAMPLE = {
   "affectedApps" => ["/test"],
   "id" => "867ed450-f6a8-4d33-9b0e-e11c5513990b",
   "steps" => [
@@ -25,7 +25,7 @@ EXAMPLE = {
 describe Marathon::Deployment do
 
   describe '#to_s' do
-    subject { described_class.new(EXAMPLE) }
+    subject { described_class.new(DEPLOYMENT_EXAMPLE) }
 
     let(:expected_string) do
       'Marathon::Deployment { ' \
@@ -36,31 +36,31 @@ describe Marathon::Deployment do
   end
 
   describe '#to_json' do
-    subject { described_class.new(EXAMPLE) }
+    subject { described_class.new(DEPLOYMENT_EXAMPLE) }
 
-    its(:to_json) { should == EXAMPLE.to_json }
+    its(:to_json) { should == DEPLOYMENT_EXAMPLE.to_json }
   end
 
   describe 'attributes' do
-    subject { described_class.new(EXAMPLE) }
+    subject { described_class.new(DEPLOYMENT_EXAMPLE) }
 
-    its(:id) { should == EXAMPLE['id'] }
-    its(:affectedApps) { should == EXAMPLE['affectedApps'] }
-    its(:version) { should == EXAMPLE['version'] }
-    its(:currentStep) { should == EXAMPLE['currentStep'] }
-    its(:totalSteps) { should == EXAMPLE['totalSteps'] }
+    its(:id) { should == DEPLOYMENT_EXAMPLE['id'] }
+    its(:affectedApps) { should == DEPLOYMENT_EXAMPLE['affectedApps'] }
+    its(:version) { should == DEPLOYMENT_EXAMPLE['version'] }
+    its(:currentStep) { should == DEPLOYMENT_EXAMPLE['currentStep'] }
+    its(:totalSteps) { should == DEPLOYMENT_EXAMPLE['totalSteps'] }
   end
 
   describe '#delete' do
-    subject { described_class.new(EXAMPLE) }
+    subject { described_class.new(DEPLOYMENT_EXAMPLE) }
 
     it 'deletes the deployment' do
-      expect(described_class).to receive(:delete).with(EXAMPLE['id'], false)
+      expect(described_class).to receive(:delete).with(DEPLOYMENT_EXAMPLE['id'], false)
       subject.delete
     end
 
     it 'force deletes the deployment' do
-      expect(described_class).to receive(:delete).with(EXAMPLE['id'], true)
+      expect(described_class).to receive(:delete).with(DEPLOYMENT_EXAMPLE['id'], true)
       subject.delete(true)
     end
   end
@@ -86,9 +86,8 @@ describe Marathon::Deployment do
 
     it 'deletes deployments', :vcr do
       # start a deployment
-      json = Marathon::App.change('/test', {'instances' => 1})
-      id = json['deploymentId']
-      subject.delete(id)
+      info = Marathon::App.change('/test', {'instances' => 1})
+      expect(subject.delete(info.deploymentId)).to be_instance_of(Marathon::DeploymentInfo)
     end
   end
 

data/spec/marathon/error_spec.rb

@@ -10,6 +10,11 @@ describe Marathon::Error do
         .to be(Marathon::Error::ClientError)
     end
 
+    it 'returns ClientError on 422' do
+      expect(subject.error_class(Net::HTTPResponse.new(1.1, 422, 'Client Error')))
+        .to be(Marathon::Error::ClientError)
+    end
+
     it 'returns NotFoundError on 404' do
       expect(subject.error_class(Net::HTTPResponse.new(1.1, 404, 'Not Found')))
         .to be(Marathon::Error::NotFoundError)
@@ -30,6 +35,18 @@ describe Marathon::Error do
       expect(subject.error_message(r)).to eq('fooo')
     end
 
+    it 'returns "errors" from respose json' do
+      r = { 'errors' => 'fooo' }
+      expect(r).to receive(:parsed_response) { r }
+      expect(subject.error_message(r)).to eq('fooo')
+    end
+
+    it 'returns full hash from respose json, if keys are missing' do
+      r = { 'bars' => 'fooo' }
+      expect(r).to receive(:parsed_response) { r }
+      expect(subject.error_message(r)).to eq(r)
+    end
+
     it 'returns full body if not a hash with "message"' do
       r = 'fooo'
       expect(r).to receive(:parsed_response) { r }

data/spec/marathon/group_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+
+EXAMPLE_GROUP = {
+  "id" => "/test-group",
+  "apps" => [
+      {
+          "backoffFactor" => 1.15,
+          "backoffSeconds" => 1,
+          "maxLaunchDelaySeconds" => 3600,
+          "cmd" => "sleep 30",
+          "constraints" => [],
+          "cpus" => 1.0,
+          "dependencies" => [],
+          "disk" => 0.0,
+          "env" => {},
+          "executor" => "",
+          "id" => "app",
+          "instances" => 1,
+          "mem" => 128.0,
+          "ports" => [10000],
+          "requirePorts" => false,
+          "storeUrls" => [],
+          "upgradeStrategy" => {
+              "minimumHealthCapacity" => 1.0
+          },
+          "tasks" => []
+      }
+  ],
+  "dependencies" => [],
+  "groups" => []
+}
+
+describe Marathon::Group do
+
+  describe '#to_s' do
+    subject { described_class.new(EXAMPLE_GROUP) }
+
+    let(:expected_string) do
+      "Marathon::Group { :id => /test-group }"
+    end
+
+    let(:expected_pretty_string) do
+       "Group ID:   /test-group\n" + \
+       "    App ID:     app\n" + \
+       "    Instances:  0/1\n" + \
+       "    Command:    sleep 30\n" + \
+       "    CPUs:       1.0\n" + \
+       "    Memory:     128.0 MB\n" + \
+       "    Version:\n" + \
+       "Version:"
+
+    end
+
+    its(:to_s) { should == expected_string }
+    its(:to_pretty_s) { should == expected_pretty_string }
+  end
+
+  describe '#start!' do
+    subject { described_class.new({ 'id' => '/group/foo' }) }
+
+    it 'starts the group' do
+      expect(described_class).to receive(:start)
+        .with({:apps=>[], :dependencies=>[], :groups=>[], :id=>'/group/foo'}) do
+          Marathon::DeploymentInfo.new({ 'version' => 'new-version' })
+      end
+      expect(subject.start!.version).to eq('new-version')
+    end
+  end
+
+  describe '#refresh' do
+    subject { described_class.new({ 'id' => '/app/foo' }) }
+
+    it 'refreshs the group' do
+      expect(described_class).to receive(:get).with('/app/foo') do
+        described_class.new({ 'id' => '/app/foo', 'refreshed' => true })
+      end
+      subject.refresh
+      expect(subject.info[:refreshed]).to be(true)
+    end
+  end
+
+  describe '#change!' do
+    subject { described_class.new({ 'id' => '/app/foo' }) }
+
+    it 'changes the group' do
+      expect(described_class).to receive(:change).with('/app/foo', {'instances' => 9000 }, false)
+      subject.change!('instances' => 9000)
+    end
+  end
+
+  describe '#roll_back!' do
+    subject { described_class.new({ 'id' => '/app/foo', 'instances' => 10 }) }
+
+    it 'changes the group' do
+      expect(subject).to receive(:change!).with({'version' => 'old_version' }, false)
+      subject.roll_back!('old_version')
+    end
+
+    it 'changes the group with force' do
+      expect(subject).to receive(:change!).with({'version' => 'old_version' }, true)
+      subject.roll_back!('old_version', true)
+    end
+  end
+
+  describe '.start' do
+    subject { described_class }
+
+    it 'starts the group', :vcr do
+      expect(subject.start(EXAMPLE_GROUP)).to be_instance_of(Marathon::DeploymentInfo)
+    end
+
+    it 'fails getting not existing group', :vcr do
+      expect {
+        subject.get('fooo group')
+      }.to raise_error(Marathon::Error::NotFoundError)
+    end
+  end
+
+  describe '.list' do
+    subject { described_class }
+
+    it 'lists apps', :vcr do
+      groups = subject.list
+      expect(groups).to be_instance_of(described_class)
+      expect(groups.groups.size).not_to eq(0)
+      expect(groups.groups.first).to be_instance_of(described_class)
+    end
+  end
+
+  describe '.get' do
+    subject { described_class }
+
+    it 'gets the group', :vcr do
+      group = subject.get('/test-group')
+      expect(group).to be_instance_of(described_class)
+      expect(group.id).to eq('/test-group')
+      expect(group.apps.first).to be_instance_of(Marathon::App)
+    end
+
+    it 'fails getting not existing app', :vcr do
+      expect {
+        subject.get('fooo group')
+      }.to raise_error(Marathon::Error::NotFoundError)
+    end
+  end
+
+  describe '.delete' do
+    subject { described_class }
+
+    it 'deletes the group', :vcr do
+      subject.delete('/test-group', true)
+    end
+
+    it 'fails deleting not existing app', :vcr do
+      expect {
+        subject.delete('fooo group')
+      }.to raise_error(Marathon::Error::NotFoundError)
+    end
+  end
+
+  describe '.changes' do
+    subject { described_class }
+
+    it 'changes the group', :vcr do
+      expect(subject.change('/ubuntu2', { 'instances' => 2 }))
+        .to be_instance_of(Marathon::DeploymentInfo)
+      expect(subject.change('/ubuntu2', { 'instances' => 1 }, true))
+        .to be_instance_of(Marathon::DeploymentInfo)
+    end
+  end
+
+end