pogo 2.32.14 → 2.39.2

data/spec/heroku/command/addons_spec.rb

@@ -5,25 +5,25 @@ module Heroku::Command
   describe Addons do
     before do
       @addons = prepare_command(Addons)
-      stub_core.release("myapp", "current").returns( "name" => "v99" )
+      stub_core.release("example", "current").returns( "name" => "v99" )
     end
 
     describe "index" do
 
       before(:each) do
         stub_core
-        api.post_app("name" => "myapp", "stack" => "cedar")
+        api.post_app("name" => "example", "stack" => "cedar")
       end
 
       after(:each) do
-        api.delete_app("myapp")
+        api.delete_app("example")
       end
 
       it "should display no addons when none are configured" do
         stderr, stdout = execute("addons")
         stderr.should == ""
         stdout.should == <<-STDOUT
-myapp has no add-ons.
+example has no add-ons.
 STDOUT
       end
 
@@ -32,7 +32,7 @@ STDOUT
           {
             :expects => 200,
             :method => :get,
-            :path => %r{^/apps/myapp/addons$}
+            :path => %r{^/apps/example/addons$}
           },
           {
             :body   => Heroku::API::OkJson.encode([
@@ -46,12 +46,12 @@ STDOUT
         stderr, stdout = execute("addons")
         stderr.should == ""
         stdout.should == <<-STDOUT
-=== myapp Configured Add-ons
+=== example Configured Add-ons
 deployhooks:http
 heroku-postgresql:ronin  HEROKU_POSTGRESQL_RED
 
-=== myapp Add-ons to Configure
-deployhooks:email  https://api.heroku.com/myapps/myapp/addons/deployhooks:email
+=== example Add-ons to Configure
+deployhooks:email  https://api.heroku.com/apps/example/addons/deployhooks:email
 
 STDOUT
         Excon.stubs.shift
@@ -60,7 +60,14 @@ STDOUT
     end
 
     describe "list" do
-      before do
+
+      it "sends region option to the server" do
+        stub_request(:get, %r{/addons\?region=eu$}).
+          to_return(:body => Heroku::OkJson.encode([]))
+        execute("addons:list --region=eu")
+      end
+
+      it "lists available addons" do
         stub_core.addons.returns([
           { "name" => "cloudcounter:basic", "state" => "alpha" },
           { "name" => "cloudcounter:pro", "state" => "public" },
@@ -68,9 +75,6 @@ STDOUT
           { "name" => "cloudcounter:old", "state" => "disabled" },
           { "name" => "cloudcounter:platinum", "state" => "beta" }
         ])
-      end
-
-      it "lists available addons" do
         stderr, stdout = execute("addons:list")
         stderr.should == ""
         stdout.should == <<-STDOUT
@@ -93,19 +97,19 @@ STDOUT
     describe 'v1-style command line params' do
       it "understands foo=baz" do
         @addons.stub!(:args).and_return(%w(my_addon foo=baz))
-        @addons.heroku.should_receive(:install_addon).with('myapp', 'my_addon', { 'foo' => 'baz' })
+        @addons.heroku.should_receive(:install_addon).with('example', 'my_addon', { 'foo' => 'baz' })
         @addons.add
       end
 
       it "gives a deprecation notice with an example" do
-        stub_request(:post, %r{apps/myapp/addons/my_addon$}).
+        stub_request(:post, %r{apps/example/addons/my_addon$}).
           with(:body => {:config => {:foo => 'bar', :extra => "XXX"}}).
           to_return(:body => Heroku::OkJson.encode({ 'price' => 'free' }))
         Excon.stub(
           {
             :expects => 200,
             :method => :get,
-            :path => %r{^/apps/myapp/releases/current}
+            :path => %r{^/apps/example/releases/current}
           },
           {
             :body   => Heroku::API::OkJson.encode({ 'name' => 'v99' }),
@@ -116,7 +120,7 @@ STDOUT
         stderr.should == ""
         stdout.should == <<-STDOUT
 Warning: non-unix style params have been deprecated, use --extra=XXX instead
-Adding my_addon on myapp... done, v99 (free)
+Adding my_addon on example... done, v99 (free)
 Use `heroku addons:docs my_addon` to view documentation.
 STDOUT
         Excon.stubs.shift
@@ -126,36 +130,36 @@ STDOUT
     describe 'unix-style command line params' do
       it "understands --foo=baz" do
         @addons.stub!(:args).and_return(%w(my_addon --foo=baz))
-        @addons.heroku.should_receive(:install_addon).with('myapp', 'my_addon', { 'foo' => 'baz' })
+        @addons.heroku.should_receive(:install_addon).with('example', 'my_addon', { 'foo' => 'baz' })
         @addons.add
       end
 
       it "understands --foo baz" do
         @addons.stub!(:args).and_return(%w(my_addon --foo baz))
-        @addons.heroku.should_receive(:install_addon).with('myapp', 'my_addon', { 'foo' => 'baz' })
+        @addons.heroku.should_receive(:install_addon).with('example', 'my_addon', { 'foo' => 'baz' })
         @addons.add
       end
 
       it "treats lone switches as true" do
         @addons.stub!(:args).and_return(%w(my_addon --foo))
-        @addons.heroku.should_receive(:install_addon).with('myapp', 'my_addon', { 'foo' => true })
+        @addons.heroku.should_receive(:install_addon).with('example', 'my_addon', { 'foo' => true })
         @addons.add
       end
 
       it "converts 'true' to boolean" do
         @addons.stub!(:args).and_return(%w(my_addon --foo=true))
-        @addons.heroku.should_receive(:install_addon).with('myapp', 'my_addon', { 'foo' => true })
+        @addons.heroku.should_receive(:install_addon).with('example', 'my_addon', { 'foo' => true })
         @addons.add
       end
 
       it "works with many config vars" do
         @addons.stub!(:args).and_return(%w(my_addon --foo  baz --bar  yes --baz=foo --bab --bob=true))
-        @addons.heroku.should_receive(:install_addon).with('myapp', 'my_addon', { 'foo' => 'baz', 'bar' => 'yes', 'baz' => 'foo', 'bab' => true, 'bob' => true })
+        @addons.heroku.should_receive(:install_addon).with('example', 'my_addon', { 'foo' => 'baz', 'bar' => 'yes', 'baz' => 'foo', 'bab' => true, 'bob' => true })
         @addons.add
       end
 
       it "sends the variables to the server" do
-        stub_request(:post, %r{apps/myapp/addons/my_addon$}).
+        stub_request(:post, %r{apps/example/addons/my_addon$}).
           with(:body => {:config => { 'foo' => 'baz', 'bar' => 'yes', 'baz' => 'foo', 'bab' => 'true', 'bob' => 'true' }})
         stderr, stdout = execute("addons:add my_addon --foo  baz --bar  yes --baz=foo --bab --bob=true")
         stderr.should == ""
@@ -170,12 +174,12 @@ STDOUT
     describe "mixed options" do
       it "understands foo=bar and --baz=bar on the same line" do
         @addons.stub!(:args).and_return(%w(my_addon foo=baz --baz=bar bob=true --bar))
-        @addons.heroku.should_receive(:install_addon).with('myapp', 'my_addon', { 'foo' => 'baz', 'baz' => 'bar', 'bar' => true, 'bob' => true })
+        @addons.heroku.should_receive(:install_addon).with('example', 'my_addon', { 'foo' => 'baz', 'baz' => 'bar', 'bar' => true, 'bob' => true })
         @addons.add
       end
 
       it "sends the variables to the server" do
-        stub_request(:post, %r{apps/myapp/addons/my_addon$}).
+        stub_request(:post, %r{apps/example/addons/my_addon$}).
           with(:body => {:config => { 'foo' => 'baz', 'baz' => 'bar', 'bar' => 'true', 'bob' => 'true' }})
         stderr, stdout = execute("addons:add my_addon foo=baz --baz=bar bob=true --bar")
         stderr.should == ""
@@ -188,7 +192,7 @@ STDOUT
         %w{fork follow}.each do |switch|
           @addons.stub!(:args).and_return("addon --#{switch} HEROKU_POSTGRESQL_RED".split)
           @addons.heroku.should_receive(:install_addon).
-            with('myapp', 'addon', {switch => 'HEROKU_POSTGRESQL_RED'})
+            with('example', 'addon', {switch => 'HEROKU_POSTGRESQL_RED'})
           @addons.add
         end
       end
@@ -203,7 +207,7 @@ STDOUT
                              'type'  => 'heroku-postgresql:ronin' }})
           ])
           @addons.stub!(:args).and_return("heroku-postgresql --#{switch} HEROKU_POSTGRESQL_RED".split)
-          @addons.heroku.should_receive(:install_addon).with('myapp', 'heroku-postgresql', {switch => 'postgres://red_url'})
+          @addons.heroku.should_receive(:install_addon).with('example', 'heroku-postgresql', {switch => 'postgres://red_url'})
           @addons.add
         end
       end
@@ -213,7 +217,7 @@ STDOUT
           @addons.stub!(:app_config_vars).and_return({})
           @addons.stub!(:app_attachments).and_return([])
           @addons.stub!(:args).and_return("heroku-postgresql --#{switch} postgres://foo:yeah@awesome.com:234/bestdb".split)
-          @addons.heroku.should_receive(:install_addon).with('myapp', 'heroku-postgresql', {switch => 'postgres://foo:yeah@awesome.com:234/bestdb'})
+          @addons.heroku.should_receive(:install_addon).with('example', 'heroku-postgresql', {switch => 'postgres://foo:yeah@awesome.com:234/bestdb'})
           @addons.add
         end
       end
@@ -226,7 +230,7 @@ STDOUT
           {
             :expects => 200,
             :method => :get,
-            :path => %r{^/apps/myapp/releases/current}
+            :path => %r{^/apps/example/releases/current}
           },
           {
             :body   => Heroku::API::OkJson.encode({ 'name' => 'v99' }),
@@ -246,34 +250,34 @@ STDOUT
 
       it "adds an addon" do
         @addons.stub!(:args).and_return(%w(my_addon))
-        @addons.heroku.should_receive(:install_addon).with('myapp', 'my_addon', {})
+        @addons.heroku.should_receive(:install_addon).with('example', 'my_addon', {})
         @addons.add
       end
 
       it "adds an addon with a price" do
-        stub_core.install_addon("myapp", "my_addon", {}).returns({ "price" => "free" })
+        stub_core.install_addon("example", "my_addon", {}).returns({ "price" => "free" })
         stderr, stdout = execute("addons:add my_addon")
         stderr.should == ""
         stdout.should =~ /\(free\)/
       end
 
       it "adds an addon with a price and message" do
-        stub_core.install_addon("myapp", "my_addon", {}).returns({ "price" => "free", "message" => "foo" })
+        stub_core.install_addon("example", "my_addon", {}).returns({ "price" => "free", "message" => "foo" })
         stderr, stdout = execute("addons:add my_addon")
         stderr.should == ""
         stdout.should == <<-OUTPUT
-Adding my_addon on myapp... done, v99 (free)
+Adding my_addon on example... done, v99 (free)
 foo
 Use `heroku addons:docs my_addon` to view documentation.
 OUTPUT
       end
 
       it "adds an addon with a price and multiline message" do
-        stub_core.install_addon("myapp", "my_addon", {}).returns({ "price" => "$200/mo", "message" => "foo\nbar" })
+        stub_core.install_addon("example", "my_addon", {}).returns({ "price" => "$200/mo", "message" => "foo\nbar" })
         stderr, stdout = execute("addons:add my_addon")
         stderr.should == ""
         stdout.should == <<-OUTPUT
-Adding my_addon on myapp... done, v99 ($200/mo)
+Adding my_addon on example... done, v99 ($200/mo)
 foo
 bar
 Use `heroku addons:docs my_addon` to view documentation.
@@ -293,7 +297,7 @@ OUTPUT
           {
             :expects => 200,
             :method => :get,
-            :path => %r{^/apps/myapp/releases/current}
+            :path => %r{^/apps/example/releases/current}
           },
           {
             :body   => Heroku::API::OkJson.encode({ 'name' => 'v99' }),
@@ -312,32 +316,32 @@ OUTPUT
 
       it "upgrades an addon" do
         @addons.stub!(:args).and_return(%w(my_addon))
-        @addons.heroku.should_receive(:upgrade_addon).with('myapp', 'my_addon', {})
+        @addons.heroku.should_receive(:upgrade_addon).with('example', 'my_addon', {})
         @addons.upgrade
       end
 
       it "upgrade an addon with config vars" do
         @addons.stub!(:args).and_return(%w(my_addon --foo=baz))
-        @addons.heroku.should_receive(:upgrade_addon).with('myapp', 'my_addon', { 'foo' => 'baz' })
+        @addons.heroku.should_receive(:upgrade_addon).with('example', 'my_addon', { 'foo' => 'baz' })
         @addons.upgrade
       end
 
       it "adds an addon with a price" do
-        stub_core.upgrade_addon("myapp", "my_addon", {}).returns({ "price" => "free" })
+        stub_core.upgrade_addon("example", "my_addon", {}).returns({ "price" => "free" })
         stderr, stdout = execute("addons:upgrade my_addon")
         stderr.should == ""
         stdout.should == <<-OUTPUT
-Upgrading to my_addon on myapp... done, v99 (free)
+Upgrading to my_addon on example... done, v99 (free)
 Use `heroku addons:docs my_addon` to view documentation.
 OUTPUT
       end
 
       it "adds an addon with a price and message" do
-        stub_core.upgrade_addon("myapp", "my_addon", {}).returns({ "price" => "free", "message" => "Don't Panic" })
+        stub_core.upgrade_addon("example", "my_addon", {}).returns({ "price" => "free", "message" => "Don't Panic" })
         stderr, stdout = execute("addons:upgrade my_addon")
         stderr.should == ""
         stdout.should == <<-OUTPUT
-Upgrading to my_addon on myapp... done, v99 (free)
+Upgrading to my_addon on example... done, v99 (free)
 Don't Panic
 Use `heroku addons:docs my_addon` to view documentation.
 OUTPUT
@@ -351,7 +355,7 @@ OUTPUT
           {
             :expects => 200,
             :method => :get,
-            :path => %r{^/apps/myapp/releases/current}
+            :path => %r{^/apps/example/releases/current}
           },
           {
             :body   => Heroku::API::OkJson.encode({ 'name' => 'v99' }),
@@ -370,32 +374,32 @@ OUTPUT
 
       it "downgrades an addon" do
         @addons.stub!(:args).and_return(%w(my_addon))
-        @addons.heroku.should_receive(:upgrade_addon).with('myapp', 'my_addon', {})
+        @addons.heroku.should_receive(:upgrade_addon).with('example', 'my_addon', {})
         @addons.downgrade
       end
 
       it "downgrade an addon with config vars" do
         @addons.stub!(:args).and_return(%w(my_addon --foo=baz))
-        @addons.heroku.should_receive(:upgrade_addon).with('myapp', 'my_addon', { 'foo' => 'baz' })
+        @addons.heroku.should_receive(:upgrade_addon).with('example', 'my_addon', { 'foo' => 'baz' })
         @addons.downgrade
       end
 
       it "downgrades an addon with a price" do
-        stub_core.upgrade_addon("myapp", "my_addon", {}).returns({ "price" => "free" })
+        stub_core.upgrade_addon("example", "my_addon", {}).returns({ "price" => "free" })
         stderr, stdout = execute("addons:downgrade my_addon")
         stderr.should == ""
         stdout.should == <<-OUTPUT
-Downgrading to my_addon on myapp... done, v99 (free)
+Downgrading to my_addon on example... done, v99 (free)
 Use `heroku addons:docs my_addon` to view documentation.
 OUTPUT
       end
 
       it "downgrades an addon with a price and message" do
-        stub_core.upgrade_addon("myapp", "my_addon", {}).returns({ "price" => "free", "message" => "Don't Panic" })
+        stub_core.upgrade_addon("example", "my_addon", {}).returns({ "price" => "free", "message" => "Don't Panic" })
         stderr, stdout = execute("addons:downgrade my_addon")
         stderr.should == ""
         stdout.should == <<-OUTPUT
-Downgrading to my_addon on myapp... done, v99 (free)
+Downgrading to my_addon on example... done, v99 (free)
 Don't Panic
 Use `heroku addons:docs my_addon` to view documentation.
 OUTPUT
@@ -423,14 +427,14 @@ OUTPUT
     it "removes addons after prompting for confirmation" do
       @addons.stub!(:args).and_return(%w( addon1 ))
       @addons.should_receive(:confirm_command).once.and_return(true)
-      @addons.heroku.should_receive(:uninstall_addon).with('myapp', 'addon1', :confirm => "myapp")
+      @addons.heroku.should_receive(:uninstall_addon).with('example', 'addon1', :confirm => "example")
       @addons.remove
     end
 
     it "removes addons with confirm option" do
-      Heroku::Command.stub!(:current_options).and_return(:confirm => "myapp")
+      Heroku::Command.stub!(:current_options).and_return(:confirm => "example")
       @addons.stub!(:args).and_return(%w( addon1 ))
-      @addons.heroku.should_receive(:uninstall_addon).with('myapp', 'addon1', :confirm => "myapp")
+      @addons.heroku.should_receive(:uninstall_addon).with('example', 'addon1', :confirm => "example")
       @addons.remove
     end
 
@@ -438,11 +442,11 @@ OUTPUT
 
       before(:each) do
         stub_core
-        api.post_app("name" => "myapp", "stack" => "cedar")
+        api.post_app("name" => "example", "stack" => "cedar")
       end
 
       after(:each) do
-        api.delete_app("myapp")
+        api.delete_app("example")
       end
 
       it "displays usage when no argument is specified" do
@@ -519,11 +523,11 @@ STDOUT
 
       before(:each) do
         stub_core
-        api.post_app("name" => "myapp", "stack" => "cedar")
+        api.post_app("name" => "example", "stack" => "cedar")
       end
 
       after(:each) do
-        api.delete_app("myapp")
+        api.delete_app("example")
       end
 
       it "displays usage when no argument is specified" do
@@ -536,13 +540,13 @@ STDERR
       end
 
       it "opens the addon if only one matches" do
-        api.post_addon('myapp', 'redistogo:nano')
+        api.post_addon('example', 'redistogo:nano')
         require("launchy")
-        Launchy.should_receive(:open).with("https://api.#{@addons.heroku.host}/myapps/myapp/addons/redistogo:nano").and_return(Thread.new {})
+        Launchy.should_receive(:open).with("https://api.#{@addons.heroku.host}/apps/example/addons/redistogo:nano").and_return(Thread.new {})
         stderr, stdout = execute('addons:open redistogo:nano')
         stderr.should == ''
         stdout.should == <<-STDOUT
-Opening redistogo:nano for myapp... done
+Opening redistogo:nano for example... done
 STDOUT
       end
 
@@ -551,7 +555,7 @@ STDOUT
           {
             :expects => 200,
             :method => :get,
-            :path => %r{^/apps/myapp/addons$}
+            :path => %r{^/apps/example/addons$}
           },
           {
             :body   => Heroku::API::OkJson.encode([

data/spec/heroku/command/apps_spec.rb

@@ -11,34 +11,36 @@ module Heroku::Command
     context("info") do
 
       before(:each) do
-        api.post_app("name" => "myapp", "stack" => "cedar")
+        api.post_app("name" => "example", "stack" => "cedar")
       end
 
       after(:each) do
-        api.delete_app("myapp")
+        api.delete_app("example")
       end
 
       it "displays impicit app info" do
         stderr, stdout = execute("apps:info")
         stderr.should == ""
         stdout.should == <<-STDOUT
-=== myapp
-Git URL:       git@heroku.com:myapp.git
+=== example
+Git URL:       git@heroku.com:example.git
 Owner Email:   email@example.com
 Stack:         cedar
-Web URL:       http://myapp.herokuapp.com/
+Tier:          Legacy
+Web URL:       http://example.herokuapp.com/
 STDOUT
       end
 
       it "gets explicit app from --app" do
-        stderr, stdout = execute("apps:info --app myapp")
+        stderr, stdout = execute("apps:info --app example")
         stderr.should == ""
         stdout.should == <<-STDOUT
-=== myapp
-Git URL:       git@heroku.com:myapp.git
+=== example
+Git URL:       git@heroku.com:example.git
 Owner Email:   email@example.com
 Stack:         cedar
-Web URL:       http://myapp.herokuapp.com/
+Tier:          Legacy
+Web URL:       http://example.herokuapp.com/
 STDOUT
       end
 
@@ -49,16 +51,17 @@ STDOUT
 create_status=complete
 created_at=\\d{4}/\\d{2}/\\d{2} \\d{2}:\\d{2}:\\d{2} [+-]\\d{4}
 dynos=0
-git_url=git@heroku.com:myapp.git
+git_url=git@heroku.com:example.git
 id=\\d{1,5}
-name=myapp
+name=example
 owner_email=email@example.com
 repo_migrate_status=complete
 repo_size=
 requested_stack=
 slug_size=
 stack=cedar
-web_url=http://myapp.herokuapp.com/
+tier=legacy
+web_url=http://example.herokuapp.com/
 workers=0
 STDOUT
       end
@@ -84,40 +87,40 @@ STDOUT
 
       it "with a name" do
         with_blank_git_repository do
-          stderr, stdout = execute("apps:create myapp")
+          stderr, stdout = execute("apps:create example")
           stderr.should == ""
           stdout.should == <<-STDOUT
-Creating myapp... done, stack is bamboo-mri-1.9.2
-http://myapp.herokuapp.com/ | git@heroku.com:myapp.git
+Creating example... done, stack is bamboo-mri-1.9.2
+http://example.herokuapp.com/ | git@heroku.com:example.git
 Git remote heroku added
 STDOUT
         end
-        api.delete_app("myapp")
+        api.delete_app("example")
       end
 
       it "with -a name" do
         with_blank_git_repository do
-          stderr, stdout = execute("apps:create -a myapp")
+          stderr, stdout = execute("apps:create -a example")
           stderr.should == ""
           stdout.should == <<-STDOUT
-Creating myapp... done, stack is bamboo-mri-1.9.2
-http://myapp.herokuapp.com/ | git@heroku.com:myapp.git
+Creating example... done, stack is bamboo-mri-1.9.2
+http://example.herokuapp.com/ | git@heroku.com:example.git
 Git remote heroku added
 STDOUT
         end
-        api.delete_app("myapp")
+        api.delete_app("example")
       end
 
       it "with --no-remote" do
         with_blank_git_repository do
-          stderr, stdout = execute("apps:create myapp --no-remote")
+          stderr, stdout = execute("apps:create example --no-remote")
           stderr.should == ""
           stdout.should == <<-STDOUT
-Creating myapp... done, stack is bamboo-mri-1.9.2
-http://myapp.herokuapp.com/ | git@heroku.com:myapp.git
+Creating example... done, stack is bamboo-mri-1.9.2
+http://example.herokuapp.com/ | git@heroku.com:example.git
 STDOUT
         end
-        api.delete_app("myapp")
+        api.delete_app("example")
       end
 
       it "with addons" do
@@ -167,20 +170,20 @@ STDOUT
     context("index") do
 
       before(:each) do
-        api.post_app("name" => "myapp", "stack" => "cedar")
+        api.post_app("name" => "example", "stack" => "cedar")
       end
 
       after(:each) do
-        api.delete_app("myapp")
+        api.delete_app("example")
       end
 
       it "succeeds" do
-        stub_core.list.returns([["myapp", "user"]])
+        stub_core.list.returns([["example", "user"]])
         stderr, stdout = execute("apps")
         stderr.should == ""
         stdout.should == <<-STDOUT
 === My Apps
-myapp
+example
 
 STDOUT
       end
@@ -192,20 +195,20 @@ STDOUT
       context("success") do
 
         before(:each) do
-          api.post_app("name" => "myapp", "stack" => "cedar")
+          api.post_app("name" => "example", "stack" => "cedar")
         end
 
         after(:each) do
-          api.delete_app("myapp2")
+          api.delete_app("example2")
         end
 
         it "renames app" do
           with_blank_git_repository do
-            stderr, stdout = execute("apps:rename myapp2")
+            stderr, stdout = execute("apps:rename example2")
             stderr.should == ""
             stdout.should == <<-STDOUT
-Renaming myapp to myapp2... done
-http://myapp2.herokuapp.com/ | git@heroku.com:myapp2.git
+Renaming example to example2... done
+http://example2.herokuapp.com/ | git@heroku.com:example2.git
 Don't forget to update your Git remotes on any local checkouts.
 STDOUT
           end
@@ -227,32 +230,32 @@ STDERR
     context("destroy") do
 
       before(:each) do
-        api.post_app("name" => "myapp", "stack" => "cedar")
+        api.post_app("name" => "example", "stack" => "cedar")
       end
 
       it "succeeds with app explicitly specified with --app and user confirmation" do
-        stderr, stdout = execute("apps:destroy --confirm myapp")
+        stderr, stdout = execute("apps:destroy --confirm example")
         stderr.should == ""
         stdout.should == <<-STDOUT
-Destroying myapp (including all add-ons)... done
+Destroying example (including all add-ons)... done
 STDOUT
       end
 
       context("fails") do
 
         after(:each) do
-          api.delete_app("myapp")
+          api.delete_app("example")
         end
 
         it "fails with explicit app but no confirmation" do
-          stderr, stdout = execute("apps:destroy myapp")
+          stderr, stdout = execute("apps:destroy example")
           stderr.should == <<-STDERR
- !    Confirmation did not match myapp. Aborted.
+ !    Confirmation did not match example. Aborted.
 STDERR
           stdout.should == "
  !    WARNING: Potentially Destructive Action
- !    This command will destroy myapp (including all add-ons).
- !    To proceed, type \"myapp\" or re-run this command with --confirm myapp
+ !    This command will destroy example (including all add-ons).
+ !    To proceed, type \"example\" or re-run this command with --confirm example
 
 > "
 
@@ -275,73 +278,73 @@ STDERR
 
       it "creates adding heroku to git remote" do
         with_blank_git_repository do
-          stderr, stdout = execute("apps:create myapp")
+          stderr, stdout = execute("apps:create example")
           stderr.should == ""
           stdout.should == <<-STDOUT
-Creating myapp... done, stack is bamboo-mri-1.9.2
-http://myapp.herokuapp.com/ | git@heroku.com:myapp.git
+Creating example... done, stack is bamboo-mri-1.9.2
+http://example.herokuapp.com/ | git@heroku.com:example.git
 Git remote heroku added
 STDOUT
           `git remote`.strip.should match(/^heroku$/)
-          api.delete_app("myapp")
+          api.delete_app("example")
         end
       end
 
       it "creates adding a custom git remote" do
         with_blank_git_repository do
-          stderr, stdout = execute("apps:create myapp --remote myremote")
+          stderr, stdout = execute("apps:create example --remote myremote")
           stderr.should == ""
           stdout.should == <<-STDOUT
-Creating myapp... done, stack is bamboo-mri-1.9.2
-http://myapp.herokuapp.com/ | git@heroku.com:myapp.git
+Creating example... done, stack is bamboo-mri-1.9.2
+http://example.herokuapp.com/ | git@heroku.com:example.git
 Git remote myremote added
 STDOUT
           `git remote`.strip.should match(/^myremote$/)
-          api.delete_app("myapp")
+          api.delete_app("example")
         end
       end
 
       it "doesn't add a git remote if it already exists" do
         with_blank_git_repository do
           `git remote add heroku /tmp/git_spec_#{Process.pid}`
-          stderr, stdout = execute("apps:create myapp")
+          stderr, stdout = execute("apps:create example")
           stderr.should == ""
           stdout.should == <<-STDOUT
-Creating myapp... done, stack is bamboo-mri-1.9.2
-http://myapp.herokuapp.com/ | git@heroku.com:myapp.git
+Creating example... done, stack is bamboo-mri-1.9.2
+http://example.herokuapp.com/ | git@heroku.com:example.git
 STDOUT
-          api.delete_app("myapp")
+          api.delete_app("example")
         end
       end
 
       it "renames updating the corresponding heroku git remote" do
         with_blank_git_repository do
           `git remote add github     git@github.com:test/test.git`
-          `git remote add production git@heroku.com:myapp.git`
-          `git remote add staging    git@heroku.com:myapp-staging.git`
+          `git remote add production git@heroku.com:example.git`
+          `git remote add staging    git@heroku.com:example-staging.git`
 
-          api.post_app("name" => "myapp", "stack" => "cedar")
-          stderr, stdout = execute("apps:rename myapp2")
-          api.delete_app("myapp2")
+          api.post_app("name" => "example", "stack" => "cedar")
+          stderr, stdout = execute("apps:rename example2")
+          api.delete_app("example2")
 
           remotes = `git remote -v`
           remotes.should == <<-REMOTES
 github\tgit@github.com:test/test.git (fetch)
 github\tgit@github.com:test/test.git (push)
-production\tgit@heroku.com:myapp2.git (fetch)
-production\tgit@heroku.com:myapp2.git (push)
-staging\tgit@heroku.com:myapp-staging.git (fetch)
-staging\tgit@heroku.com:myapp-staging.git (push)
+production\tgit@heroku.com:example2.git (fetch)
+production\tgit@heroku.com:example2.git (push)
+staging\tgit@heroku.com:example-staging.git (fetch)
+staging\tgit@heroku.com:example-staging.git (push)
 REMOTES
         end
       end
 
       it "destroys removing any remotes pointing to the app" do
         with_blank_git_repository do
-          `git remote add heroku git@heroku.com:myapp.git`
+          `git remote add heroku git@heroku.com:example.git`
 
-          api.post_app("name" => "myapp", "stack" => "cedar")
-          stderr, stdout = execute("apps:destroy --confirm myapp")
+          api.post_app("name" => "example", "stack" => "cedar")
+          stderr, stdout = execute("apps:destroy --confirm example")
 
           `git remote`.strip.should_not include('heroku')
         end