digitalronin-rackspace 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ba0533cf37abea8c1ea65902886a5268dc5a82d2
+  data.tar.gz: aca6b07411ab9a37a6d96241ead65b4ee55b11d7
+SHA512:
+  metadata.gz: 05025ecc9ae813517a0d615b9afa49c40283c0d51534e3909605c90761f43a58da0f01346146c0ab993398357711fdee89626f3d61c8156b4bf4794c4db6e9e9
+  data.tar.gz: 0a88db9edd98d95b489cfe523b1e8f058fe08882dc06b5c196ad7f7d29039220807b26773944d1ad0415e360d1a4ea28e653dfabc2b3df2ae7379e26627eae99

data/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+gem "fog"
+
+group :development do
+  gem "rake"
+  gem "pry-byebug"
+  gem "rspec"
+  gem "gem-this"
+end

data/Gemfile.lock

@@ -0,0 +1,152 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    CFPropertyList (2.3.1)
+    builder (3.2.2)
+    byebug (4.0.5)
+      columnize (= 0.9.0)
+    coderay (1.1.0)
+    columnize (0.9.0)
+    diff-lcs (1.2.5)
+    excon (0.45.3)
+    fission (0.5.0)
+      CFPropertyList (~> 2.2)
+    fog (1.30.0)
+      fog-atmos
+      fog-aws (~> 0.0)
+      fog-brightbox (~> 0.4)
+      fog-core (~> 1.27, >= 1.27.4)
+      fog-ecloud
+      fog-google (>= 0.0.2)
+      fog-json
+      fog-local
+      fog-powerdns (>= 0.1.1)
+      fog-profitbricks
+      fog-radosgw (>= 0.0.2)
+      fog-riakcs
+      fog-sakuracloud (>= 0.0.4)
+      fog-serverlove
+      fog-softlayer
+      fog-storm_on_demand
+      fog-terremark
+      fog-vmfusion
+      fog-voxel
+      fog-xml (~> 0.1.1)
+      ipaddress (~> 0.5)
+      nokogiri (~> 1.5, >= 1.5.11)
+    fog-atmos (0.1.0)
+      fog-core
+      fog-xml
+    fog-aws (0.1.2)
+      fog-core (~> 1.27)
+      fog-json (~> 1.0)
+      fog-xml (~> 0.1)
+      ipaddress (~> 0.8)
+    fog-brightbox (0.7.1)
+      fog-core (~> 1.22)
+      fog-json
+      inflecto (~> 0.0.2)
+    fog-core (1.30.0)
+      builder
+      excon (~> 0.45)
+      formatador (~> 0.2)
+      mime-types
+      net-scp (~> 1.1)
+      net-ssh (>= 2.1.3)
+    fog-ecloud (0.1.1)
+      fog-core
+      fog-xml
+    fog-google (0.0.5)
+      fog-core
+      fog-json
+      fog-xml
+    fog-json (1.0.1)
+      fog-core (~> 1.0)
+      multi_json (~> 1.0)
+    fog-local (0.2.1)
+      fog-core (~> 1.27)
+    fog-powerdns (0.1.1)
+      fog-core (~> 1.27)
+      fog-json (~> 1.0)
+      fog-xml (~> 0.1)
+    fog-profitbricks (0.0.2)
+      fog-core
+      fog-xml
+      nokogiri
+    fog-radosgw (0.0.4)
+      fog-core (>= 1.21.0)
+      fog-json
+      fog-xml (>= 0.0.1)
+    fog-riakcs (0.1.0)
+      fog-core
+      fog-json
+      fog-xml
+    fog-sakuracloud (1.0.1)
+      fog-core
+      fog-json
+    fog-serverlove (0.1.2)
+      fog-core
+      fog-json
+    fog-softlayer (0.4.5)
+      fog-core
+      fog-json
+    fog-storm_on_demand (0.1.1)
+      fog-core
+      fog-json
+    fog-terremark (0.1.0)
+      fog-core
+      fog-xml
+    fog-vmfusion (0.1.0)
+      fission
+      fog-core
+    fog-voxel (0.1.0)
+      fog-core
+      fog-xml
+    fog-xml (0.1.2)
+      fog-core
+      nokogiri (~> 1.5, >= 1.5.11)
+    formatador (0.2.5)
+    gem-this (0.3.7)
+    inflecto (0.0.2)
+    ipaddress (0.8.0)
+    method_source (0.8.2)
+    mime-types (2.5)
+    mini_portile (0.6.2)
+    multi_json (1.11.0)
+    net-scp (1.2.1)
+      net-ssh (>= 2.6.5)
+    net-ssh (2.9.2)
+    nokogiri (1.6.6.2)
+      mini_portile (~> 0.6.0)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    pry-byebug (3.1.0)
+      byebug (~> 4.0)
+      pry (~> 0.10)
+    rake (10.4.2)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.3)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+    slop (3.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fog
+  gem-this
+  pry-byebug
+  rake
+  rspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 David Salgado
+
+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,43 @@
+A tool to manage Rackspace Cloud servers and Block Storage volumes
+
+[![Gem Version](https://badge.fury.io/rb/digitalronin-rackspace.svg)](http://badge.fury.io/rb/digitalronin-rackspace)
+[![Build Status](https://travis-ci.org/digitalronin/digitalronin-rackspace.svg?branch=master)](https://travis-ci.org/digitalronin/digitalronin-rackspace)
+[![Dependency Status](https://gemnasium.com/digitalronin/digitalronin-rackspace.svg)](https://gemnasium.com/digitalronin/digitalronin-rackspace)
+
+[fog](http://fog.io) is awesome, but the API can be a bit cryptic and long-winded, especially for things like creating a VM with an attached block storage volume
+
+USAGE
+
+Create an 8G General Purpose VM with an attached 75G SATA block storage volume;
+
+    vm = Rackspace::Vm.new(
+      size:     8,
+      account:  'myaccount',
+      name:     'testserver',
+      volume:   { size: 75 }
+    ).create
+
+Destroy a VM and its attached storage volume
+
+    Rackspace::Vm.new(account: 'myaccount', name: 'testserver').destroy(destroy_volume: true)
+
+See the scripts in the examples directory
+
+ASSUMPTIONS/PRE-REQUISITES
+
+* Ruby 2.2.0 (1.9+ should work, but I haven't tested any versions except 2.2)
+* Valid Rackspace Cloud account and API key (see rackspace_credentials.yml.example for how to supply these via a YAML file)
+* By default, VMs are "General Purpose" Ubuntu 14.04 machines - this can be overridden by supplying "image_name" and "flavor_id"
+
+CAVEATS
+
+* This gem will create and destroy cloud servers and block storage volumes in your account. This could cost you money and might destroy data you care about. Use it with caution and at your own risk.
+
+* The gem doesn't support attaching multiple volumes to a server.
+
+* Deleting server with an attached volume can fail if the call to destroy the volume happens before it has finished detaching.
+
+TODO
+
+* The gem should wait to ensure success of any API operations before returning from the relevant method call
+

data/lib/rackspace.rb

@@ -0,0 +1,34 @@
+require 'fog'
+require 'yaml'
+
+module Rackspace
+  # Delay between checks, when waiting for the Rackspace API
+  SLEEP_DELAY = 20
+  # Maximum iterations before we give up waiting for the Rackspace API
+  MAX_ITERATIONS_ON_CREATE = 20
+
+  # Cloud servers
+  DEFAULT_SIZE       = 1
+  DEFAULT_IMAGE_NAME = 'Ubuntu 14.04 LTS (Trusty Tahr) (PVHVM)'
+  DEFAULT_FLAVOUR    = 'general1'
+
+  # Block storage volumes
+  SATA      = 'SATA'
+  SSD       = 'SSD'
+  MIN_SIZE  = 75
+  MAX_SIZE  = 1024
+  AVAILABLE = 'available'
+
+  DEFAULT_REGION = :ord
+end
+
+libdir = File.join(File.dirname(__FILE__), 'rackspace')
+
+require File.join(libdir, 'logger.rb')
+require File.join(libdir, 'base.rb')
+require File.join(libdir, 'api.rb')
+require File.join(libdir, 'server_api.rb')
+require File.join(libdir, 'storage_api.rb')
+require File.join(libdir, 'vm.rb')
+require File.join(libdir, 'volume.rb')
+

data/lib/rackspace/api.rb

@@ -0,0 +1,40 @@
+module Rackspace
+  class Api
+    attr_reader :logger
+
+    def initialize(params)
+      @logger = params.fetch(:logger, Rackspace::Logger.new)
+    end
+
+    private
+
+    def wait_for(name)
+      logger.log "Waiting for #{object_type} #{name}"
+
+      obj = nil; ready = false; iterations = 1
+
+      while !ready do
+        obj = find_by_name(name)
+
+        if obj.nil?
+          logger.log "Waiting for #{object_type} #{name} to appear in API list..."
+        else
+          logger.log "Found #{object_type} #{name}. Status: #{obj.state}, check #{iterations} of #{MAX_ITERATIONS_ON_CREATE}"
+
+          if obj.state == ready_state
+            ready = true
+          end
+        end
+
+        iterations += 1
+
+        raise "#{object_type} not ready after #{iterations} sleeps. Aborting." if iterations > MAX_ITERATIONS_ON_CREATE
+
+        sleep(SLEEP_DELAY) unless ready
+      end
+
+      obj
+    end
+
+  end
+end

data/lib/rackspace/base.rb

@@ -0,0 +1,44 @@
+module Rackspace
+  class Base
+    attr_reader :account, :region, :credentials, :logger
+
+    DEFAULT_CREDENTIALS = 'rackspace_credentials.yml'
+
+    def initialize(params)
+      @logger            = params.fetch(:logger, Rackspace::Logger.new)
+      @account           = params.fetch(:account)
+      @region            = params.fetch(:region, DEFAULT_REGION)
+      @credentials       = params.fetch(:credentials) {
+        credentials_file = params.fetch(:credentials_file, DEFAULT_CREDENTIALS)
+        YAML.load(File.read(credentials_file))
+      }
+    end
+
+    def log(msg)
+      logger.log(msg)
+    end
+
+    def server_api
+      @server_api ||= ServerApi.new(rackspace_credentials)
+    end
+
+    def storage_api
+      @storage_api ||= StorageApi.new(rackspace_credentials)
+    end
+
+    private
+
+    def accounts
+      credentials.fetch(:accounts) { raise("No :accounts section found in credentials") }
+    end
+
+    def rackspace_credentials
+      {
+        rackspace_username: account,
+        rackspace_api_key:  accounts.fetch(account) { raise("No API key found for account: #{account}") },
+        rackspace_region:   region,
+      }
+    end
+
+  end
+end

data/lib/rackspace/logger.rb

@@ -0,0 +1,7 @@
+module Rackspace
+  class Logger
+    def log(msg)
+      puts [Time.now.strftime("%Y-%m-%d %H:%M:%S"), msg].join(' ')
+    end
+  end
+end

data/lib/rackspace/server_api.rb

@@ -0,0 +1,41 @@
+module Rackspace
+  class ServerApi < Api
+    attr_reader :api
+
+    def initialize(rackspace_credentials)
+      super rackspace_credentials
+      @api ||= Fog::Compute.new(
+        rackspace_credentials.merge(
+          version:   :v2,
+          provider:  'Rackspace',
+        )
+      )
+    end
+
+    def find_by_name(name)
+      api.servers.detect {|i| i.name == name}
+    end
+
+    def create(params)
+      api.servers.create(params)
+      wait_for params.fetch(:name)
+    end
+
+    def image_by_name(img_name)
+      img = api.images.detect {|i| i.name == img_name}
+      raise "No such server image #{img_name}" if img.nil?
+      img
+    end
+
+    private
+
+    def object_type
+      'server'
+    end
+
+    def ready_state
+      'ACTIVE'
+    end
+
+  end
+end

data/lib/rackspace/storage_api.rb

@@ -0,0 +1,44 @@
+module Rackspace
+  class StorageApi < Api
+    attr_reader :api
+
+    def initialize(rackspace_credentials)
+      super rackspace_credentials
+      @api ||= Fog::Rackspace::BlockStorage.new(rackspace_credentials)
+    end
+
+    def find_by_name(name)
+      api.volumes.detect { |v| v.display_name == name }
+    end
+
+    def find_by_id(volume_id)
+      api.get_volume volume_id
+    end
+
+    def create(params)
+      name = params.fetch(:name)
+
+      api.volumes.create(
+        size:          params.fetch(:size),
+        display_name:  name,
+        volume_type:   params.fetch(:volume_type),
+      )
+      wait_for(name)
+    end
+
+    def destroy(name)
+      find_by_name(name).destroy
+    end
+
+    private
+
+    def object_type
+      'volume'
+    end
+
+    def ready_state
+      AVAILABLE
+    end
+
+  end
+end

data/lib/rackspace/vm.rb

@@ -0,0 +1,102 @@
+module Rackspace
+  class Vm < Base
+    attr_reader :name, :size, :flavor_id, :image_name, :volume
+
+    def initialize(params)
+      super params
+      @name              = params.fetch(:name)
+      @image_name        = params.fetch(:image_name,  DEFAULT_IMAGE_NAME)
+      @size              = params.fetch(:size,        DEFAULT_SIZE)
+      @flavor_id         = params.fetch(:flavor_id,   "#{DEFAULT_FLAVOUR}-#{size}")
+      @volume_definition = params[:volume]
+    end
+
+    def create
+      log "Creating server #{name} in account #{account}"
+      @server = server_api.create(
+        name:        name,
+        flavor_id:   flavor_id,
+        image_id:    image_id,
+        personality: personality
+      )
+      build_and_attach_volume if @volume_definition
+      self
+    end
+
+    def destroy(options = {})
+      log "Destroying server #{name} in account #{account}"
+      server.attachments.map(&:destroy)
+      volume.destroy if options[:destroy_volume]
+      server.destroy
+      self
+    end
+
+    def public_ip
+      server.ipv4_address
+    end
+
+    def private_ip
+      server.private_ip_address
+    end
+
+    def state
+      server.state
+    end
+
+    def attach_volume(vol)
+      server.attach_volume(vol.volume)
+    end
+
+    def volume
+      @volume ||= begin
+        if attachments.any?
+          Rackspace::Volume.new(
+            account:     account,
+            region:      region,
+            credentials: credentials,
+            volume_id:   attachments.first.volume_id
+          )
+        end
+      end
+    end
+
+    private
+
+    def attachments
+      server.attachments
+    end
+
+    def build_and_attach_volume
+      vol = Rackspace::Volume.new(@volume_definition.merge(
+          account:      account,
+          region:       region,
+          credentials:  credentials,
+          name:         "#{name}-vol",
+      )).create
+
+      log "Attaching block storage volume #{vol.name}"
+      server.attach_volume(vol.volume)
+      @volume = nil # force an API query next time volume is called
+    end
+
+    def server
+      @server ||= server_api.find_by_name(name)
+    end
+
+    def personality
+      [{
+        'path'     => '/root/.ssh/authorized_keys',
+        'contents' => Base64.encode64(credentials.fetch(:public_ssh_key)),
+      }]
+    end
+
+    def image_id
+      server_api.image_by_name(image_name).id
+    end
+
+    def find_by_name
+      server_api.find_by_name(name)
+    end
+
+  end
+end

data/lib/rackspace/volume.rb

@@ -0,0 +1,55 @@
+module Rackspace
+  class Volume < Base
+    attr_reader :volume_type, :size, :name, :volume_id, :device
+
+    def initialize(params)
+      super params
+      if @volume_id = params[:volume_id]
+        fetch_volume_by_id
+      else
+        @volume_type = params.fetch(:volume_type, SATA)
+        @size        = params.fetch(:size, MIN_SIZE)
+        @name        = params.fetch(:name)
+      end
+    end
+
+    def create
+      log "Creating #{size}GB #{volume_type} block storage volume: #{name}"
+      storage_api.create(
+        size:         size,
+        name:         name,
+        volume_type:  volume_type,
+      )
+      self
+    end
+
+    def destroy
+      log "Destroying volume #{name} in account #{account}"
+      volume.destroy
+      self
+    end
+
+    def volume
+      @volume ||= storage_api.find_by_name(name)
+    end
+
+    private
+
+    # Find an existing volume by its volume_id
+    def fetch_volume_by_id
+      vol  = storage_api.find_by_id(volume_id)
+      data = vol.body.fetch("volume")
+      @name        = data.fetch('display_name')
+      @volume_type = data.fetch('volume_type')
+      @size        = data.fetch('size')
+
+      # Sometimes the Rackspace API takes time to update,
+      # and newly-attached volumes don't report any attachments
+      # yet.
+      attachments = data.fetch('attachments')
+      if attachments.any?
+        @device = attachments.first.fetch('device')
+      end
+    end
+  end
+end

data/spec/rackspace/vm_spec.rb

@@ -0,0 +1,193 @@
+require './spec/spec_helper.rb'
+
+describe Rackspace::Vm do
+  let(:credentials) { {
+    accounts:        { 'myaccount' => 'dummy api key' },
+    public_ssh_key:  'dummy ssh key',
+  } }
+
+  let(:params) { {
+    credentials:  credentials,
+    account:      'myaccount',
+    name:         'myserver',
+  } }
+
+  subject(:vm) { described_class.new(params) }
+
+  let(:logger) { double(Rackspace::Logger, log: true) }
+
+  let(:rackspace_credentials) { {
+    rackspace_username:  'myaccount',
+    rackspace_api_key:   'dummy api key',
+    rackspace_region:    :ord,
+  } }
+
+  let(:personality) { [
+    'path'     => '/root/.ssh/authorized_keys',
+    'contents' => Base64.encode64('dummy ssh key')
+  ] }
+
+  let(:image) { double(id: 'some image') }
+
+  let(:api) { double(Rackspace::ServerApi, image_by_name: image, create: true) }
+
+  before do
+    allow(Rackspace::Logger).to receive(:new).and_return(logger)
+  end
+
+  before do
+    allow(Rackspace::ServerApi).to receive(:new).and_return(api)
+  end
+
+  context "with defaults" do
+    it "creates ServerApi instance" do
+      expect(Rackspace::ServerApi).to receive(:new).with(rackspace_credentials).and_return(api)
+      vm.create
+    end
+
+    it "creates a vm" do
+      expect(api).to receive(:create).with({
+        name:         'myserver',
+        flavor_id:    'general1-1',
+        image_id:     'some image',
+        personality:  personality,
+      })
+
+      vm.create
+    end
+  end
+
+  context "overriding vm size" do
+    let(:params) { super().merge(size: 2) }
+
+    it "creates a vm" do
+      expect(api).to receive(:create).with(hash_including(flavor_id: 'general1-2'))
+      vm.create
+    end
+  end
+
+  context "overriding image" do
+    let(:image2) { double(id: 'image2-id') }
+    let(:params) { super().merge(image_name: 'another image') }
+
+    it "creates a vm" do
+      allow(api).to receive(:image_by_name).with('another image').and_return(image2)
+      expect(api).to receive(:create).with(hash_including(image_id: 'image2-id'))
+      vm.create
+    end
+  end
+
+  context "overriding flavor_id" do
+    let(:params) { super().merge(flavor_id: 'some-flavor-id') }
+
+    it "creates a vm" do
+      expect(api).to receive(:create).with(hash_including(flavor_id: 'some-flavor-id'))
+      vm.create
+    end
+  end
+
+  context "overriding region" do
+    let(:params) { super().merge(region: :iad) }
+
+    it "creates ServerApi instance" do
+      expect(Rackspace::ServerApi).to receive(:new).with(hash_including(rackspace_region: :iad))
+      vm.create
+    end
+  end
+
+  context "destroying" do
+    let(:attachment) { double(destroy: true)                            }
+    let(:server)     { double(attachments: [attachment], destroy: true) }
+
+    before do
+      allow(api).to receive(:attachments).and_return([])
+      allow(api).to receive(:find_by_name).with('myserver').and_return(server)
+    end
+
+    it "finds the vm" do
+      expect(api).to receive(:find_by_name).with('myserver')
+      vm.destroy
+    end
+
+    it "destroys the vm" do
+      expect(server).to receive(:destroy)
+      vm.destroy
+    end
+
+    it "detaches volumes" do
+      expect(attachment).to receive(:destroy)
+      vm.destroy
+    end
+  end
+
+  context "attached block storage volumes" do
+    context "attaching volumes" do
+      let(:vol)    { double                                 }
+      let(:volume) { double(Rackspace::Volume, volume: vol) }
+      let(:server) { double                                 }
+
+      before do
+        allow(api).to receive(:find_by_name).with('myserver').and_return(server)
+      end
+
+      it "attaches" do
+        expect(server).to receive(:attach_volume).with(vol)
+        vm.attach_volume(volume)
+      end
+    end
+
+    context "building and attaching a volume" do
+      let(:params) { super().merge(volume: {size: 100}) }
+      let(:vol)    { double }
+      let(:volume) { double(Rackspace::Volume, volume: vol, name: 'myvol') }
+      let(:server) { double(attach_volume: true)                           }
+
+      let(:v_params) { {
+        account:      'myaccount',
+        region:       :ord,
+        credentials:  credentials,
+        name:         'myserver-vol',
+        size:         100,
+      } }
+
+      before do
+        allow(api).to receive(:find_by_name).with('myserver').and_return(server)
+        allow(api).to receive(:create).and_return(server)
+        allow(Rackspace::Volume).to receive(:new).with(v_params).and_return(volume)
+        allow(volume).to receive(:create).and_return(volume)
+      end
+
+      it "creates the volume" do
+        expect(Rackspace::Volume).to receive(:new).with(v_params).and_return(volume)
+        expect(volume).to receive(:create).and_return(volume)
+        vm.create
+      end
+
+      it "attaches the volume" do
+        expect(server).to receive(:attach_volume).with(vol)
+        vm.create
+      end
+
+      context "querying volume" do
+        let(:attachment) { double(volume_id: 'foo') }
+
+        let(:v_params) { {
+          account:      'myaccount',
+          region:       :ord,
+          credentials:  credentials,
+          volume_id:    'foo',
+        } }
+
+        before do
+          allow(server).to receive(:attachments).and_return([attachment])
+        end
+
+        it "returns the first attached volume" do
+          expect(Rackspace::Volume).to receive(:new).with(v_params)
+          vm.volume
+        end
+      end
+    end
+  end
+
+end

data/spec/rackspace/volume_spec.rb

@@ -0,0 +1,116 @@
+require './spec/spec_helper.rb'
+
+describe Rackspace::Volume do
+  let(:credentials) { {
+    accounts:        { 'myaccount' => 'dummy api key' },
+    public_ssh_key:  'dummy ssh key',
+  } }
+
+  let(:params) { {
+    credentials:  credentials,
+    account:      'myaccount',
+    name:         'myvolume',
+  } }
+
+  subject(:volume) { described_class.new(params) }
+
+  let(:logger) { double(Rackspace::Logger, log: true) }
+
+  let(:rackspace_credentials) { {
+    rackspace_username:  'myaccount',
+    rackspace_api_key:   'dummy api key',
+    rackspace_region:    :ord,
+  } }
+
+  let(:api) { double(Rackspace::StorageApi, create: true) }
+
+  before do
+    allow(Rackspace::Logger).to receive(:new).and_return(logger)
+  end
+
+  before do
+    allow(Rackspace::StorageApi).to receive(:new).and_return(api)
+  end
+
+  context "finding by id" do
+    let(:params) { super().merge(volume_id: "dummy-volume-id") }
+    let(:body) { {
+      "volume" => {
+        "display_name" => "myvol",
+        "attachments"  => [{"device" => "/dev/xvdb"}],
+        "volume_type"  => "SATA",
+        "size"         => 75
+      }
+    } }
+    let(:obj) { double(body: body) }
+
+    it "finds" do
+      expect(Rackspace::StorageApi).to receive(:new).with(rackspace_credentials).and_return(api)
+      expect(api).to receive(:find_by_id).with("dummy-volume-id").and_return(obj)
+      volume.device
+    end
+  end
+
+  context "with defaults" do
+    it "creates StorageApi instance" do
+      expect(Rackspace::StorageApi).to receive(:new).with(rackspace_credentials).and_return(api)
+      volume.create
+    end
+
+    it "creates a volume" do
+      expect(api).to receive(:create).with({
+        name:         'myvolume',
+        volume_type:  'SATA',
+        size:         75,
+      })
+
+      volume.create
+    end
+  end
+
+  context "overriding volume size" do
+    let(:params) { super().merge(size: 200) }
+
+    it "creates a volume" do
+      expect(api).to receive(:create).with(hash_including(size: 200))
+      volume.create
+    end
+  end
+
+  context "overriding volume type" do
+    let(:params) { super().merge(volume_type: 'SSD') }
+
+    it "creates a volume" do
+      expect(api).to receive(:create).with(hash_including(volume_type: 'SSD'))
+      volume.create
+    end
+  end
+
+  context "overriding region" do
+    let(:params) { super().merge(region: :iad) }
+
+    it "creates StorageApi instance" do
+      expect(Rackspace::StorageApi).to receive(:new).with(hash_including(rackspace_region: :iad))
+      volume.create
+    end
+  end
+
+  context "destroying" do
+    let(:vol) { double(destroy: true) }
+
+    before do
+      allow(api).to receive(:find_by_name).with('myvolume').and_return(vol)
+    end
+
+    it "finds the volume" do
+      expect(api).to receive(:find_by_name).with('myvolume')
+      volume.destroy
+    end
+
+    it "destroys the volume" do
+      expect(vol).to receive(:destroy)
+      volume.destroy
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require './lib/rackspace'
+
+require 'pry-byebug'
+require 'rspec'
+
+Fog.mock!
+
+

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: digitalronin-rackspace
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- David Salgado
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.30'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.30'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: Create/Query/Destroy rackspace cloud VMs and attached (or not) block
+  storage volumes
+email: david@digitalronin.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- lib/rackspace.rb
+- lib/rackspace/api.rb
+- lib/rackspace/base.rb
+- lib/rackspace/logger.rb
+- lib/rackspace/server_api.rb
+- lib/rackspace/storage_api.rb
+- lib/rackspace/vm.rb
+- lib/rackspace/volume.rb
+- spec/rackspace/vm_spec.rb
+- spec/rackspace/volume_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/digitalronin/digitalronin-rackspace
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Rackspace Cloud Servers and Block Storage Volumes
+test_files: []