cf-deploy 0.1.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Made by Made Ltd
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,251 @@
+# Rake tasks for deploying to CloudFoundry v6+
+
+This gem provides the functionality you need to deploy your rails application to
+a [CloudFoundry][CloudFoundry] provider like [Pivotal][Pivotal].
+
+With `cf-deploy` you can:
+
+ * Define your CloudFoundry connection details in your Rakefile or using
+   environment variables
+ * Implement blue/green deployment
+ * Hook into your existing rake tasks for preparing deploys/syncing assets
+
+## Basics
+
+The functionality comes in the shape of generated rake tasks. You require this
+gem in your `Rakefile` and call the `.rake_tasks!` setup method.
+
+``` ruby
+require 'cf-deploy'
+CF::Deploy.rake_tasks!
+```
+
+By default tasks will be created for each manifest in your `manifests/` folder.
+If you have a `staging.yml` and `production.yml` you can now run the following
+commands:
+
+``` sh
+bundle exec rake cf:deploy:staging
+bundle exec rake cf:deploy:production
+```
+
+This however mimics the commands `cf push -f manifests/staging.yml` and
+`cf push -f manifests/production.yml`. Not really anything helpful or new.
+Things start to get more exciting when you define your environments in your
+`Rakefile` along with their task dependencies just like normal rake task syntax.
+
+``` ruby
+require 'cf-deploy'
+
+CF::Deploy.rake_tasks! do
+  environment :staging => 'assets:precompile'
+  environment :production => [:clean, 'assets:precompile']
+end
+```
+
+Now when running `cf:deploy:staging` and `cf:deploy:production` the prerequisite
+tasks will be run first.
+
+The next thing to talk about is route mapping. You can define a route in a an
+environment block like so:
+
+``` ruby
+require 'cf-deploy'
+
+CF::Deploy.rake_tasks! do
+  environment :staging => 'assets:precompile' do
+    route 'example.com', 'staging'
+  end
+
+  environment :production => [:clean, 'assets:precompile'] do
+    route 'example.com'
+    route 'example.com', 'admin'
+  end
+end
+```
+
+Any time you deploy an environment with one or more routes defined the routes
+will be mapped to all applications in the environment's manifest.
+
+And then things get super interesting when you start talking blue/green.
+
+## What is blue/green deployment?
+
+Simply put, blue/green deployment allows you to deploy a new version of your
+app, test it on a private URL and then direct your traffic to the new version
+when you are ready.
+
+You have two applications for one environment, say production. One version is
+called green, the other is blue. The first time you deploy your app you either
+go to blue or green. Thereafter, any changes you want to deploy you send to the
+color that doesn't have your production domain pointed at it. You test it on
+a private URL and then when you're happy you flip your domain to point at that.
+If something then goes wrong you can then flip your domain back to the last
+working version.
+
+This gem provides rake tasks for you to deploy using this methodology as well
+as the standard single app deployment process on a CloudFoundry provider.
+
+For example you might have a straight forward deployment for staging but use
+the blue/green strategy for production. Here is what your Rakefile might look
+like:
+
+``` ruby
+require 'cf-deploy'
+
+CF::Deploy.rake_tasks! do
+  environment :staging => 'assets:precompile'
+
+  environment :production => 'assets:precompile' do
+    route 'example-app.io'
+  end
+end
+```
+
+You should also have `manifests/production_blue.yml` and
+`manifests/production_green.yml` defined.
+
+When you run `cf:deploy:production` for the first time (assuming neither
+`production_blue.yml` or `production_green.yml` are deployed) your blue app will
+be deployed and route setup.
+
+Running `cf:deploy:production` thereafter will deploy which ever version isn't
+currently deployed. Your route(s) will not be mapped automatically this time.
+Nows your chance to checkout your new deployment using an alternate route. When
+you're happy and want to map your route across run:
+
+``` sh
+bundle exec rake cf:deploy:production:flip
+```
+
+## Installation
+
+You need the `cf` command installed already. Grab the latest release from
+the [CloudFoundry CLI][cli] repo on github.
+
+You then need to install this gem in your project's `Gemfile`:
+
+``` ruby
+gem 'cf-deploy', '0.1.0'
+```
+
+### Defining CloudFoundry details in your Rakefile
+
+You can configure some or all of your CloudFoundry details when calling
+`CF::Deploy.rake_tasks!`.
+
+``` ruby
+require 'cf-deploy'
+
+CF::Deploy.rake_tasks! do
+  api 'api.run.pivotal.io'
+  username 'example@example.com'
+  password 'SOMETHING'
+  organisation 'Made'
+  space 'development'
+
+  environment :staging => 'assets:precompile'
+
+  environment :production => 'assets:precompile' do
+    route 'example-app.io'
+  end
+end
+```
+
+All are optional. If you do not provide any you will be prompted when running
+the rake tasks.
+
+### Defining CloudFoundry details using ENV variables
+
+Instead of defining your CloudFoundry login details in your Rakefile and
+committing them to your code repository you can instead provide them using
+ENV variables on your command line:
+
+``` sh
+export CF_API=api.run.pivotal.io
+export CF_USERNAME=example@example.com
+export CF_PASSWORD=SOMETHING
+export CF_ORG=Made
+export CF_SPACE=development
+```
+
+Now you can run any of the `cf-deploy` rake tasks providing you have called
+`CF::Deploy.rake_tasks!` in your `Rakefile`.
+
+## Commands
+
+### Deploying an environment
+
+If you defined a staging environment in your Rakefile the following task will
+have been created:
+
+```
+bundle exec rake cf:deploy:staging
+```
+
+Run this to deploy out your staging environment.
+
+Any environment you define will have a task created named `cf:deploy:#{env}`.
+
+### Deploy the next blue/green environment
+
+If you have defined CloudFoundry manifest files matching `manifests/*_blue.yml`
+and `manifests/*_green.yml` you will be able to call `rake cf:deploy:*` without
+the `_blue` or `_green`. For example with `production_blue.yml` and
+`production_green.yml` you can call the following:
+
+```
+bundle exec rake cf:deploy:production
+```
+
+Running the deploy task for an env with blue and green manifests will trigger a
+lookup to see which env is currently deployed. The task will then start
+deploying the other production color, so if green is currently deployed then
+blue will be deployed. If neither is currently deployed, blue will be deployed
+first.
+
+Once deployed your routing will still be pointing to the *previous deployment*.
+If you run the same task again, the same environment will be deployed. That is
+if green was deployed, and then you run the task, blue will be deployed, if you
+run the task again, blue will be deployed again. This is because we work out
+the current deployment based on where your routes are pointing and since the
+deploy command for blue green environments doesn't map routes the current
+deployment will not change.
+
+#### First time proviso
+
+This isn't the case for a first time deploy. The first time you deploy your
+blue environment will be deployed and any defined routes will be mapped to all
+apps defined in your blue manifest.
+
+### Switch routes over to new environment
+
+In order to flip your routes from blue to green or vice-versa you need to run
+the following task.
+
+```
+bundle exec rake cf:deploy:production:flip
+```
+
+This will go ahead and map routes to whatever color the routes aren't mapped to
+and then unmap the other color. At this point your new production will be
+deployed and live.
+
+## Credits
+
+[![made](https://s3-eu-west-1.amazonaws.com/made-assets/googleapps/google-apps.png)][made]
+
+Developed and maintained by [Made][made]. Key contributions:
+
+ * [Luke Morton](https://github.com/DrPheltRight)
+
+## License
+
+Copyright © 2014 Made by Made Ltd. It is free software, and may be
+redistributed under the terms specified in the [MIT-LICENSE][license] file.
+
+[CloudFoundry]: http://www.cloudfoundry.org/
+[Pivotal]: https://run.pivotal.io/
+[cli]: https://github.com/cloudfoundry/cli/releases
+[made]: http://www.madetech.co.uk?ref=github&repo=ydtd_frontend
+[license]: https://github.com/madebymade/cf-deploy/blob/master/LICENSE

data/lib/cf-deploy.rb

@@ -0,0 +1 @@
+require 'cf/deploy'

data/lib/cf/deploy.rb

@@ -0,0 +1,70 @@
+require 'cf/deploy/version'
+require 'cf/deploy/config'
+require 'cf/deploy/env_config'
+require 'cf/deploy/commands'
+require 'rake'
+
+module CF
+  class Deploy
+    class << self
+      def rake_tasks!(&block)
+        new(Config.new(&block)).tasks
+      end
+    end
+
+    include Commands
+
+    attr_accessor :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    def tasks
+      [define_login_task].concat(deploy_tasks)
+    end
+
+    def deploy_tasks
+      config[:environments].map { |env| define_deploy_task(env) }
+    end
+
+    def define_login_task
+      return Rake::Task['cf:login'] if Rake::Task.task_defined?('cf:login')
+
+      Rake::Task.define_task('cf:login') do
+        login(config)
+      end
+    end
+
+    def define_deploy_task(env)
+      blue_green_task(env) if env[:deployments].size > 1
+
+      env[:deployments].each do |deployment|
+        Rake::Task.define_task(deployment[:task_name] => env[:deps]) do
+          push(deployment[:manifest])
+
+          env[:routes].each do |route|
+            deployment[:app_names].each do |app_name|
+              map_route(route, app_name)
+            end
+          end
+        end
+      end
+    end
+
+    def first_domain(env)
+      env[:routes].first.values_at(:host, :domain).compact.join('.')
+    end
+
+    def next_production(env)
+      current_production(first_domain(env)) != 'blue' ? 'blue' : 'green'
+    end
+
+    def blue_green_task(env)
+      Rake::Task.define_task(env[:task_name] => env[:deps]) do
+        task_name = EnvConfig.task_name("#{env[:name]}_#{next_production(env)}")
+        Rake::Task[task_name].invoke
+      end
+    end
+  end
+end

data/lib/cf/deploy/commands.rb

@@ -0,0 +1,33 @@
+module CF
+  class Deploy
+    module Commands
+      def login(config)
+        login_cmd = ['cf login']
+
+        login_cmd << Config::VALID_CF_KEYS
+          .reject { |key| config[key].nil? }
+          .map { |key| "-#{key.to_s[0]} #{config[key]}" }
+
+        Kernel.system(login_cmd.flatten.join(' '))
+      end
+
+      def push(manifest)
+        Kernel.system("cf push -f #{manifest}")
+      end
+
+      def map_route(route, app_name)
+        map_cmd = "cf map-route #{app_name} #{route[:domain]}"
+        map_cmd = "#{map_cmd} -n #{route[:hostname]}" unless route[:hostname].nil?
+        Kernel.system(map_cmd)
+      end
+
+      def current_production(domain)
+        io = IO.popen("cf routes | grep #{domain}")
+        matches = /(blue|green)/.match(io.read)
+        io.close
+        return if matches.nil?
+        matches[1].strip
+      end
+    end
+  end
+end

data/lib/cf/deploy/config.rb

@@ -0,0 +1,81 @@
+module CF
+  class Deploy
+    class Config < Hash
+      VALID_CF_KEYS = [:api, :username, :password, :organisation, :space]
+
+      attr_reader :environments_to_be_loaded
+
+      def initialize(&block)
+        @environments_to_be_loaded = []
+
+        merge!(:manifest_glob => 'manifests/*',
+               :api => nil,
+               :username => nil,
+               :password => nil,
+               :organisation => nil,
+               :space => nil)
+
+        instance_eval(&block) if block_given?
+
+        self[:environments] = environments(manifests_by_env)
+      end
+
+      def [](key)
+        from_env(key) || super
+      end
+
+      def from_env(key)
+        ENV["CF_#{key.upcase}"] if VALID_CF_KEYS.include?(key)
+      end
+
+      def manifests_by_env
+        Dir[self[:manifest_glob]].reduce({}) do |envs, manifest|
+          if manifest =~ /_blue.yml$/
+            env = File.basename(manifest, '_blue.yml').to_sym
+          elsif manifest =~ /_green.yml$/
+            env = File.basename(manifest, '_green.yml').to_sym
+          else
+            env = File.basename(manifest, '.yml').to_sym
+          end
+
+          envs[env] ||= []
+          envs[env] << manifest
+          envs
+        end
+      end
+
+      def environments(manifests_by_env)
+        environments = []
+
+        environments_to_be_loaded.each do |(env, block)|
+          if env.is_a?(Hash)
+            name, deps = env.first
+            deps = (['cf:login'] << deps).flatten
+          else
+            name = env
+            deps = ['cf:login']
+          end
+
+          manifests = manifests_by_env.delete(name) || []
+          environments << EnvConfig.new(name, deps, manifests, &block)
+        end
+
+        manifests_by_env.each do |(name, manifests)|
+          environments << EnvConfig.new(name, ['cf:login'], manifests)
+        end
+
+        environments
+      end
+
+      # Config setter methods
+      #
+      def manifest_glob(glob) self[:manifest_glob] = glob end
+      def api(api) self[:api] = api end
+      def username(username) self[:username] = username end
+      def password(password) self[:password] = password end
+      def organisation(organisation) self[:organisation] = organisation end
+      def space(space) self[:space] = space end
+      def environment(env, &block) @environments_to_be_loaded << [env, block] end
+    end
+  end
+end

data/lib/cf/deploy/env_config.rb

@@ -0,0 +1,57 @@
+require 'yaml'
+
+module CF
+  class Deploy
+    class EnvConfig < Hash
+      def self.task_name(name)
+        "cf:deploy:#{name}"
+      end
+
+      def initialize(name, deps, manifests, &block)
+        merge!(:name => name,
+               :task_name => EnvConfig.task_name(name),
+               :deps => deps,
+               :routes => [],
+               :manifests => manifests)
+
+        instance_eval(&block) if block_given?
+
+        self[:deployments] = deployments
+      end
+
+      def deployments
+        self[:manifests].map { |manifest| deployment_for_manifest(manifest) }
+      end
+
+      def deployment_for_manifest(manifest)
+        if self[:manifests].size > 1
+          task_name = EnvConfig.task_name(File.basename(manifest, '.yml').to_sym)
+        else
+          task_name = self[:task_name]
+        end
+
+        {:task_name => task_name,
+         :manifest => manifest,
+         :app_names => app_names_for_manifest(manifest)}
+      end
+
+      def app_names_for_manifest(manifest)
+        YAML.load_file(manifest)['applications'].map { |a| a['name'] }
+      end
+
+      # Environment config setter methods
+      #
+      def manifest(manifest)
+        self[:manifests] << manifest
+      end
+
+      def manifests(manifests)
+        self[:manifests].concat(manifests)
+      end
+
+      def route(domain, hostname = nil)
+        self[:routes] << {:domain => domain, :hostname => hostname}
+      end
+    end
+  end
+end

data/lib/cf/deploy/version.rb

@@ -0,0 +1,5 @@
+module CF
+  class Deploy
+    VERSION = "0.1.0"
+  end
+end

data/spec/blue_green_task_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'cf-deploy'
+require 'rake'
+
+describe CF::Deploy do
+  before :each do
+    Rake::Task.clear
+  end
+
+  context 'Blue/green deployment task' do
+    let :rake_tasks! do
+      Dir.chdir('spec/') do
+        described_class.rake_tasks! do
+          environment :production do
+            route 'example.com'
+            route 'example.com', '2'
+          end
+        end
+      end
+    end
+
+    it 'should exist if *_blue.yml and *_green.yml manifests exist' do
+      rake_tasks!
+      expect(Rake::Task['cf:deploy:production']).to be_a(Rake::Task)
+    end
+
+    it 'should deploy blue if not currently deployed' do
+      rake_tasks!
+      expect(Kernel).to receive(:system).with('cf login').ordered
+      expect(IO).to receive(:popen).with('cf routes | grep example.com') { double(:read => '', :close => nil) }
+      expect(Kernel).to receive(:system).with('cf push -f manifests/production_blue.yml').ordered
+      expect(Kernel).to receive(:system).with('cf map-route production-blue-app example.com').ordered
+      expect(Kernel).to receive(:system).with('cf map-route production-blue-app example.com -n 2').ordered
+      Rake::Task['cf:deploy:production'].invoke
+    end
+
+    it 'should deploy blue if green currently deployed' do
+      rake_tasks!
+      expect(Kernel).to receive(:system).with('cf login').ordered
+      expect(IO).to receive(:popen).with('cf routes | grep example.com') { double(:read => 'production-green-app', :close => nil) }
+      expect(Kernel).to receive(:system).with('cf push -f manifests/production_blue.yml').ordered
+      expect(Kernel).to receive(:system).with('cf map-route production-blue-app example.com').ordered
+      expect(Kernel).to receive(:system).with('cf map-route production-blue-app example.com -n 2').ordered
+      Rake::Task['cf:deploy:production'].invoke
+    end
+
+    it 'should deploy green if blue currently deployed' do
+      rake_tasks!
+      expect(Kernel).to receive(:system).with('cf login').ordered
+      expect(IO).to receive(:popen).with('cf routes | grep example.com') { double(:read => 'production-blue-app', :close => nil) }
+      expect(Kernel).to receive(:system).with('cf push -f manifests/production_green.yml').ordered
+      expect(Kernel).to receive(:system).with('cf map-route production-green-app example.com').ordered
+      expect(Kernel).to receive(:system).with('cf map-route production-green-app example.com -n 2').ordered
+      Rake::Task['cf:deploy:production'].invoke
+    end
+
+    xit 'should throw exception if no routes defined for blue/green task' do
+    end
+  end
+end

data/spec/deploy_task_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+require 'cf-deploy'
+require 'rake'
+
+describe CF::Deploy do
+  before :each do
+    Rake::Task.clear
+  end
+
+  context 'Rake::Task[cf:deploy:XX]' do
+    it 'should run a manifest' do
+      Dir.chdir('spec/') do
+        described_class.rake_tasks!
+      end
+
+      expect(Kernel).to receive(:system).with('cf login').ordered
+      expect(Kernel).to receive(:system).with('cf push -f manifests/staging.yml').ordered
+      Rake::Task['cf:deploy:staging'].invoke
+    end
+
+    it 'should setup a route if defined after pushing manifest' do
+      Dir.chdir('spec/') do
+        described_class.rake_tasks! do
+          environment :test do
+            route 'testexample.com'
+          end
+        end
+      end
+
+      expect(Kernel).to receive(:system).with('cf login').ordered
+      expect(Kernel).to receive(:system).with('cf push -f manifests/test.yml').ordered
+      expect(Kernel).to receive(:system).with('cf map-route test-app testexample.com').ordered
+      Rake::Task['cf:deploy:test'].invoke
+    end
+
+    it 'should setup a route with a hostname if defined' do
+      Dir.chdir('spec/') do
+        described_class.rake_tasks! do
+          environment :test do
+            route 'example.com', 'test'
+          end
+        end
+      end
+
+      expect(Kernel).to receive(:system).with('cf login').ordered
+      expect(Kernel).to receive(:system).with('cf push -f manifests/test.yml').ordered
+      expect(Kernel).to receive(:system).with('cf map-route test-app example.com -n test')
+      Rake::Task['cf:deploy:test'].invoke
+    end
+
+    it 'should setup multiple routes if defined' do
+      Dir.chdir('spec/') do
+        described_class.rake_tasks! do
+          environment :test do
+            route 'example.com'
+            route 'example.com', '2'
+          end
+        end
+      end
+
+      expect(Kernel).to receive(:system).with('cf login').ordered
+      expect(Kernel).to receive(:system).with('cf push -f manifests/test.yml').ordered
+      expect(Kernel).to receive(:system).with('cf map-route test-app example.com').ordered
+      expect(Kernel).to receive(:system).with('cf map-route test-app example.com -n 2').ordered
+      Rake::Task['cf:deploy:test'].invoke
+    end
+
+    xit 'should not map routes if push fails' do
+    end
+
+    xit 'should throw decent error if manifest does not exist' do
+    end
+
+    xit 'should throw decent error if manifest invalid' do
+    end
+
+    it 'should allow individual manifest to be specified' do
+      Dir.chdir('spec/') do
+        CF::Deploy.rake_tasks! do
+          environment :custom_manifest do
+            manifest 'manifests/staging.yml'
+          end
+        end
+      end
+
+      expect(Kernel).to receive(:system).with('cf login').ordered
+      expect(Kernel).to receive(:system).with('cf push -f manifests/staging.yml').ordered
+      Rake::Task['cf:deploy:custom_manifest'].invoke
+    end
+  end
+end

data/spec/login_task_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'cf-deploy'
+require 'rake'
+
+describe CF::Deploy do
+  before :each do
+    Rake::Task.clear
+  end
+
+  context 'Rake::Task[cf:login]' do
+    it 'should run `cf login` without arguments if none provided' do
+      described_class.rake_tasks!
+      expect(Kernel).to receive(:system).with('cf login')
+      Rake::Task['cf:login'].invoke
+    end
+
+    it 'should include defined details' do
+      described_class.rake_tasks! do
+        api 'api.run.pivotal.io'
+      end
+
+      expect(Kernel).to receive(:system).with('cf login -a api.run.pivotal.io')
+      Rake::Task['cf:login'].invoke
+    end
+
+    it 'should include all defined details' do
+      described_class.rake_tasks! do
+        api 'api'
+        username 'test'
+        password 'pass'
+        organisation 'org'
+        space 'space'
+      end
+
+      expect(Kernel).to receive(:system).with('cf login -a api -u test -p pass -o org -s space')
+      Rake::Task['cf:login'].invoke
+    end
+
+    it 'should include all details provided in ENV' do
+      {'CF_API' => 'api',
+       'CF_USERNAME' => 'test',
+       'CF_PASSWORD' => 'pass',
+       'CF_ORGANISATION' => 'org',
+       'CF_SPACE' => 'space'}.each do |(k, v)|
+        expect(ENV).to receive(:[]).with(k).and_return(v).at_least(:once)
+      end
+
+      expect(Kernel).to receive(:system).with('cf login -a api -u test -p pass -o org -s space')
+      described_class.rake_tasks!
+      Rake::Task['cf:login'].invoke
+    end
+
+    it 'should mix and match ENV and defined details with ENV having precedence' do
+      {'CF_API' => nil,
+       'CF_USERNAME' => 'test',
+       'CF_PASSWORD' => 'pass',
+       'CF_ORGANISATION' => 'org',
+       'CF_SPACE' => nil}.each do |(k, v)|
+        expect(ENV).to receive(:[]).with(k).and_return(v).at_least(:once)
+      end
+
+      expect(Kernel).to receive(:system).with('cf login -a api -u test -p pass -o org')
+
+      described_class.rake_tasks! do
+        api 'api'
+        organisation 'will be overridden by ENV[CF_ORGANISATION]'
+      end
+
+      Rake::Task['cf:login'].invoke
+    end
+  end
+end

data/spec/rake_tasks_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'cf-deploy'
+require 'rake'
+
+describe CF::Deploy do
+  before :each do
+    Rake::Task.clear
+  end
+
+  context '.rake_tasks!' do
+    it 'should install task for each manifest' do
+      Dir.chdir('spec/') do
+        described_class.rake_tasks!
+      end
+
+      expect(Rake::Task['cf:deploy:staging']).to be_a(Rake::Task)
+      expect(Rake::Task['cf:deploy:test']).to be_a(Rake::Task)
+    end
+
+    it 'should install login task' do
+      Dir.chdir('spec/') do
+        described_class.rake_tasks!
+      end
+
+      expect(Rake::Task['cf:login']).to be_a(Rake::Task)
+    end
+
+    it 'should install a login task as a prerequisite for deploy tasks' do
+      Dir.chdir('spec/') do
+        described_class.rake_tasks!
+      end
+
+      expect(Rake::Task['cf:deploy:staging'].prerequisite_tasks[0]).to be(Rake::Task['cf:login'])
+    end
+
+    it 'should install tasks with prerequisites' do
+      expected_task_1 = Rake::Task.define_task('asset:precompile')
+      expected_task_2 = Rake::Task.define_task(:clean)
+
+      Dir.chdir('spec/') do
+        described_class.rake_tasks! do
+          environment :staging => 'asset:precompile'
+          environment :test => ['asset:precompile', :clean]
+        end
+      end
+
+      expect(Rake::Task['cf:deploy:staging'].prerequisite_tasks[1]).to be(expected_task_1)
+      expect(Rake::Task['cf:deploy:test'].prerequisite_tasks[2]).to be(expected_task_2)
+    end
+
+    it 'should have a configurable manifest glob options' do
+      Dir.chdir('spec/') do
+        described_class.rake_tasks! do
+          manifest_glob 'manifests/staging.yml'
+        end
+      end
+
+      expect(Rake::Task.tasks.count).to eq(2)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+
+SimpleCov.start

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: cf-deploy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Luke Morton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+description: 
+email:
+- luke@madebymade.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cf/deploy/commands.rb
+- lib/cf/deploy/config.rb
+- lib/cf/deploy/env_config.rb
+- lib/cf/deploy/version.rb
+- lib/cf/deploy.rb
+- lib/cf-deploy.rb
+- spec/blue_green_task_spec.rb
+- spec/deploy_task_spec.rb
+- spec/login_task_spec.rb
+- spec/rake_tasks_spec.rb
+- spec/spec_helper.rb
+- LICENSE
+- README.md
+homepage: https://github.com/madebymade/cf-deploy
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3630708785980553311
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3630708785980553311
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Rake tasks for deploying to CloudFoundry v6+
+test_files: []