pogo 2.32.14 → 2.39.2

data/lib/heroku/command/sharing.rb

@@ -13,7 +13,7 @@ module Heroku::Command
     #Example:
     #
     # $ heroku sharing
-    # === myapp Collaborators
+    # === example Collaborators
     # collaborator@example.com
     # email@example.com
     #
@@ -33,7 +33,7 @@ module Heroku::Command
     #Example:
     #
     # $ heroku sharing:add collaborator@example.com
-    # Adding collaborator@example.com to myapp collaborators... done
+    # Adding collaborator@example.com to example collaborators... done
     #
     def add
       unless email = shift_argument
@@ -53,7 +53,7 @@ module Heroku::Command
     #Example:
     #
     # $ heroku sharing:remove collaborator@example.com
-    # Removing collaborator@example.com to myapp collaborators... done
+    # Removing collaborator@example.com to example collaborators... done
     #
     def remove
       unless email = shift_argument
@@ -73,7 +73,7 @@ module Heroku::Command
     #Example:
     #
     # $ heroku sharing:transfer collaborator@example.com
-    # Transferring myapp to collaborator@example.com... done
+    # Transferring example to collaborator@example.com... done
     #
     def transfer
       unless email = shift_argument

data/lib/heroku/command/ssl.rb

@@ -2,13 +2,15 @@ require "heroku/command/base"
 
 module Heroku::Command
 
+  # DEPRECATED: see `heroku certs` instead
+  #
   # manage ssl certificates for an app
   #
   class Ssl < Base
 
     # ssl
     #
-    # list certificates for an app
+    # list legacy certificates for an app
     #
     def index
       api.get_domains(app).body.each do |domain|
@@ -22,36 +24,16 @@ module Heroku::Command
 
     # ssl:add PEM KEY
     #
-    # add an ssl certificate to an app
+    # DEPRECATED: see `heroku certs:add` instead
     #
     def add
-      pem_file = args.shift
-      key_file = args.shift
-      fail "Usage: heroku ssl:add PEM KEY" unless pem_file && key_file
-      raise CommandFailed, "Missing pem file." unless pem_file
-      raise CommandFailed, "Missing key file." unless key_file
-      raise CommandFailed, "Could not find pem in #{pem_file}"  unless File.exists?(pem_file)
-      raise CommandFailed, "Could not find key in #{key_file}"  unless File.exists?(key_file)
-
-      pem  = File.read(pem_file)
-      key  = File.read(key_file)
-      info = heroku.add_ssl(app, pem, key)
-      display "Added certificate to #{info['domain']}, expiring at #{info['expires_at']}"
-    end
-
-    # ssl:remove DOMAIN
-    #
-    # remove an ssl certificate from an app
-    #
-    def remove
-      raise CommandFailed, "Missing domain. Usage:\nheroku ssl:remove <domain>" unless domain = args.shift
-      heroku.remove_ssl(app, domain)
-      display "Removed certificate from #{domain}"
+      $stderr.puts " !    `heroku ssl:add` has been deprecated. Please use the SSL Endpoint add-on and the `heroku certs` commands instead."
+      $stderr.puts " !    SSL Endpoint documentation is available at: https://devcenter.heroku.com/articles/ssl-endpoint"
     end
 
     # ssl:clear
     #
-    # remove all ssl certificates from an app
+    # remove legacy ssl certificates from an app
     #
     def clear
       heroku.clear_ssl(app)

data/lib/heroku/command/stack.rb

@@ -12,7 +12,7 @@ module Heroku::Command
     #Example:
     #
     # $ heroku stack
-    # === myapp Available Stacks
+    # === example Available Stacks
     #   bamboo-mri-1.9.2
     #   bamboo-ree-1.8.7
     # * cedar

data/lib/heroku/helpers/heroku_postgresql.rb

@@ -61,17 +61,6 @@ module Heroku::Helpers::HerokuPostgresql
       @hpg_databases['DATABASE_URL'] = find_database_url_real_attachment
     end
 
-    if app_config_vars['SHARED_DATABASE_URL']
-      @hpg_databases['SHARED_DATABASE'] = Attachment.new({
-        'config_var' => 'SHARED_DATABASE',
-        'resource' => {
-            'name'  => 'SHARED_DATABASE',
-            'value' => app_config_vars['SHARED_DATABASE_URL'],
-            'type'  => 'shared:database'
-          }
-        })
-    end
-
     return @hpg_databases
   end
 
@@ -82,11 +71,15 @@ module Heroku::Helpers::HerokuPostgresql
   def forget_config!
     @hpg_databases   = nil
     @app_config_vars = nil
+    @app_attachments = nil
   end
 
   def find_database_url_real_attachment
-    primary_db_url = app_config_vars['DATABASE_URL']
-    return unless primary_db_url
+    raw_primary_db_url = app_config_vars['DATABASE_URL']
+    return unless raw_primary_db_url
+
+    primary_db_url = raw_primary_db_url.split("?").first
+    return unless primary_db_url && !primary_db_url.empty?
 
     real_config = app_config_vars.detect {|k,v| k != 'DATABASE_URL' && v == primary_db_url }
     if real_config
@@ -113,11 +106,11 @@ module Heroku::Helpers::HerokuPostgresql
     end
 
     found_attachment = nil
-    canidates = match_attachments_by_name(name)
+    candidates = match_attachments_by_name(name)
     if default && name.empty? && app_config_vars[default]
       found_attachment = hpg_databases[default]
-    elsif canidates.size == 1
-      found_attachment = hpg_databases[canidates.first]
+    elsif candidates.size == 1
+      found_attachment = hpg_databases[candidates.first]
     end
 
     if found_attachment.nil?
@@ -132,7 +125,7 @@ module Heroku::Helpers::HerokuPostgresql
       %w[fork follow].each do |opt|
         if val = config[opt]
           unless val.is_a?(String)
-            error("--#{opt} requires a database argument")
+            error("--#{opt} requires a database argument.")
           end
 
           uri = URI.parse(val) rescue nil
@@ -140,6 +133,9 @@ module Heroku::Helpers::HerokuPostgresql
             argument_url = uri.to_s
           else
             attachment = hpg_resolve(val)
+            if attachment.starter_plan?
+              error("#{opt.tr 'f', 'F'} is only available on production databases.")
+            end
             argument_url = attachment.url
           end
 

data/lib/heroku/helpers/log_displayer.rb

@@ -0,0 +1,70 @@
+require "heroku/helpers"
+
+module Heroku::Helpers
+  class LogDisplayer
+
+    include Heroku::Helpers
+
+    attr_reader :heroku, :app, :opts
+
+    def initialize(heroku, app, opts)
+      @heroku, @app, @opts = heroku, app, opts
+    end
+
+    def display_logs
+      @assigned_colors = {}
+      @line_start = true
+      @token = nil
+
+      heroku.read_logs(app, opts) do |chunk|
+        unless chunk.empty?
+          if STDOUT.isatty && ENV.has_key?("TERM")
+            display(colorize(chunk))
+          else
+            display(chunk)
+          end
+        end
+      end
+    rescue Errno::EPIPE
+    rescue Interrupt => interrupt
+      if STDOUT.isatty && ENV.has_key?("TERM")
+        display("\e[0m")
+      end
+      raise(interrupt)
+    end
+
+    COLORS = %w( cyan yellow green magenta red )
+    COLOR_CODES = {
+      "red"     => 31,
+      "green"   => 32,
+      "yellow"  => 33,
+      "magenta" => 35,
+      "cyan"    => 36,
+    }
+
+    def colorize(chunk)
+      lines = []
+      chunk.split("\n").map do |line|
+        if parsed_line = parse_log(line)
+          header, identifier, body = parsed_line
+          @assigned_colors[identifier] ||= COLORS[@assigned_colors.size % COLORS.size]
+          lines << [
+            "\e[#{COLOR_CODES[@assigned_colors[identifier]]}m",
+            header,
+            "\e[0m",
+            body,
+          ].join("")
+        elsif not line.empty?
+          lines << line
+        end
+      end
+      lines.join("\n")
+    end
+
+    def parse_log(log)
+      return unless parsed = log.match(/^(.*?\[(\w+)([\d\.]+)?\]:)(.*)?$/)
+      [1, 2, 4].map { |i| parsed[i] }
+    end
+
+  end
+end

data/lib/heroku/plugin.rb

@@ -11,6 +11,7 @@ module Heroku
       heroku-cedar
       heroku-certs
       heroku-credentials
+      heroku-dyno-size
       heroku-kill
       heroku-labs
       heroku-logging
@@ -19,11 +20,13 @@ module Heroku
       heroku-postgresql
       heroku-releases
       heroku-shared-postgresql
+      heroku-sql-console
       heroku-status
       heroku-stop
       heroku-suggest
       pgbackups-automate
       pgcmd
+      heroku-fork
     )
 
     attr_reader :name, :uri

data/lib/heroku/updater.rb

@@ -1,10 +1,14 @@
+require "digest"
 require "fileutils"
-
-require 'heroku/helpers'
+require "heroku/helpers"
 
 module Heroku
   module Updater
 
+    def self.error(message)
+      raise Heroku::Command::CommandFailed.new(message)
+    end
+
     def self.updating_lock_path
       File.join(Heroku::Helpers.home_directory, ".heroku", "updating")
     end
@@ -84,6 +88,11 @@ module Heroku
               file.print Excon.get_with_redirect(url, :nonblock => false).body
             end
 
+            hash = Digest::SHA256.file("#{download_dir}/heroku.zip").hexdigest
+            official_hash = Excon.get_with_redirect("https://toolbelt.heroku.com/update/hash", :nonblock => false).body.chomp
+
+            error "Update hash signature mismatch" unless hash == official_hash
+
             Zip::ZipFile.open("#{download_dir}/heroku.zip") do |zip|
               zip.each do |entry|
                 target = File.join(download_dir, entry.to_s)

data/lib/heroku/version.rb

@@ -1,3 +1,3 @@
 module Heroku
-  VERSION = "2.32.14"
+  VERSION = "2.39.2"
 end

data/spec/heroku/auth_spec.rb

@@ -109,6 +109,16 @@ module Heroku
       end
     end
 
+    describe "#base_host" do
+      it "returns the host without the first part" do
+        @cli.base_host("http://foo.bar.com").should == "bar.com"
+      end
+
+      it "works with localhost" do
+        @cli.base_host("http://localhost:3000").should == "localhost"
+      end
+    end
+
     it "asks for credentials when the file doesn't exist" do
       @cli.delete_credentials
       @cli.should_receive(:ask_for_credentials).and_return(["u", "p"])

data/spec/heroku/client/ssl_endpoint_spec.rb

@@ -7,42 +7,42 @@ describe Heroku::Client, "ssl endpoints" do
   end
 
   it "adds an ssl endpoint" do
-    stub_request(:post, "https://api.heroku.com/apps/myapp/ssl-endpoints").
+    stub_request(:post, "https://api.heroku.com/apps/example/ssl-endpoints").
       with(:body => { :accept => "json", :pem => "pem content", :key => "key content" }).
       to_return(:body => %{ {"cname": "tokyo-1050" } })
-    @client.ssl_endpoint_add("myapp", "pem content", "key content").should == { "cname" => "tokyo-1050" }
+    @client.ssl_endpoint_add("example", "pem content", "key content").should == { "cname" => "tokyo-1050" }
   end
 
   it "gets info on an ssl endpoint" do
-    stub_request(:get, "https://api.heroku.com/apps/myapp/ssl-endpoints/tokyo-1050").
+    stub_request(:get, "https://api.heroku.com/apps/example/ssl-endpoints/tokyo-1050").
       to_return(:body => %{ {"cname": "tokyo-1050" } })
-    @client.ssl_endpoint_info("myapp", "tokyo-1050").should == { "cname" => "tokyo-1050" }
+    @client.ssl_endpoint_info("example", "tokyo-1050").should == { "cname" => "tokyo-1050" }
   end
 
   it "lists ssl endpoints for an app" do
-    stub_request(:get, "https://api.heroku.com/apps/myapp/ssl-endpoints").
+    stub_request(:get, "https://api.heroku.com/apps/example/ssl-endpoints").
       to_return(:body => %{ [{"cname": "tokyo-1050" }, {"cname": "tokyo-1051" }] })
-    @client.ssl_endpoint_list("myapp").should == [
+    @client.ssl_endpoint_list("example").should == [
       { "cname" => "tokyo-1050" },
       { "cname" => "tokyo-1051" },
     ]
   end
 
   it "removes an ssl endpoint" do
-    stub_request(:delete, "https://api.heroku.com/apps/myapp/ssl-endpoints/tokyo-1050")
-    @client.ssl_endpoint_remove("myapp", "tokyo-1050")
+    stub_request(:delete, "https://api.heroku.com/apps/example/ssl-endpoints/tokyo-1050")
+    @client.ssl_endpoint_remove("example", "tokyo-1050")
   end
 
   it "rolls back an ssl endpoint" do
-    stub_request(:post, "https://api.heroku.com/apps/myapp/ssl-endpoints/tokyo-1050/rollback").
+    stub_request(:post, "https://api.heroku.com/apps/example/ssl-endpoints/tokyo-1050/rollback").
       to_return(:body => %{ {"cname": "tokyo-1050" } })
-    @client.ssl_endpoint_rollback("myapp", "tokyo-1050").should == { "cname" => "tokyo-1050" }
+    @client.ssl_endpoint_rollback("example", "tokyo-1050").should == { "cname" => "tokyo-1050" }
   end
 
   it "updates an ssl endpoint" do
-    stub_request(:put, "https://api.heroku.com/apps/myapp/ssl-endpoints/tokyo-1050").
+    stub_request(:put, "https://api.heroku.com/apps/example/ssl-endpoints/tokyo-1050").
       with(:body => { :accept => "json", :pem => "pem content", :key => "key content" }).
       to_return(:body => %{ {"cname": "tokyo-1050" } })
-    @client.ssl_endpoint_update("myapp", "tokyo-1050", "pem content", "key content").should == { "cname" => "tokyo-1050" }
+    @client.ssl_endpoint_update("example", "tokyo-1050", "pem content", "key content").should == { "cname" => "tokyo-1050" }
   end
 end

data/spec/heroku/client_spec.rb

@@ -24,26 +24,26 @@ describe Heroku::Client do
     stub_api_request(:get, "/apps").to_return(:body => <<-EOXML)
       <?xml version='1.0' encoding='UTF-8'?>
       <apps type="array">
-        <app><name>myapp1</name><owner>test@heroku.com</owner></app>
-        <app><name>myapp2</name><owner>test@heroku.com</owner></app>
+        <app><name>example</name><owner>test@heroku.com</owner></app>
+        <app><name>example2</name><owner>test@heroku.com</owner></app>
       </apps>
     EOXML
     capture_stderr do # capture deprecation message
       @client.list.should == [
-        ["myapp1", "test@heroku.com"],
-        ["myapp2", "test@heroku.com"]
+        ["example", "test@heroku.com"],
+        ["example2", "test@heroku.com"]
       ]
     end
   end
 
   it "info -> get app attributes" do
-    stub_api_request(:get, "/apps/myapp").to_return(:body => <<-EOXML)
+    stub_api_request(:get, "/apps/example").to_return(:body => <<-EOXML)
       <?xml version='1.0' encoding='UTF-8'?>
       <app>
         <blessed type='boolean'>true</blessed>
         <created-at type='datetime'>2008-07-08T17:21:50-07:00</created-at>
         <id type='integer'>49134</id>
-        <name>myapp</name>
+        <name>example</name>
         <production type='boolean'>true</production>
         <share-public type='boolean'>true</share-public>
         <domain_name/>
@@ -52,7 +52,7 @@ describe Heroku::Client do
     @client.stub!(:list_collaborators).and_return([:jon, :mike])
     @client.stub!(:installed_addons).and_return([:addon1])
     capture_stderr do # capture deprecation message
-      @client.info('myapp').should == { :blessed => 'true', :created_at => '2008-07-08T17:21:50-07:00', :id => '49134', :name => 'myapp', :production => 'true', :share_public => 'true', :domain_name => nil, :collaborators => [:jon, :mike], :addons => [:addon1] }
+      @client.info('example').should == { :blessed => 'true', :created_at => '2008-07-08T17:21:50-07:00', :id => '49134', :name => 'example', :production => 'true', :share_public => 'true', :domain_name => nil, :collaborators => [:jon, :mike], :addons => [:addon1] }
     end
   end
 
@@ -82,14 +82,14 @@ describe Heroku::Client do
     @client.should_receive(:resource).and_return(@resource)
     @resource.should_receive(:put).with({}, @client.heroku_headers).and_return(@response)
     capture_stderr do # capture deprecation message
-      @client.create_complete?('myapp').should be_false
+      @client.create_complete?('example').should be_false
     end
   end
 
   it "update(name, attributes) -> updates existing apps" do
-    stub_api_request(:put, "/apps/myapp").with(:body => "app[mode]=production")
+    stub_api_request(:put, "/apps/example").with(:body => "app[mode]=production")
     capture_stderr do # capture deprecation message
-      @client.update("myapp", :mode => 'production')
+      @client.update("example", :mode => 'production')
     end
   end
 
@@ -101,63 +101,63 @@ describe Heroku::Client do
   end
 
   it "rake(app_name, cmd) -> run a rake command on the app" do
-    stub_api_request(:post, "/apps/myapp/services").with(:body => "rake db:migrate").to_return(:body => "foo")
+    stub_api_request(:post, "/apps/example/services").with(:body => "rake db:migrate").to_return(:body => "foo")
     stub_api_request(:get,  "/foo").to_return(:body => "output")
     capture_stderr do # capture deprecation message
-      @client.rake('myapp', 'db:migrate')
+      @client.rake('example', 'db:migrate')
     end
   end
 
   it "console(app_name, cmd) -> run a console command on the app" do
-    stub_api_request(:post, "/apps/myapp/console").with(:body => "command=2%2B2")
-    @client.console('myapp', '2+2')
+    stub_api_request(:post, "/apps/example/console").with(:body => "command=2%2B2")
+    @client.console('example', '2+2')
   end
 
   it "console(app_name) { |c| } -> opens a console session, yields one accessor and closes it after the block" do
-    stub_api_request(:post,   "/apps/myapp/consoles").to_return(:body => "consolename")
-    stub_api_request(:post,   "/apps/myapp/consoles/consolename/command").with(:body => "command=1%2B1").to_return(:body => "2")
-    stub_api_request(:delete, "/apps/myapp/consoles/consolename")
+    stub_api_request(:post,   "/apps/example/consoles").to_return(:body => "consolename")
+    stub_api_request(:post,   "/apps/example/consoles/consolename/command").with(:body => "command=1%2B1").to_return(:body => "2")
+    stub_api_request(:delete, "/apps/example/consoles/consolename")
 
-    @client.console('myapp') do |c|
+    @client.console('example') do |c|
       c.run("1+1").should == '=> 2'
     end
   end
 
   it "shows an error message when a console request fails" do
-    stub_request(:post, %r{.*/apps/myapp/console}).to_return({
+    stub_request(:post, %r{.*/apps/example/console}).to_return({
       :body => "ERRMSG", :status => 502
     })
-    lambda { @client.console('myapp') }.should raise_error(Heroku::Client::AppCrashed, /Your application may have crashed/)
+    lambda { @client.console('example') }.should raise_error(Heroku::Client::AppCrashed, /Your application may have crashed/)
   end
 
   it "restart(app_name) -> restarts the app servers" do
-    stub_api_request(:delete, "/apps/myapp/server")
+    stub_api_request(:delete, "/apps/example/server")
     capture_stderr do # capture deprecation message
-      @client.restart('myapp')
+      @client.restart('example')
     end
   end
 
   describe "read_logs" do
     describe "old style" do
       before(:each) do
-        stub_api_request(:get, "/apps/myapp/logs?logplex=true").to_return(:body => "Use old logs")
-        stub_api_request(:get, "/apps/myapp/logs").to_return(:body => "oldlogs")
+        stub_api_request(:get, "/apps/example/logs?logplex=true").to_return(:body => "Use old logs")
+        stub_api_request(:get, "/apps/example/logs").to_return(:body => "oldlogs")
       end
 
       it "can read old style logs" do
         @client.should_receive(:puts).with("oldlogs")
-        @client.read_logs("myapp")
+        @client.read_logs("example")
       end
     end
 
     describe "new style" do
       before(:each) do
-        stub_api_request(:get, "/apps/myapp/logs?logplex=true").to_return(:body => "https://logplex.heroku.com/identifier")
+        stub_api_request(:get, "/apps/example/logs?logplex=true").to_return(:body => "https://logplex.heroku.com/identifier")
         stub_request(:get, "https://logplex.heroku.com/identifier").to_return(:body => "newlogs")
       end
 
       it "can read new style logs" do
-        @client.read_logs("myapp") do |logs|
+        @client.read_logs("example") do |logs|
           logs.should == "newlogs"
         end
       end
@@ -165,40 +165,40 @@ describe Heroku::Client do
   end
 
   it "logs(app_name) -> returns recent output of the app logs" do
-    stub_api_request(:get, "/apps/myapp/logs").to_return(:body => "log")
+    stub_api_request(:get, "/apps/example/logs").to_return(:body => "log")
     capture_stderr do # capture deprecation message
-      @client.logs('myapp').should == 'log'
+      @client.logs('example').should == 'log'
     end
   end
 
   it "can get the number of dynos" do
-    stub_api_request(:get, "/apps/myapp").to_return(:body => <<-EOXML)
+    stub_api_request(:get, "/apps/example").to_return(:body => <<-EOXML)
       <?xml version='1.0' encoding='UTF-8'?>
       <app>
         <dynos type='integer'>5</dynos>
       </app>
     EOXML
     capture_stderr do # capture deprecation message
-      @client.dynos('myapp').should == 5
+      @client.dynos('example').should == 5
     end
   end
 
   it "can get the number of workers" do
-    stub_api_request(:get, "/apps/myapp").to_return(:body => <<-EOXML)
+    stub_api_request(:get, "/apps/example").to_return(:body => <<-EOXML)
       <?xml version='1.0' encoding='UTF-8'?>
       <app>
         <workers type='integer'>5</workers>
       </app>
     EOXML
     capture_stderr do # capture deprecation message
-      @client.workers('myapp').should == 5
+      @client.workers('example').should == 5
     end
   end
 
   it "set_dynos(app_name, qty) -> scales the app" do
-    stub_api_request(:put, "/apps/myapp/dynos").with(:body => "dynos=3")
+    stub_api_request(:put, "/apps/example/dynos").with(:body => "dynos=3")
     capture_stderr do # capture deprecation message
-      @client.set_dynos('myapp', 3)
+      @client.set_dynos('example', 3)
     end
   end
 
@@ -208,7 +208,7 @@ describe Heroku::Client do
     e.stub!(:http_body).and_return('the crashlog')
     @client.should_receive(:post).and_raise(e)
     capture_stderr do # capture deprecation message
-      lambda { @client.rake('myapp', '') }.should raise_error(Heroku::Client::AppCrashed)
+      lambda { @client.rake('example', '') }.should raise_error(Heroku::Client::AppCrashed)
     end
   end
 
@@ -218,22 +218,22 @@ describe Heroku::Client do
     e.stub!(:http_body).and_return('not a crashlog')
     @client.should_receive(:post).and_raise(e)
     capture_stderr do # capture deprecation message
-      lambda { @client.rake('myapp', '') }.should raise_error(RestClient::RequestFailed)
+      lambda { @client.rake('example', '') }.should raise_error(RestClient::RequestFailed)
     end
   end
 
   describe "ps_scale" do
     it "scales a process and returns the new count" do
-      stub_api_request(:post, "/apps/myapp/ps/scale").with(:body => { :type => "web", :qty => "5" }).to_return(:body => "5")
+      stub_api_request(:post, "/apps/example/ps/scale").with(:body => { :type => "web", :qty => "5" }).to_return(:body => "5")
       capture_stderr do # capture deprecation message
-        @client.ps_scale("myapp", :type => "web", :qty => "5").should == 5
+        @client.ps_scale("example", :type => "web", :qty => "5").should == 5
       end
     end
   end
 
   describe "collaborators" do
     it "list(app_name) -> list app collaborators" do
-      stub_api_request(:get, "/apps/myapp/collaborators").to_return(:body => <<-EOXML)
+      stub_api_request(:get, "/apps/example/collaborators").to_return(:body => <<-EOXML)
         <?xml version="1.0" encoding="UTF-8"?>
         <collaborators type="array">
           <collaborator><email>joe@example.com</email></collaborator>
@@ -241,7 +241,7 @@ describe Heroku::Client do
         </collaborators>
       EOXML
       capture_stderr do # capture deprecation message
-        @client.list_collaborators('myapp').should == [
+        @client.list_collaborators('example').should == [
           { :email => 'joe@example.com' },
           { :email => 'jon@example.com' }
         ]
@@ -249,23 +249,23 @@ describe Heroku::Client do
     end
 
     it "add_collaborator(app_name, email) -> adds collaborator to app" do
-      stub_api_request(:post, "/apps/myapp/collaborators").with(:body => "collaborator%5Bemail%5D=joe%40example.com")
+      stub_api_request(:post, "/apps/example/collaborators").with(:body => "collaborator%5Bemail%5D=joe%40example.com")
       capture_stderr do # capture deprecation message
-        @client.add_collaborator('myapp', 'joe@example.com')
+        @client.add_collaborator('example', 'joe@example.com')
       end
     end
 
     it "remove_collaborator(app_name, email) -> removes collaborator from app" do
-      stub_api_request(:delete, "/apps/myapp/collaborators/joe%40example%2Ecom")
+      stub_api_request(:delete, "/apps/example/collaborators/joe%40example%2Ecom")
       capture_stderr do # capture deprecation message
-        @client.remove_collaborator('myapp', 'joe@example.com')
+        @client.remove_collaborator('example', 'joe@example.com')
       end
     end
   end
 
   describe "domain names" do
     it "list(app_name) -> list app domain names" do
-      stub_api_request(:get, "/apps/myapp/domains").to_return(:body => <<-EOXML)
+      stub_api_request(:get, "/apps/example/domains").to_return(:body => <<-EOXML)
         <?xml version="1.0" encoding="UTF-8"?>
         <domain-names type="array">
           <domain-name><domain>example1.com</domain></domain-name>
@@ -273,51 +273,51 @@ describe Heroku::Client do
         </domain-names>
       EOXML
       capture_stderr do # capture deprecation message
-        @client.list_domains('myapp').should == [{:domain => 'example1.com'}, {:domain => 'example2.com'}]
+        @client.list_domains('example').should == [{:domain => 'example1.com'}, {:domain => 'example2.com'}]
       end
     end
 
     it "add_domain(app_name, domain) -> adds domain name to app" do
-      stub_api_request(:post, "/apps/myapp/domains").with(:body => "example.com")
+      stub_api_request(:post, "/apps/example/domains").with(:body => "example.com")
       capture_stderr do # capture deprecation message
-        @client.add_domain('myapp', 'example.com')
+        @client.add_domain('example', 'example.com')
       end
     end
 
     it "remove_domain(app_name, domain) -> removes domain name from app" do
-      stub_api_request(:delete, "/apps/myapp/domains/example.com")
+      stub_api_request(:delete, "/apps/example/domains/example.com")
       capture_stderr do # capture deprecation message
-        @client.remove_domain('myapp', 'example.com')
+        @client.remove_domain('example', 'example.com')
       end
     end
 
     it "remove_domain(app_name, domain) -> makes sure a domain is set" do
       lambda do
         capture_stderr do # capture deprecation message
-          @client.remove_domain('myapp', '')
+          @client.remove_domain('example', '')
         end
       end.should raise_error(ArgumentError)
     end
 
     it "remove_domains(app_name) -> removes all domain names from app" do
-      stub_api_request(:delete, "/apps/myapp/domains")
+      stub_api_request(:delete, "/apps/example/domains")
       capture_stderr do # capture deprecation message
-        @client.remove_domains('myapp')
+        @client.remove_domains('example')
       end
     end
 
     it "add_ssl(app_name, pem, key) -> adds a ssl cert to the domain" do
-      stub_api_request(:post, "/apps/myapp/ssl").with do |request|
+      stub_api_request(:post, "/apps/example/ssl").with do |request|
         body = CGI::parse(request.body)
         body["key"].first.should == "thekey"
         body["pem"].first.should == "thepem"
       end.to_return(:body => "{}")
-      @client.add_ssl('myapp', 'thepem', 'thekey')
+      @client.add_ssl('example', 'thepem', 'thekey')
     end
 
     it "remove_ssl(app_name, domain) -> removes the ssl cert for the domain" do
-      stub_api_request(:delete, "/apps/myapp/domains/example.com/ssl")
-      @client.remove_ssl('myapp', 'example.com')
+      stub_api_request(:delete, "/apps/example/domains/example.com/ssl")
+      @client.remove_ssl('example', 'example.com')
     end
   end
 
@@ -364,63 +364,63 @@ describe Heroku::Client do
         end
       end
 
-      stub_api_request(:post, "/apps/myapp/database/session2").to_return(:body => "{\"session_id\":\"x234\"}")
-      @client.database_session('myapp')
+      stub_api_request(:post, "/apps/example/database/session2").to_return(:body => "{\"session_id\":\"x234\"}")
+      @client.database_session('example')
     end
 
     it "database_reset(app_name) -> reset an app's database" do
-      stub_api_request(:post, "/apps/myapp/database/reset")
-      @client.database_reset('myapp')
+      stub_api_request(:post, "/apps/example/database/reset")
+      @client.database_reset('example')
     end
 
     it "maintenance(app_name, :on) -> sets maintenance mode for an app" do
-      stub_api_request(:post, "/apps/myapp/server/maintenance").with(:body => "maintenance_mode=1")
+      stub_api_request(:post, "/apps/example/server/maintenance").with(:body => "maintenance_mode=1")
       capture_stderr do # capture deprecation message
-        @client.maintenance('myapp', :on)
+        @client.maintenance('example', :on)
       end
     end
 
     it "maintenance(app_name, :off) -> turns off maintenance mode for an app" do
-      stub_api_request(:post, "/apps/myapp/server/maintenance").with(:body => "maintenance_mode=0")
+      stub_api_request(:post, "/apps/example/server/maintenance").with(:body => "maintenance_mode=0")
       capture_stderr do # capture deprecation message
-        @client.maintenance('myapp', :off)
+        @client.maintenance('example', :off)
       end
     end
   end
 
   describe "config vars" do
     it "config_vars(app_name) -> json hash of config vars for the app" do
-      stub_api_request(:get, "/apps/myapp/config_vars").to_return(:body => '{"A":"one", "B":"two"}')
+      stub_api_request(:get, "/apps/example/config_vars").to_return(:body => '{"A":"one", "B":"two"}')
       capture_stderr do # capture deprecation message
-        @client.config_vars('myapp').should == { 'A' => 'one', 'B' => 'two'}
+        @client.config_vars('example').should == { 'A' => 'one', 'B' => 'two'}
       end
     end
 
     it "add_config_vars(app_name, vars)" do
-      stub_api_request(:put, "/apps/myapp/config_vars").with(:body => '{"x":"y"}')
+      stub_api_request(:put, "/apps/example/config_vars").with(:body => '{"x":"y"}')
       capture_stderr do # capture deprecation message
-        @client.add_config_vars('myapp', {'x'=> 'y'})
+        @client.add_config_vars('example', {'x'=> 'y'})
       end
     end
 
     it "remove_config_var(app_name, key)" do
-      stub_api_request(:delete, "/apps/myapp/config_vars/mykey")
+      stub_api_request(:delete, "/apps/example/config_vars/mykey")
       capture_stderr do # capture deprecation message
-        @client.remove_config_var('myapp', 'mykey')
+        @client.remove_config_var('example', 'mykey')
       end
     end
 
     it "clear_config_vars(app_name) -> resets all config vars for this app" do
-      stub_api_request(:delete, "/apps/myapp/config_vars")
+      stub_api_request(:delete, "/apps/example/config_vars")
       capture_stderr do # capture deprecation message
-        @client.clear_config_vars('myapp')
+        @client.clear_config_vars('example')
       end
     end
 
     it "can handle config vars with special characters" do
-      stub_api_request(:delete, "/apps/myapp/config_vars/foo%5Bbar%5D")
+      stub_api_request(:delete, "/apps/example/config_vars/foo%5Bbar%5D")
       capture_stderr do # capture deprecation message
-        lambda { @client.remove_config_var('myapp', 'foo[bar]') }.should_not raise_error
+        lambda { @client.remove_config_var('example', 'foo[bar]') }.should_not raise_error
       end
     end
   end
@@ -432,68 +432,68 @@ describe Heroku::Client do
     end
 
     it "installed_addons(app_name) -> array of installed addons" do
-      stub_api_request(:get, "/apps/myapp/addons").to_return(:body => '[{"name":"addon1"}]')
-      @client.installed_addons('myapp').should == [{'name' => 'addon1'}]
+      stub_api_request(:get, "/apps/example/addons").to_return(:body => '[{"name":"addon1"}]')
+      @client.installed_addons('example').should == [{'name' => 'addon1'}]
     end
 
     it "install_addon(app_name, addon_name)" do
-      stub_api_request(:post, "/apps/myapp/addons/addon1")
-      @client.install_addon('myapp', 'addon1').should be_nil
+      stub_api_request(:post, "/apps/example/addons/addon1")
+      @client.install_addon('example', 'addon1').should be_nil
     end
 
     it "upgrade_addon(app_name, addon_name)" do
-      stub_api_request(:put, "/apps/myapp/addons/addon1")
-      @client.upgrade_addon('myapp', 'addon1').should be_nil
+      stub_api_request(:put, "/apps/example/addons/addon1")
+      @client.upgrade_addon('example', 'addon1').should be_nil
     end
 
     it "downgrade_addon(app_name, addon_name)" do
-      stub_api_request(:put, "/apps/myapp/addons/addon1")
-      @client.downgrade_addon('myapp', 'addon1').should be_nil
+      stub_api_request(:put, "/apps/example/addons/addon1")
+      @client.downgrade_addon('example', 'addon1').should be_nil
     end
 
     it "uninstall_addon(app_name, addon_name)" do
-      stub_api_request(:delete, "/apps/myapp/addons/addon1?").
+      stub_api_request(:delete, "/apps/example/addons/addon1?").
         to_return(:body => json_encode({"message" => nil, "price" => "free", "status" => "uninstalled"}))
 
-      @client.uninstall_addon('myapp', 'addon1').should be_true
+      @client.uninstall_addon('example', 'addon1').should be_true
     end
 
     it "uninstall_addon(app_name, addon_name) with confirmation" do
-      stub_api_request(:delete, "/apps/myapp/addons/addon1?confirm=myapp").
+      stub_api_request(:delete, "/apps/example/addons/addon1?confirm=example").
         to_return(:body => json_encode({"message" => nil, "price" => "free", "status" => "uninstalled"}))
 
-      @client.uninstall_addon('myapp', 'addon1', :confirm => "myapp").should be_true
+      @client.uninstall_addon('example', 'addon1', :confirm => "example").should be_true
     end
 
     it "install_addon(app_name, addon_name) with response" do
-      stub_request(:post, "https://api.heroku.com/apps/myapp/addons/addon1").
+      stub_request(:post, "https://api.heroku.com/apps/example/addons/addon1").
         to_return(:body => json_encode({'price' => 'free', 'message' => "Don't Panic"}))
 
-      @client.install_addon('myapp', 'addon1').
+      @client.install_addon('example', 'addon1').
         should == { 'price' => 'free', 'message' => "Don't Panic" }
     end
 
     it "upgrade_addon(app_name, addon_name) with response" do
-      stub_request(:put, "https://api.heroku.com/apps/myapp/addons/addon1").
+      stub_request(:put, "https://api.heroku.com/apps/example/addons/addon1").
         to_return(:body => json_encode('price' => 'free', 'message' => "Don't Panic"))
 
-      @client.upgrade_addon('myapp', 'addon1').
+      @client.upgrade_addon('example', 'addon1').
         should == { 'price' => 'free', 'message' => "Don't Panic" }
     end
 
     it "downgrade_addon(app_name, addon_name) with response" do
-      stub_request(:put, "https://api.heroku.com/apps/myapp/addons/addon1").
+      stub_request(:put, "https://api.heroku.com/apps/example/addons/addon1").
         to_return(:body => json_encode('price' => 'free', 'message' => "Don't Panic"))
 
-      @client.downgrade_addon('myapp', 'addon1').
+      @client.downgrade_addon('example', 'addon1').
         should == { 'price' => 'free', 'message' => "Don't Panic" }
     end
 
     it "uninstall_addon(app_name, addon_name) with response" do
-      stub_api_request(:delete, "/apps/myapp/addons/addon1?").
+      stub_api_request(:delete, "/apps/example/addons/addon1?").
         to_return(:body => json_encode('price'=> 'free', 'message'=> "Don't Panic"))
 
-      @client.uninstall_addon('myapp', 'addon1').
+      @client.uninstall_addon('example', 'addon1').
         should == { 'price' => 'free', 'message' => "Don't Panic" }
     end
   end
@@ -548,16 +548,16 @@ describe Heroku::Client do
 
   describe "stacks" do
     it "list_stacks(app_name) -> json hash of available stacks" do
-      stub_api_request(:get, "/apps/myapp/stack?include_deprecated=false").to_return(:body => '{"stack":"one"}')
+      stub_api_request(:get, "/apps/example/stack?include_deprecated=false").to_return(:body => '{"stack":"one"}')
       capture_stderr do # capture deprecation message
-        @client.list_stacks("myapp").should == { 'stack' => 'one' }
+        @client.list_stacks("example").should == { 'stack' => 'one' }
       end
     end
 
     it "list_stacks(app_name, include_deprecated=true) passes the deprecated option" do
-      stub_api_request(:get, "/apps/myapp/stack?include_deprecated=true").to_return(:body => '{"stack":"one"}')
+      stub_api_request(:get, "/apps/example/stack?include_deprecated=true").to_return(:body => '{"stack":"one"}')
       capture_stderr do # capture deprecation message
-        @client.list_stacks("myapp", :include_deprecated => true).should == { 'stack' => 'one' }
+        @client.list_stacks("example", :include_deprecated => true).should == { 'stack' => 'one' }
       end
     end
   end