marathon-api 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 23bb47d2d3c76218c3aa461968660ac5551e3f76
-  data.tar.gz: ce1149c5f48884ecd403b69e61fb9ab12f8e0b3b
+  metadata.gz: 37c0d0ae7d91ddeaa7861bffa40b81e72a434e19
+  data.tar.gz: c5d165cf0d590a78fea207dfc705fa409174a8a5
 SHA512:
-  metadata.gz: 7fca9778495fc930fe67d956a7db8e749f08c56e2e0bcce4320bac3dfbf94ac6d1025909135c573e06938fa2c27705b1a2d7f774a8713830192d768c27990faa
-  data.tar.gz: 6301fea04cd2a18a89aa6dd59a52c46b79d2ee8a6a580131783661c249021e75750aa758c19c7efad99dad13621e24243f64270654f29b6d3aa672c75f00684d
+  metadata.gz: 941597d6ae53616a9931735f9a016606933df061115ff21eb1202325388d785e8e824dedc64e00d3fd64725f2560aac1bfdec0758d3b22ad57245b485f94dcdd
+  data.tar.gz: 56afa004de719231016576cba81c13f2553d50e7378e9b79a05f68f5b8664e0ac52b0fa25f2df69f7f29710598f64b5809dfdaff39e1263efd43e4cccb0c828e

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2014 Swipely, Inc.
+Copyright (c) 2015 Otto (GmbH & Co KG)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -102,6 +102,12 @@ apps.last.delete!
 
 The other Marathon endpoints are available in the same way.
 
+Contributing
+------------
+
+Please fork and send pull request.
+Make sure to have test cases for your changes.
+
 Credits
 -------
 

data/bin/marathon

@@ -46,9 +46,9 @@ def subcmd_start(cmd_opts)
     if cmd_opts[:json]
       path = cmd_opts[:json]
       if path == '-'
-        app_opts = Marathon::Util.keywordize_hash(JSON.parse($stdin.read))
+        app_opts = Marathon::Util.keywordize_hash!(JSON.parse($stdin.read))
       elsif File.exists?(path)
-        app_opts = Marathon::Util.keywordize_hash(JSON.parse(File.read(cmd_opts[:json])))
+        app_opts = Marathon::Util.keywordize_hash!(JSON.parse(File.read(cmd_opts[:json])))
       else
         raise Marathon::Error::ArgumentError, "File '#{path}' does not exist"
       end
@@ -231,12 +231,10 @@ def run_subcmd(cmd, cmd_opts)
   end
 end
 
-if __FILE__ == $0
-  global_opts = parse_global_opts
-  set_global_opts(global_opts)
+global_opts = parse_global_opts
+set_global_opts(global_opts)
 
-  cmd = parse_subcmd
-  cmd_opts = parse_subcmd_opts(cmd)
+cmd = parse_subcmd
+cmd_opts = parse_subcmd_opts(cmd)
 
-  run_subcmd(cmd, cmd_opts)
-end
+run_subcmd(cmd, cmd_opts)

data/lib/marathon/app.rb

@@ -6,13 +6,12 @@ class Marathon::App < Marathon::Base
                   storeUris tasksRunning tasksStaged uris user version ]
 
   DEFAULTS = {
-    :constraints => [],
     :env => {},
     :ports => [],
     :uris => []
   }
 
-  attr_reader :read_only
+  attr_reader :healthChecks, :constraints, :container, :read_only, :tasks
 
   # Create a new application object.
   # ++hash++: Hash including all attributes.
@@ -22,6 +21,7 @@ class Marathon::App < Marathon::Base
     super(Marathon::Util.merge_keywordized_hash(DEFAULTS, hash), ACCESSORS)
     raise ArgumentError, 'App must have an id' unless id
     @read_only = read_only
+    refresh_attributes
   end
 
   # Prevent actions on read only instances.
@@ -32,40 +32,6 @@ class Marathon::App < Marathon::Base
     end
   end
 
-  # Get container info.
-  # This is read only!
-  def container
-    if @info[:container]
-      Marathon::Container.new(@info[:container])
-    else
-      nil
-    end
-  end
-
-  # Get constrains.
-  # This is read only!
-  def constraints
-    @info[:constraints].map { |e| Marathon::Constraint.new(e) }
-  end
-
-  # Get health checks.
-  # This is read only!
-  def healthChecks
-    @info[:healthChecks].map { |e| Marathon::HealthCheck.new(e) }
-  end
-
-  # List all running tasks for the application.
-  # This is read only!
-  def tasks
-    check_read_only
-    unless @info[:tasks]
-      refresh
-    end
-
-    raise UnexpectedResponseError, "Expected to find tasks element in app's info" unless @info[:tasks]
-    @info[:tasks].map { |e| Marathon::Task.new(e) }
-  end
-
   # List the versions of the application.
   # ++version++: Get a specific versions
   # Returns Array of Strings if ++version = nil++,
@@ -83,13 +49,14 @@ class Marathon::App < Marathon::Base
     check_read_only
     new_app = self.class.get(id)
     @info = new_app.info
+    refresh_attributes
   end
 
   # Create and start the application.
-  def start!
-    check_read_only
-    new_app = self.class.start(info)
-    @info = new_app.info
+  # ++force++: If the app is affected by a running deployment, then the update operation will fail.
+  #            The current deployment can be overridden by setting the `force` query parameter.
+  def start!(force = false)
+    change!(info, force)
   end
 
   # Initiates a rolling restart of all running tasks of the given app.
@@ -109,7 +76,14 @@ class Marathon::App < Marathon::Base
   #            The current deployment can be overridden by setting the `force` query parameter.
   def change!(hash, force = false)
     check_read_only
-    self.class.change(id, hash, force)
+    Marathon::Util.keywordize_hash!(hash)
+    if hash[:version] and hash.size > 1
+      # remove :version if it's not the only key
+      new_hash = Marathon::Util.remove_keys(hash, [:version])
+    else
+      new_hash = hash
+    end
+    self.class.change(id, new_hash, force)
   end
 
   # Create a new version with parameters of an old version.
@@ -118,7 +92,7 @@ class Marathon::App < Marathon::Base
   # ++force++: If the app is affected by a running deployment, then the update operation will fail.
   #            The current deployment can be overridden by setting the `force` query parameter.
   def roll_back!(version, force = false)
-    change!({'version' => version}, force)
+    change!({:version => version}, force)
   end
 
   # Change the number of desired instances.
@@ -126,7 +100,7 @@ class Marathon::App < Marathon::Base
   # ++force++: If the app is affected by a running deployment, then the update operation will fail.
   #            The current deployment can be overridden by setting the `force` query parameter.
   def scale!(instances, force = false)
-    change!({'instances' => instances}, force)
+    change!({:instances => instances}, force)
   end
 
   # Change the number of desired instances to 0.
@@ -169,6 +143,18 @@ Version:    #{version}
     constraints.map { |e| "Constraint: #{e.to_pretty_s}" }.join("\n")
   end
 
+  # Rebuild attribute classes
+  def refresh_attributes
+    @healthChecks = (info[:healthChecks] || []).map { |e| Marathon::HealthCheck.new(e) }
+    @constraints = (info[:constraints] || []).map { |e| Marathon::Constraint.new(e) }
+    if info[:container]
+      @container = Marathon::Container.new(info[:container])
+    else
+      @container = nil
+    end
+    @tasks = (@info[:tasks] || []).map { |e| Marathon::Task.new(e) }
+  end
+
   class << self
 
     # List the application with id.

data/lib/marathon/base.rb

@@ -7,13 +7,13 @@ class Marathon::Base
 
   # Create the object
   # ++hash++: object returned from API. May be Hash or Array.
-  # ++attr_readers++: List of attribute readers.
-  def initialize(hash, attr_readers = [])
-    raise ArgumentError, 'hash must be a Hash' if attr_readers and attr_readers.size > 0 and not hash.is_a?(Hash)
+  # ++attr_accessors++: List of attribute accessors.
+  def initialize(hash, attr_accessors = [])
+    raise ArgumentError, 'hash must be a Hash' if attr_accessors and attr_accessors.size > 0 and not hash.is_a?(Hash)
     raise ArgumentError, 'hash must be Hash or Array' unless hash.is_a?(Hash) or hash.is_a?(Array)
-    raise ArgumentError, 'attr_readers must be an Array' unless attr_readers.is_a?(Array)
-    @info = Marathon::Util.keywordize_hash(hash)
-    attr_readers.each { |e| add_attr_reader(e) }
+    raise ArgumentError, 'attr_accessors must be an Array' unless attr_accessors.is_a?(Array)
+    @info = Marathon::Util.keywordize_hash!(hash)
+    attr_accessors.each { |e| add_attr_accessor(e) }
   end
 
   # Return application as JSON formatted string.
@@ -23,10 +23,11 @@ class Marathon::Base
 
   private
 
-  # Create attr_reader for @info[key].
+  # Create attr_accessor for @info[key].
   # ++key++: key in @info
-  def add_attr_reader(key)
+  def add_attr_accessor(key)
     sym = key.to_sym
-    self.class.send(:define_method, sym.id2name) { |*args, &block| info[sym] }
+    self.class.send(:define_method, sym.id2name) { info[sym] }
+    self.class.send(:define_method, "#{sym.id2name}=") { |v| info[sym] = v }
   end
-end
+end

data/lib/marathon/container.rb

@@ -10,27 +10,15 @@ class Marathon::Container < Marathon::Base
     :volumes => []
   }
 
+  attr_reader :docker, :volumes
+
   # Create a new container object.
   # ++hash++: Hash returned by API.
   def initialize(hash)
     super(Marathon::Util.merge_keywordized_hash(DEFAULTS, hash), ACCESSORS)
     Marathon::Util.validate_choice('type', type, SUPPERTED_TYPES)
-  end
-
-  # Get container's docker information.
-  # This is read only!
-  def docker
-    if @info[:docker]
-      Marathon::ContainerDocker.new(@info[:docker])
-    else
-      nil
-    end
-  end
-
-  # Get container's volumes.
-  # This is read only!
-  def volumes
-    @info[:volumes].map { |e| Marathon::ContainerVolume.new(e) }
+    @docker = Marathon::ContainerDocker.new(info[:docker]) if info[:docker]
+    @volumes = info[:volumes].map { |e| Marathon::ContainerVolume.new(e) }
   end
 
   def to_s
@@ -38,4 +26,4 @@ class Marathon::Container < Marathon::Base
     + " :volumes => #{Marathon::Util.items_to_pretty_s(volumes)} }"
   end
 
-end
+end

data/lib/marathon/container_docker.rb

@@ -8,18 +8,15 @@ class Marathon::ContainerDocker < Marathon::Base
     :portMappings => []
   }
 
+  attr_reader :portMappings
+
   # Create a new container docker object.
   # ++hash++: Hash returned by API.
   def initialize(hash)
     super(Marathon::Util.merge_keywordized_hash(DEFAULTS, hash), ACCESSORS)
     Marathon::Util.validate_choice('network', network, %w[BRIDGE HOST])
     raise Marathon::Error::ArgumentError, 'image must not be nil' unless image
-  end
-
-  # Get container's port mappings.
-  # This is read only!
-  def portMappings
-    @info[:portMappings].map { |e| Marathon::ContainerDockerPortMapping.new(e) }
+    @portMappings = (info[:portMappings] || []).map { |e| Marathon::ContainerDockerPortMapping.new(e) }
   end
 
   def to_pretty_s
@@ -30,4 +27,4 @@ class Marathon::ContainerDocker < Marathon::Base
     "Marathon::ContainerDocker { :image => #{image} }"
   end
 
-end
+end

data/lib/marathon/group.rb

@@ -5,36 +5,26 @@ class Marathon::Group < Marathon::Base
   ACCESSORS = %w[ id dependencies version ]
 
   DEFAULTS = {
-    :apps => [],
-    :dependencies => [],
-    :groups => []
+    :dependencies => []
   }
 
+  attr_reader :apps, :groups
+
   # Create a new group object.
   # ++hash++: Hash including all attributes.
   #           See https://mesosphere.github.io/marathon/docs/rest-api.html#post-/v2/groups for full details.
   def initialize(hash)
     super(Marathon::Util.merge_keywordized_hash(DEFAULTS, hash), ACCESSORS)
     raise ArgumentError, 'Group must have an id' unless id
+    refresh_attributes
     raise ArgumentError, 'Group can have either groups or apps, not both' if apps.size > 0 and groups.size > 0
   end
 
-  # Get apps.
-  # This is read only!
-  def apps
-    @info[:apps].map { |e| Marathon::App.new(e) }
-  end
-
-  # Get groups.
-  # This is read only!
-  def groups
-    @info[:groups].map { |e| Marathon::Group.new(e) }
-  end
-
   # Reload attributes from marathon API.
   def refresh
     new_app = self.class.get(id)
     @info = new_app.info
+    refresh_attributes
   end
 
   # Create and start a the application group. Application groups can contain other application groups.
@@ -65,7 +55,14 @@ class Marathon::Group < Marathon::Base
   # ++force++: If the group is affected by a running deployment, then the update operation will fail.
   #            The current deployment can be overridden by setting the `force` query parameter.
   def change!(hash, force = false)
-    self.class.change(id, hash, force)
+    Marathon::Util.keywordize_hash!(hash)
+    if hash[:version] and hash.size > 1
+      # remove :version if it's not the only key
+      new_hash = Marathon::Util.remove_keys(hash, [:version])
+    else
+      new_hash = hash
+    end
+    self.class.change(id, new_hash, force)
   end
 
   # Create a new version with parameters of an old version.
@@ -97,6 +94,12 @@ Version:    #{version}
     array.map { |e| e.to_pretty_s.split("\n").map { |e| "    #{e}" }}.join("\n")
   end
 
+  # Rebuild attribute classes
+  def refresh_attributes
+    @apps = (info[:apps] || []).map { |e| Marathon::App.new(e) }
+    @groups = (info[:groups] || []).map { |e| Marathon::Group.new(e) }
+  end
+
   class << self
 
     # List the group with the specified ID.

data/lib/marathon/util.rb

@@ -40,21 +40,33 @@ class Marathon::Util
 
     # Swap keys of the hash against their symbols.
     # ++hash++: the hash
-    def keywordize_hash(hash)
+    # ++ignore_keys++: don't keywordize hashes under theses keys
+    def keywordize_hash!(hash, ignore_keys = [:env])
       if hash.is_a?(Hash)
-        new_hash = {}
-        hash.each do |k,v|
+        hmap!(hash) do |k,v|
           key = k.to_sym
-          if key == :env and v.is_a?(Hash)
-            # ignore :env => {} to prevent renameing environment variables
-            new_hash[key] = hash[k]
+          if ignore_keys.include?(key) and v.is_a?(Hash)
+            { key => v }
           else
-            new_hash[key] = keywordize_hash(hash[k])
+            { key => keywordize_hash!(v) }
           end
         end
+      elsif hash.is_a?(Array)
+        hash.map! { |e| keywordize_hash!(e) }
+      end
+      hash
+    end
+
+    # Remove keys from hash and all it's sub hashes.
+    # ++hash++: the hash
+    # ++keys++: list of keys to remove
+    def remove_keys(hash, keys)
+      if hash.is_a?(Hash)
+        new_hash = {}
+        hash.each { |k,v| new_hash[k] = remove_keys(v, keys) unless keys.include?(k) }
         new_hash
       elsif hash.is_a?(Array)
-        hash.map { |e| keywordize_hash(e) }
+        hash.map { |e| remove_keys(e, keys) }
       else
         hash
       end
@@ -62,7 +74,7 @@ class Marathon::Util
 
     # Merge two hashes but keywordize both.
     def merge_keywordized_hash(h1, h2)
-      keywordize_hash(h1).merge(keywordize_hash(h2))
+      keywordize_hash!(h1).merge(keywordize_hash!(h2))
     end
 
     # Stringify an item or an array of items.
@@ -75,5 +87,16 @@ class Marathon::Util
         item.to_pretty_s
       end
     end
+
+    # Implement map! on a hash
+    def hmap!(hash, &block)
+      hash.keys.each do |key|
+        new_hash = block.call(key, hash[key])
+        new_key = new_hash.keys.first
+        hash[new_key] = new_hash[new_key]
+        hash.delete(key) unless key == new_key
+      end
+      hash
+    end
   end
 end

data/lib/marathon/version.rb

@@ -1,3 +1,3 @@
 module Marathon
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/spec/marathon/app_spec.rb

@@ -38,7 +38,7 @@ describe Marathon::App do
     subject { described_class.new({ 'id' => '/app/foo' }) }
 
     let(:expected_string) do
-      '{"constraints":[],"env":{},"ports":[],"uris":[],"id":"/app/foo"}'
+      '{"env":{},"ports":[],"uris":[],"id":"/app/foo"}'
     end
 
     its(:to_json) { should == expected_string }
@@ -84,26 +84,6 @@ describe Marathon::App do
   describe '#tasks' do
     subject { described_class.new({ 'id' => '/ubuntu2' }) }
 
-    it 'checks for read only' do
-      expect(subject).to receive(:check_read_only)
-      subject.info[:tasks] = []
-      subject.tasks
-    end
-
-    it 'has tasks', :vcr do
-      tasks = subject.tasks
-      expect(tasks).to be_instance_of(Array)
-      expect(tasks.size).to eq(1)
-      expect(tasks.first).to be_instance_of(Marathon::Task)
-      expect(tasks.first.appId).to eq(subject.id)
-    end
-
-    it 'loads tasks from API when not loaded already' do
-      subject.info[:tasks] = nil
-      expect(subject).to receive(:refresh) { subject.info[:tasks] = [] }
-      expect(subject.tasks).to eq([])
-    end
-
     it 'shows already loaded tasks w/o API call' do
       subject.info[:tasks] = []
       expect(subject).not_to receive(:refresh)
@@ -132,17 +112,22 @@ describe Marathon::App do
 
     it 'checks for read only' do
       expect(subject).to receive(:check_read_only)
-      expect(described_class).to receive(:start) { described_class.new('id' => subject.id) }
+      expect(described_class).to receive(:change).with(
+          '/app/foo',
+          {:env=>{}, :ports=>[], :uris=>[], :id=>"/app/foo"},
+          false
+        )
       subject.start!
     end
 
     it 'starts the app' do
-      expect(described_class).to receive(:start)
-        .with({:constraints=>[], :env=>{}, :ports=>[], :uris=>[], :id=>"/app/foo"}) do
-          described_class.new({ 'id' => '/app/foo', 'started' => true })
-      end
+      expect(described_class).to receive(:change)
+        .with(
+          '/app/foo',
+          {:env=>{}, :ports=>[], :uris=>[], :id=>"/app/foo"},
+          false
+        )
       subject.start!
-      expect(subject.info[:started]).to be(true)
     end
   end
 
@@ -196,13 +181,13 @@ describe Marathon::App do
     end
 
     it 'changes the app' do
-      expect(described_class).to receive(:change).with('/app/foo', {'instances' => 9000 }, false)
-      subject.change!('instances' => 9000)
+      expect(described_class).to receive(:change).with('/app/foo', {:instances => 9000 }, false)
+      subject.change!('instances' => 9000, 'version' => 'old-version')
     end
   end
 
   describe '#roll_back!' do
-    subject { described_class.new({ 'id' => '/app/foo', 'instances' => 10 }) }
+    subject { described_class.new({:id => '/app/foo', :instances => 10}) }
 
     it 'checks for read only' do
       expect(subject).to receive(:check_read_only)
@@ -211,18 +196,18 @@ describe Marathon::App do
     end
 
     it 'changes the app' 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 app 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
 
   describe '#scale!' do
-    subject { described_class.new({ 'id' => '/app/foo', 'instances' => 10 }) }
+    subject { described_class.new({:id => '/app/foo', :instances => 10}) }
 
     it 'checks for read only' do
       expect(subject).to receive(:check_read_only)
@@ -231,18 +216,18 @@ describe Marathon::App do
     end
 
     it 'changes the app' do
-      expect(subject).to receive(:change!).with({'instances' => 9000 }, false)
+      expect(subject).to receive(:change!).with({:instances => 9000}, false)
       subject.scale!(9000)
     end
 
     it 'changes the app with force' do
-      expect(subject).to receive(:change!).with({'instances' => 9000 }, true)
+      expect(subject).to receive(:change!).with({:instances => 9000}, true)
       subject.scale!(9000, true)
     end
   end
 
   describe '#suspend!' do
-    subject { described_class.new({ 'id' => '/app/foo', 'instances' => 10 }) }
+    subject { described_class.new({'id' => '/app/foo', :instances => 10}) }
 
     it 'checks for read only' do
       expect(subject).to receive(:check_read_only)
@@ -290,7 +275,14 @@ describe Marathon::App do
     subject { described_class }
 
     it 'starts the app', :vcr do
-      app = subject.start({ :id => '/test', :cmd => 'sleep 10', :instances => 1, :cpus => 0.1, :mem => 32})
+      app = subject.start({
+        :id => '/test',
+        :cmd => 'sleep 10',
+        :instances => 1,
+        :cpus => 0.1,
+        :mem => 32,
+        :version => 'foo-version'
+      })
       expect(app).to be_instance_of(described_class)
       expect(app.id).to eq('/test')
       expect(app.instances).to eq(1)

data/spec/marathon/base_spec.rb

@@ -22,7 +22,7 @@ describe Marathon::Base do
       }) }
 
     let(:expected_string) do
-      '{"app":{"id":"/app/foo"},"foo":"blubb","bar":1}'
+      '{"foo":"blubb","bar":1,"app":{"id":"/app/foo"}}'
     end
 
     its(:to_json) { should == expected_string }
@@ -50,4 +50,4 @@ describe Marathon::Base do
     its(:bar) { should == 1 }
   end
 
-end
+end

data/spec/marathon/deployment_spec.rb

@@ -1,25 +1,25 @@
 require 'spec_helper'
 
 DEPLOYMENT_EXAMPLE = {
-  "affectedApps" => ["/test"],
-  "id" => "867ed450-f6a8-4d33-9b0e-e11c5513990b",
-  "steps" => [
+  :affectedApps => ["/test"],
+  :id => "867ed450-f6a8-4d33-9b0e-e11c5513990b",
+  :steps => [
       [
           {
-              "action" => "ScaleApplication",
-              "app" => "/test"
+              :action => "ScaleApplication",
+              :app => "/test"
           }
       ]
   ],
-  "currentActions" => [
+  :currentActions => [
     {
-      "action" => "ScaleApplication",
-      "app" => "/test"
+      :action => "ScaleApplication",
+      :app => "/test"
     }
   ],
-  "version" => "2014-08-26T08:18:03.595Z",
-  "currentStep" => 1,
-  "totalSteps" => 1
+  :version => "2014-08-26T08:18:03.595Z",
+  :currentStep => 1,
+  :totalSteps => 1
 }
 
 describe Marathon::Deployment do
@@ -44,23 +44,23 @@ describe Marathon::Deployment do
   describe 'attributes' do
     subject { described_class.new(DEPLOYMENT_EXAMPLE) }
 
-    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'] }
+    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(DEPLOYMENT_EXAMPLE) }
 
     it 'deletes the deployment' do
-      expect(described_class).to receive(:delete).with(DEPLOYMENT_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(DEPLOYMENT_EXAMPLE['id'], true)
+      expect(described_class).to receive(:delete).with(DEPLOYMENT_EXAMPLE[:id], true)
       subject.delete(true)
     end
   end
@@ -70,9 +70,9 @@ describe Marathon::Deployment do
 
     it 'lists deployments', :vcr do
       # start a deployment
-      Marathon::App.change('/test', {'instances' => 0})
+      Marathon::App.change('/test', {:instances => 0})
       sleep 1
-      Marathon::App.change('/test', {'instances' => 2})
+      Marathon::App.change('/test', {:instances => 2})
       sleep 1
 
       deployments = subject.list
@@ -86,9 +86,9 @@ describe Marathon::Deployment do
 
     it 'deletes deployments', :vcr do
       # start a deployment
-      info = Marathon::App.change('/test', {'instances' => 1})
+      info = Marathon::App.change('/test', {:instances => 1})
       expect(subject.delete(info.deploymentId)).to be_instance_of(Marathon::DeploymentInfo)
     end
   end
 
-end
+end

data/spec/marathon/group_spec.rb

@@ -23,11 +23,13 @@ EXAMPLE_GROUP = {
           "upgradeStrategy" => {
               "minimumHealthCapacity" => 1.0
           },
-          "tasks" => []
+          "tasks" => [],
+          "version" => 'foo-version'
       }
   ],
   "dependencies" => [],
-  "groups" => []
+  "groups" => [],
+  "version" => 'foo-version'
 }
 
 describe Marathon::Group do
@@ -46,8 +48,8 @@ describe Marathon::Group do
        "    Command:    sleep 30\n" + \
        "    CPUs:       1.0\n" + \
        "    Memory:     128.0 MB\n" + \
-       "    Version:\n" + \
-       "Version:"
+       "    Version:    foo-version\n" + \
+       "Version:    foo-version"
 
     end
 
@@ -60,7 +62,7 @@ describe Marathon::Group do
 
     it 'starts the group' do
       expect(described_class).to receive(:start)
-        .with({:apps=>[], :dependencies=>[], :groups=>[], :id=>'/group/foo'}) do
+        .with({:dependencies=>[], :id=>'/group/foo'}) do
           Marathon::DeploymentInfo.new({ 'version' => 'new-version' })
       end
       expect(subject.start!.version).to eq('new-version')
@@ -83,9 +85,14 @@ describe Marathon::Group 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)
+      expect(described_class).to receive(:change).with('/app/foo', {:instances => 9000 }, false)
       subject.change!('instances' => 9000)
     end
+
+    it 'changes the group and strips :version' do
+      expect(described_class).to receive(:change).with('/app/foo', {:instances => 9000 }, false)
+      subject.change!('instances' => 9000, :version => 'old-version')
+    end
   end
 
   describe '#roll_back!' do

data/spec/marathon/util_spec.rb

@@ -41,23 +41,46 @@ describe Marathon::Util do
     end
   end
 
-  describe '.keywordize_hash' do
+  describe '.keywordize_hash!' do
     subject { described_class }
 
     it 'keywordizes the hash' do
-      expect(subject.keywordize_hash({
-        'foo'  => 'bar',
-        'f00'  => {'w00h00'  => 'yeah'},
-        'bang' => [{'tricky' => 'one'}],
-        'env'  => {'foo' => 'bar'},
-        'null' => nil
-      })).to eq({
+      hash = {
+        'foo'      => 'bar',
+        'f00'      => {'w00h00'  => 'yeah'},
+        'bang'     => [{'tricky' => 'one'}],
+        'env'      => {'foo' => 'bar'},
+        'null'     => nil
+      }
+
+      expect(subject.keywordize_hash!(hash)).to eq({
         :foo  => 'bar',
         :f00  => {:w00h00  => 'yeah'},
         :bang => [{:tricky => 'one'}],
         :env  => {'foo' => 'bar'},
         :null => nil
       })
+      # make sure, it changes the hash w/o creating a new one
+      expect(hash[:foo]).to eq('bar')
+    end
+  end
+
+  describe '.remove_keys' do
+    subject { described_class }
+
+    it 'removes keys from hash' do
+      hash = {
+        :foo      => 'bar',
+        :deleteme => {'w00h00'  => 'yeah'},
+        :blah     => [{:deleteme => :foo}, 1]
+      }
+
+      expect(subject.remove_keys(hash, [:deleteme])).to eq({
+        :foo  => 'bar',
+        :blah => [{}, 1]
+      })
+      # make sure, it does not changes the original hash
+      expect(hash.size).to eq(3)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: marathon-api
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Felix Bechstein
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-09 00:00:00.000000000 Z
+date: 2015-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json