marathon-api 2.0.0 → 2.0.1

data/spec/marathon/container_docker_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 CONTAINER_DOCKER_EXAMPLE = {
-    :network    => 'HOST',
-    :image      => 'felixb/yocto-httpd',
-    :privileged =>  false
-  }
+    :network => 'HOST',
+    :image => 'felixb/yocto-httpd',
+    :privileged => false
+}
 
 describe Marathon::ContainerDocker do
 
@@ -13,12 +13,12 @@ describe Marathon::ContainerDocker do
 
     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 /)
+          .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/)
+          .to raise_error(Marathon::Error::ArgumentError, /image must not be/)
     end
   end
 
@@ -27,17 +27,17 @@ describe Marathon::ContainerDocker do
 
     its(:network) { should == 'HOST' }
     its(:image) { should == 'felixb/yocto-httpd' }
-    its(:portMappings){ should == [] }
-    its(:privileged){ should == false}
+    its(:portMappings) { should == [] }
+    its(:privileged) { should == false }
   end
   describe '#privileged' do
     subject { described_class.new({
-        :network    => 'HOST',
-        :image      => 'felixb/yocto-httpd',
-        :privileged =>  true
-      })
+                                      :network => 'HOST',
+                                      :image => 'felixb/yocto-httpd',
+                                      :privileged => true
+                                  })
     }
-    its(:privileged){ should == true}
+    its(:privileged) { should == true }
   end
 
   describe '#to_s' do

data/spec/marathon/container_spec.rb

@@ -2,15 +2,15 @@ require 'spec_helper'
 
 def container_helper type
   return {
-    :type => type,
-    :docker => {
-      :image => 'felixb/yocto-httpd',
-      :portMappings => [{:containerPort => 8080}]
-    },
-    :volumes => [{
-      :containerPath => '/data',
-      :hostPath => '/var/opt/foo'
-    }]
+      :type => type,
+      :docker => {
+          :image => 'felixb/yocto-httpd',
+          :portMappings => [{:containerPort => 8080}]
+      },
+      :volumes => [{
+                       :containerPath => '/data',
+                       :hostPath => '/var/opt/foo'
+                   }]
   }
 end
 

data/spec/marathon/container_volume_spec.rb

@@ -4,7 +4,7 @@ CONTAINER_VOLUME_EXAMPLE = {
     :containerPath => '/data',
     :hostPath => '/var/opt/foo',
     :mode => 'RO'
-  }
+}
 
 describe Marathon::ContainerVolume do
 
@@ -13,14 +13,14 @@ describe Marathon::ContainerVolume do
 
     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 /)
+          .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/)
+          .to raise_error(Marathon::Error::ArgumentError, /containerPath .* not be nil/)
       expect { subject.new(:containerPath => '/') }
-        .to raise_error(Marathon::Error::ArgumentError, /hostPath .* not be nil/)
+          .to raise_error(Marathon::Error::ArgumentError, /hostPath .* not be nil/)
     end
   end
 

data/spec/marathon/deployment_action_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-DEPLOYMENT_ACTION_EXAMPLE = { "app" => "app1", "type" => "StartApplication" }
+DEPLOYMENT_ACTION_EXAMPLE = {"app" => "app1", "type" => "StartApplication"}
 
 describe Marathon::DeploymentAction do
 

data/spec/marathon/deployment_info_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 DEPLOYMENT_INFO_EXAMPLE = {
-  'deploymentId' => 'deployment-123',
-  'version' => 'version-456'
+    'deploymentId' => 'deployment-123',
+    'version' => 'version-456'
 }
 
 describe Marathon::DeploymentInfo do

data/spec/marathon/deployment_spec.rb

@@ -1,25 +1,25 @@
 require 'spec_helper'
 
 DEPLOYMENT_EXAMPLE = {
-  :affectedApps => ["/test"],
-  :id => "867ed450-f6a8-4d33-9b0e-e11c5513990b",
-  :steps => [
-      [
-          {
-              :action => "ScaleApplication",
-              :app => "/test"
-          }
-      ]
-  ],
-  :currentActions => [
-    {
-      :action => "ScaleApplication",
-      :app => "/test"
-    }
-  ],
-  :version => "2014-08-26T08:18:03.595Z",
-  :currentStep => 1,
-  :totalSteps => 1
+    :affectedApps => ["/test"],
+    :id => "867ed450-f6a8-4d33-9b0e-e11c5513990b",
+    :steps => [
+        [
+            {
+                :action => "ScaleApplication",
+                :app => "/test"
+            }
+        ]
+    ],
+    :currentActions => [
+        {
+            :action => "ScaleApplication",
+            :app => "/test"
+        }
+    ],
+    :version => "2014-08-26T08:18:03.595Z",
+    :currentStep => 1,
+    :totalSteps => 1
 }
 
 describe Marathon::Deployment do

data/spec/marathon/deployment_step_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 DEPLOYMENT_STEP_EXAMPLE = {
-  "actions" => [
-    { "app" => "app1", "type" => "StartApplication" },
-    { "app" => "app2", "type" => "StartApplication" }
-  ]
+    "actions" => [
+        {"app" => "app1", "type" => "StartApplication"},
+        {"app" => "app2", "type" => "StartApplication"}
+    ]
 }
 
 describe Marathon::DeploymentStep do

data/spec/marathon/error_spec.rb

@@ -7,22 +7,22 @@ describe Marathon::Error do
 
     it 'returns ClientError on 400' do
       expect(subject.error_class(Net::HTTPResponse.new(1.1, 400, 'Client Error')))
-        .to be(Marathon::Error::ClientError)
+          .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)
+          .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)
+          .to be(Marathon::Error::NotFoundError)
     end
 
     it 'returns UnexpectedResponseError anything else' do
       expect(subject.error_class(Net::HTTPResponse.new(1.1, 599, 'Whatever')))
-        .to be(Marathon::Error::UnexpectedResponseError)
+          .to be(Marathon::Error::UnexpectedResponseError)
     end
   end
 
@@ -30,19 +30,19 @@ describe Marathon::Error do
     subject { described_class }
 
     it 'returns "message" from respose json' do
-      r = { 'message' => 'fooo' }
+      r = {'message' => 'fooo'}
       expect(r).to receive(:parsed_response) { r }
       expect(subject.error_message(r)).to eq('fooo')
     end
 
     it 'returns "errors" from respose json' do
-      r = { 'errors' => 'fooo' }
+      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' }
+      r = {'bars' => 'fooo'}
       expect(r).to receive(:parsed_response) { r }
       expect(subject.error_message(r)).to eq(r)
     end

data/spec/marathon/group_spec.rb

@@ -1,42 +1,42 @@
 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" => []
+    "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 '#init' do
     it 'fails with group + apps' do
-      expect{described_class.new({:apps => [{:id => 'app'}], :groups => [{:id => 'group'}], :id => '/foo'},
-                                 double(Marathon::MarathonInstance))}
-        .to raise_error(Marathon::Error::ArgumentError, /Group can have either/)
+      expect { described_class.new({:apps => [{:id => 'app'}], :groups => [{:id => 'group'}], :id => '/foo'},
+                                   double(Marathon::MarathonInstance)) }
+          .to raise_error(Marathon::Error::ArgumentError, /Group can have either/)
     end
   end
 
@@ -48,7 +48,7 @@ describe Marathon::Group do
     end
 
     let(:expected_pretty_string) do
-       "Group ID:   /test-group\n" + \
+      "Group ID:   /test-group\n" + \
        "    App ID:     app\n" + \
        "    Instances:  0/1\n" + \
        "    Command:    sleep 30\n" + \
@@ -72,8 +72,8 @@ describe Marathon::Group do
 
     it 'starts the group' do
       expect(@groups).to receive(:start)
-        .with({:dependencies=>[], :id=>'/group/foo'}) do
-          Marathon::DeploymentInfo.new({ 'version' => 'new-version' }, @marathon_instance)
+                             .with({:dependencies => [], :id => '/group/foo'}) do
+        Marathon::DeploymentInfo.new({'version' => 'new-version'}, @marathon_instance)
       end
       expect(@subject.start!.version).to eq('new-version')
     end
@@ -84,12 +84,12 @@ describe Marathon::Group do
 
       @groups = double(Marathon::Groups)
       @marathon_instance = double(Marathon::MarathonInstance, :groups => @groups)
-      @subject  = described_class.new({ 'id' => '/app/foo' }, @marathon_instance)
+      @subject = described_class.new({'id' => '/app/foo'}, @marathon_instance)
     end
 
     it 'refreshes the group' do
       expect(@groups).to receive(:get).with('/app/foo') do
-        described_class.new({ 'id' => '/app/foo', 'refreshed' => true }, @marathon_instance)
+        described_class.new({'id' => '/app/foo', 'refreshed' => true}, @marathon_instance)
       end
       @subject.refresh
       expect(@subject.info[:refreshed]).to be(true)
@@ -104,26 +104,26 @@ describe Marathon::Group do
     end
 
     it 'changes the group' do
-      expect(@groups).to receive(:change).with('/app/foo', {:instances => 9000 }, false, false)
+      expect(@groups).to receive(:change).with('/app/foo', {:instances => 9000}, false, false)
       @subject.change!('instances' => 9000)
     end
 
     it 'changes the group and strips :version' do
-      expect(@groups).to receive(:change).with('/app/foo', {:instances => 9000 }, false, false)
+      expect(@groups).to receive(:change).with('/app/foo', {:instances => 9000}, false, false)
       @subject.change!('instances' => 9000, :version => 'old-version')
     end
   end
 
   describe '#roll_back!' do
-    subject { described_class.new({ 'id' => '/app/foo', 'instances' => 10 }, double(Marathon::MarathonInstance)) }
+    subject { described_class.new({'id' => '/app/foo', 'instances' => 10}, double(Marathon::MarathonInstance)) }
 
     it 'changes the group' do
-      expect(subject).to receive(:change!).with({'version' => 'old_version' }, false)
+      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)
+      expect(subject).to receive(:change!).with({'version' => 'old_version'}, true)
       subject.roll_back!('old_version', true)
     end
   end
@@ -156,7 +156,7 @@ describe Marathon::Group do
   describe '.get' do
     subject { described_class }
 
-      it 'gets the group', :vcr do
+    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')
@@ -174,15 +174,15 @@ describe Marathon::Group do
     subject { described_class }
 
     it 'previews changes', :vcr do
-      steps = subject.change('/test-group', { 'instances' => 20 }, false, true)
+      steps = subject.change('/test-group', {'instances' => 20}, false, true)
       expect(steps).to be_instance_of(Array)
     end
 
     it 'changes the group', :vcr do
-      expect(subject.change('/test-group', { 'instances' => 2 }, true))
-        .to be_instance_of(Marathon::DeploymentInfo)
-      expect(subject.change('/test-group', { 'instances' => 1 }, true))
-        .to be_instance_of(Marathon::DeploymentInfo)
+      expect(subject.change('/test-group', {'instances' => 2}, true))
+          .to be_instance_of(Marathon::DeploymentInfo)
+      expect(subject.change('/test-group', {'instances' => 1}, true))
+          .to be_instance_of(Marathon::DeploymentInfo)
     end
   end
 
@@ -191,7 +191,7 @@ describe Marathon::Group do
 
     it 'deletes the group', :vcr do
       expect(subject.delete('/test-group', true))
-        .to be_instance_of(Marathon::DeploymentInfo)
+          .to be_instance_of(Marathon::DeploymentInfo)
     end
 
     it 'fails deleting not existing app', :vcr do

data/spec/marathon/marathon_spec.rb

@@ -48,7 +48,7 @@ describe Marathon do
     it 'adds :basic_auth options for :username and :password' do
       described_class.options = {:username => 'user', :password => 'password'}
       expect(described_class.connection.options)
-        .to eq({:basic_auth => {:username => 'user', :password => 'password'}})
+          .to eq({:basic_auth => {:username => 'user', :password => 'password'}})
 
       # reset connection after running this spec
       described_class.options = nil

data/spec/marathon/queue_spec.rb

@@ -4,9 +4,9 @@ describe Marathon::Queue do
 
   describe '#attributes' do
     subject { described_class.new({
-        'app'   => { 'id' => '/app/foo' },
-        'delay' => { 'overdue' => true }
-    }, double(Marathon::MarathonInstance)) }
+                                      'app' => {'id' => '/app/foo'},
+                                      'delay' => {'overdue' => true}
+                                  }, double(Marathon::MarathonInstance)) }
 
     it 'has app' do
       expect(subject.app).to be_instance_of(Marathon::App)
@@ -25,9 +25,9 @@ describe Marathon::Queue do
 
   describe '#to_s' do
     subject { described_class.new({
-        'app'   => { 'id' => '/app/foo' },
-        'delay' => { 'overdue' => true }
-      }, double(Marathon::MarathonInstance)) }
+                                      'app' => {'id' => '/app/foo'},
+                                      'delay' => {'overdue' => true}
+                                  }, double(Marathon::MarathonInstance)) }
 
     let(:expected_string) do
       'Marathon::Queue { :appId => /app/foo :delay => {:overdue=>true} }'
@@ -38,9 +38,9 @@ describe Marathon::Queue do
 
   describe '#to_json' do
     subject { described_class.new({
-        'app'   => { 'id' => '/app/foo' },
-        'delay' => { 'overdue' => true }
-      }, double(Marathon::MarathonInstance)) }
+                                      'app' => {'id' => '/app/foo'},
+                                      'delay' => {'overdue' => true}
+                                  }, double(Marathon::MarathonInstance)) }
 
     let(:expected_string) do
       '{"app":{"id":"/app/foo"},"delay":{"overdue":true}}'