atlantic_net 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 299bbd01dc49308dc29dcd96726cb87d285ea780
+  data.tar.gz: 4a88ca4ab658e36d2304751256add890efb9aff5
+SHA512:
+  metadata.gz: a71669c2dcb9c443e6a82dd7a2272b040b80bea41e449ce399caee070ccd86debe8a2ef2cadbfdc6924a9cfb7d2499d8de0c79c968ddb89964dbbe02c33ab5e4
+  data.tar.gz: 13edd8a8cb2ce77f949d6fbea6ed3b0e7fb5c3e6f1b711cc586d9d12859879cf4dd4879c5f69f6c7ca48eb72109529bc406cae5bd51915212f6f6be35c07a4ae

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+coverage
+Gemfile.lock
+.idea

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.3.0

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2016 Jamie Starke
+
+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,30 @@
+# atlantic_net
+
+[![Build Status](https://travis-ci.org/jrstarke/atlantic_net.png?branch=master)](https://travis-ci.org/jrstarke/atlantic_net)
+[![Coverage Status](https://coveralls.io/repos/jrstarke/atlantic_net/badge.png)](https://coveralls.io/r/jrstarke/atlantic_net)
+
+A lightweight ruby interface for interacting with the Atlantic.net API.
+
+## Installation
+
+Add atlantic_net to your Gemfile:
+
+``` ruby
+gem "atlantic_net"
+```
+
+## Usage
+
+``` ruby
+# Require the atlantic_net library
+require 'atlantic_net'
+
+# Instantiate the client with your access key and private key
+client = AtlanticNet.new(access_key, private_key)
+
+# List instances
+instances = client.list_instances
+
+# Reboot an instance
+subject.reboot_instance(instances.first["InstanceId"])
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/atlantic_net.gemspec

@@ -0,0 +1,27 @@
+Gem::Specification.new do |spec|
+  spec.name          = "atlantic_net"
+  spec.version       = "0.1.1"
+  spec.authors       = ["Jamie Starke"]
+  spec.email         = ["git@jamiestarke.com"]
+  spec.description   = "A Ruby wrapper of the Atlantic.net API"
+  spec.summary       = "A Ruby wrapper of the Atlantic.net API"
+  spec.homepage      = "http://github.com/jrstarke/atlantic_net"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "rspec", ">= 3.0.0"
+  spec.add_development_dependency "rspec-given"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "uuidtools"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency 'pry-nav'
+end

data/lib/atlantic_net.rb

@@ -0,0 +1,260 @@
+require 'base64'
+require 'openssl'
+require 'securerandom'
+require 'pry'
+require 'json'
+
+class AtlanticNetException < StandardError
+  attr_reader :atlantic_net_instance, :api_response
+
+  def initialize(instance, response, message)
+    super(message)
+    @atlantic_net_instance = instance
+    @api_response = response
+  end
+end
+
+class AtlanticNet
+
+  VERSION = "2010-12-30"
+  FORMAT =  "json"
+
+  class HttpTransport
+
+    API_URI = "https://cloudapi.atlantic.net"
+
+    # Sends the request to the API endpoint
+    #
+    # @param [Hash] data The Data to pass with the request
+    #
+    def send_request (data)
+      uri = URI.parse(API_URI)
+      uri.query = URI.encode_www_form(data)
+      
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      
+      response = http.get(uri.request_uri)
+
+      unless response.code.to_i == 200
+        fail AtlanticNetException.new(nil, {}, "The Atlantic.net api endpoint was unexpectedly unavailable. The HTTP Status code was #{response.code}")
+      end
+
+      JSON.parse(response.body)
+    end
+  end
+
+  # @param [String] access_key The Access Key for your Account.
+  #   This is the "API Public Key" from the Account Settings page.
+  #
+  # @param [String] private_key The Private Key for your Account.
+  #   This is the "API Private Key" from the Account Settings page.
+  #
+  def initialize(access_key, private_key, options = {})
+    @access_key = access_key
+    @private_key = private_key
+    @transport = transport_from_options(options)
+  end
+
+  # Generates a Base64 encoded Sha256 HMAC given a timestamp and a request_id
+  #
+  # @param [String,Int] timestamp The timestamp of the requesting call.
+  #   This should be the time the the request was originally made.
+  #
+  # @param [String] request_id The UUID representing the request.
+  #   This should be unique for each request.
+  #
+  # @return [String] A Base64 encoded HMAC of the timestamp and request_id 
+  #
+  def signature(timestamp, request_id)
+    string_to_sign = "#{timestamp}#{request_id}"
+
+    digest = OpenSSL::Digest.new('sha256')
+    Base64.encode64(OpenSSL::HMAC.digest(digest, @private_key, string_to_sign)).strip()
+  end
+
+  # Retrieve the list of currently active cloud servers.
+  #
+  # @return [Array<Hash>] The list of servers
+  #
+  def list_instances
+    response = api_call('list-instances')
+    response['list-instancesresponse']['instancesSet'].values
+  end
+
+  # Restart a specific cloud server.
+  #
+  # @param [String] instance_id The instance ID of the server you want to reboot.
+  # 
+  # @param [Hash] options The options to include with restart.
+  # @option options [String] :reboot_type (soft) Whether you want to perform a soft or hard reboot.
+  #   soft is the equivalent of performing a graceful shutdown.
+  #   hard is the equivalent of disconnecting the power and reconnecting it.
+  #
+  # @return [Hash] The return value of the request
+  #
+  def reboot_instance(instance_id, options={})
+    reboot_type = options[:reboot_type] || "soft"
+    response = api_call('reboot-instance', {instanceid: instance_id, reboottype: reboot_type})
+    response["reboot-instanceresponse"]["return"]
+  end
+
+  # Describe a specific cloud server.
+  #
+  # @param [String] instance_id The instance ID of the server you want to describe.
+  #
+  # @return [Hash] The hash of the instance
+  #
+  def describe_instance(instance_id)
+    response = api_call('describe-instance', {instanceid: instance_id})
+    response["describe-instanceresponse"]["instanceSet"]["item"]
+  end
+
+  # Terminate a specific cloud server.
+  #
+  # @param [String] instance_id The instance ID of the server you want to terminate.
+  #
+  # @return [Hash] The termination response result.
+  #
+  def terminate_instance(instance_id)
+    response = api_call('terminate-instance', {instanceid: instance_id})
+    response["terminate-instanceresponse"]["instancesSet"]["item"]
+  end
+
+  # Run a cloud server with the provided configuration options. 
+  #
+  # @param [String] server_name The name/description that will be used for the instance
+  #
+  # @param [String] plan_name The plan that should be used for this instance
+  #
+  # @param [String] vm_location The data center location you want this instance launched
+  #
+  # @param [Hash] args A hash of the options
+  # @option options [String] :image_id The VM image to use for this instance. This or :clone_image are required.
+  # @option options [String] :clone_image The server to clone for this instance. This or :image_id are required.
+  # @option options [Boolean] :enable_backup Whether backups should be enabled for this instance.
+  # @option options [Int] :server_quantity How many instances of this server should be launched.
+  # @option options [String] :key_id The ID of the key to deploy for accessing this server.
+  #
+  # @return [Hash] The run instance result
+  #
+  def run_instance(server_name, plan_name, vm_location, options={})
+    option_mapping = {
+      image_id: :imageid,
+      clone_image: :cloneimage,
+      enable_backup: :enablebackup,
+      server_quantity: :serverqty,
+      key_id: :key_id
+    }
+
+    request_options = {servername: server_name, planname: plan_name, vm_location: vm_location}
+
+    unless options.has_key? :image_id or options.has_key? :clone_image
+      fail ArgumentError.new("Missing argument: image_id or clone_image are required")
+    end
+
+    option_mapping.each do | key, value |
+      if options.has_key? key
+        request_options[value] = options[key]
+      end
+    end
+
+    response = api_call('run-instance', request_options)
+    response["run-instanceresponse"]["instancesSet"]["item"]
+  end
+
+  # Retrieve the description of all available cloud images or the description of a specific cloud image by providing the image id 
+  #
+  # @param [Hash] options A hash of the options
+  # @option options [String] :image_id ID indicating the flavor and version number of the operating system image
+  #
+  # @return [Array<Hash>] A array of image descriptions
+  #
+  def describe_images(options={})
+    args = {}
+
+    if options.has_key? :image_id
+      response = api_call('describe-image', {imageid: options[:image_id]})
+    else
+      response = api_call('describe-image')      
+    end
+
+    response["describe-imageresponse"]["imagesset"].values
+  end
+
+  # Retrieve a list of available cloud server plans, narrow the listing down optionally
+  # by server platform, or get information about just one specific plan
+  #
+  # @param [Hash] options A hash of the options
+  # @option options [String] plan_name The name of the plan to describe
+  # @option options [String] platform The platform to filter plans by (windows, linux)
+  #
+  # @return [Array<Hash>] An array of plan descriptions
+  #
+  def describe_plans(options={})
+    if options.empty?
+      response = api_call('describe-plan')
+    else
+      response = api_call('describe-plan',options)
+    end
+
+    response["describe-planresponse"]["plans"].values
+  end
+
+  # Retrieve the details of all SSH Keys associated with the account
+  #
+  # @return [Array<Hash>] An array of SSH keys
+  #
+  def list_ssh_keys
+    response = api_call('list-sshkeys')
+    response["list-sshkeysresponse"]["KeysSet"].values
+  end
+
+
+protected
+
+  # Generate the next timestamp and request_id combination 
+  #
+  # @return [Int, String] timestamp, request_id
+  #
+  def generate_request_id_tuple
+    timestamp = Time.now().to_i
+    request_uuid = SecureRandom.uuid
+    [timestamp, request_uuid]
+  end
+
+  # Performs the request and sends it off to the transport
+  #
+  # @param [String] action The API Action to perform.
+  #
+  # @param [Hash] args The arguments to pass with the request to the API.
+  #
+  def api_call(action, args = {})
+    timestamp, request_id = generate_request_id_tuple()
+    request_signature = signature(timestamp, request_id)
+
+    args = args.merge(
+      Version: VERSION,
+      ACSAccessKeyId: @access_key,
+      Format: FORMAT,
+      Timestamp: timestamp,
+      Rndguid: request_id,
+      Signature: request_signature,
+      Action: action
+    )
+
+    response = @transport.send_request(args)
+    if response.has_key? "error"
+      fail AtlanticNetException.new(self, response, response["error"]["message"])
+    end
+
+    response
+  end
+
+private
+
+  def transport_from_options(options)
+    options[:transport] || AtlanticNet::HttpTransport.new
+  end
+
+end

data/spec/atlantic_net_spec.rb

@@ -0,0 +1,608 @@
+require "spec_helper"
+
+describe AtlanticNet do
+  let(:subject) { AtlanticNet.new(access_key, private_key, options) }
+
+  let(:access_key) { "public_key" }
+  let(:private_key) { "secret" }
+
+  let(:options) { { transport: transport } }
+  let(:transport) { double(:transport, send_request: {}) }
+  
+  let(:sample_timestamp) { "Mess" }
+  let(:sample_request_id) { "age" }
+  let(:sample_signature) { "qnR8UCqJggD55PohusaBNviGoOJ67HC6Btry4qXLVZc=" }
+
+  describe "#signature" do
+    it 'returns sample signature' do
+      signature = subject.signature(sample_timestamp,sample_request_id)
+      expect(signature).to eq sample_signature
+    end
+  end
+
+  describe "#list_instances" do
+    let(:sample_api_response) { 
+      {
+        "Timestamp" => 1440018626,
+        "list-instancesresponse" => {
+          "instancesSet" => {
+            "1item" => {
+              "InstanceId" => "145607",
+              "cu_id" => "17",
+              "rate_per_hr" => "0.0341",
+              "vm_bandwidth" => "600",
+              "vm_cpu_req" => "1",
+              "vm_created_date" => "1438048503",
+              "vm_description" => "New",
+              "vm_disk_req" => "40",
+              "vm_image" => "CentOS-7.1-cPanel_64bit",
+              "vm_image_display_name" => "CentOS 6.5 64bit Server - cPanel/WHM",
+              "vm_ip_address" => "209.208.65.177",
+              "vm_name" => "17-145607",
+              "vm_network_req" => "1",
+              "vm_os_architecture" => "64",
+              "vm_plan_name" => "S",
+              "vm_ram_req" => "1024",
+              "vm_status" => "RUNNING"
+            },
+            "item" => {
+              "InstanceId" => "153979",
+              "cu_id" => "17",
+              "rate_per_hr" => "0.0547",
+              "vm_bandwidth" => "600",
+              "vm_cpu_req" => "2",
+              "vm_created_date" => "1440018294",
+              "vm_description" => "apitestserver",
+              "vm_disk_req" => "100",
+              "vm_image" => "ubuntu-14.04_64bit",
+              "vm_image_display_name" => "ubuntu-14.04_64bit",
+              "vm_ip_address" => "45.58.35.251",
+              "vm_name" => "17-153979",
+              "vm_network_req" => "1",
+              "vm_os_architecture" => "64",
+              "vm_plan_name" => "L",
+              "vm_ram_req" => "4096",
+              "vm_status" => "RUNNING" 
+            }
+          },
+          "requestid" => "c2a1bc2a-4440-438a-bd28-74dbc10a4047"
+        }
+      }
+    }
+    let(:expected_instances) {
+      [
+        {
+          "InstanceId" => "145607",
+          "cu_id" => "17",
+          "rate_per_hr" => "0.0341",
+          "vm_bandwidth" => "600",
+          "vm_cpu_req" => "1",
+          "vm_created_date" => "1438048503",
+          "vm_description" => "New",
+          "vm_disk_req" => "40",
+          "vm_image" => "CentOS-7.1-cPanel_64bit",
+          "vm_image_display_name" => "CentOS 6.5 64bit Server - cPanel/WHM",
+          "vm_ip_address" => "209.208.65.177",
+          "vm_name" => "17-145607",
+          "vm_network_req" => "1",
+          "vm_os_architecture" => "64",
+          "vm_plan_name" => "S",
+          "vm_ram_req" => "1024",
+          "vm_status" => "RUNNING"
+        },
+        {
+          "InstanceId" => "153979",
+          "cu_id" => "17",
+          "rate_per_hr" => "0.0547",
+          "vm_bandwidth" => "600",
+          "vm_cpu_req" => "2",
+          "vm_created_date" => "1440018294",
+          "vm_description" => "apitestserver",
+          "vm_disk_req" => "100",
+          "vm_image" => "ubuntu-14.04_64bit",
+          "vm_image_display_name" => "ubuntu-14.04_64bit",
+          "vm_ip_address" => "45.58.35.251",
+          "vm_name" => "17-153979",
+          "vm_network_req" => "1",
+          "vm_os_architecture" => "64",
+          "vm_plan_name" => "L",
+          "vm_ram_req" => "4096",
+          "vm_status" => "RUNNING" 
+        }
+      ]
+    }
+
+    # it 'calls api_call with list-instances api' do
+    #   expect(subject).to receive(:api_call).with("list-instances").and_return(sample_api_response)
+    #   subject.list_instances
+    # end
+
+    it 'calls api_call with list-instances and returns a list of instance hashes' do
+      allow(subject).to receive(:api_call).with("list-instances").and_return(sample_api_response)
+      instances = subject.list_instances
+      expect(instances).to eq expected_instances
+    end
+  end
+
+  describe '#reboot_instance' do
+    let(:instance_id) { "234" }
+    let(:sample_api_response) {
+      {
+        "Timestamp" => 1440171938,
+        "reboot-instanceresponse" => {
+          "requestid" => "6723430f-c416-46de-a03d-2d2ea38d3af7",
+          "return" => {
+            "Message" => "Successfully queued for reboot",
+            "value" => "true"
+          }
+        }
+      }
+    }
+    let(:expected_return) {
+      {
+        "Message" => "Successfully queued for reboot",
+        "value" => "true"
+      }
+    }
+
+    context "default options" do
+      let(:reboot_type) { "soft" }
+      
+      it 'calls api_call with reboot-instance and instance_id' do
+        expect(subject).to receive(:api_call)
+          .with("reboot-instance", {instanceid: instance_id, reboottype: reboot_type})
+          .and_return(sample_api_response)
+        result = subject.reboot_instance(instance_id)
+        expect(result).to eq expected_return
+      end
+    end
+    
+    context "reboot_type override" do
+      let(:reboot_type) { "hard" }
+
+      it 'calls api_call with reboot-instance, instance_id and reboot_type' do
+        expect(subject).to receive(:api_call)
+          .with("reboot-instance", {instanceid: instance_id, reboottype: reboot_type})
+          .and_return(sample_api_response)
+        result = subject.reboot_instance(instance_id, reboot_type: reboot_type)
+        expect(result).to eq expected_return
+      end
+    end
+  end
+
+  describe "#describe_instance" do
+    let(:instance_id) { "234" }
+    let(:sample_api_response) {
+      {
+        "Timestamp" => 1440020019,
+        "describe-instanceresponse" => {
+          "instanceSet" => {
+            "item" => {
+              "InstanceId" => "153979",
+              "cloned_from" => "",
+              "cu_id" => "17",
+              "disallow_deletion" => "N",
+              "rate_per_hr" => "0.0547",
+              "removed" => "N",
+              "reprovisioning_processed_date" => nil,
+              "resetpwd_processed_date" => nil,
+              "vm_bandwidth" => "600",
+              "vm_cpu_req" => "2",
+              "vm_created_date" => "1440018294",
+              "vm_description" => "apitestserver",
+              "vm_disk_req" => "100",
+              "vm_id" => "153979",
+              "vm_image" => "ubuntu-14.04_64bit",
+              "vm_image_display_name" => "ubuntu-14.04_64bit",
+              "vm_ip_address" => "45.58.35.251",
+              "vm_ip_gateway" => "45.58.34.1",
+              "vm_ip_subnet" => "255.255.254.0",
+              "vm_network_req" => "1",
+              "vm_os_architecture" => "64",
+              "vm_plan_name" => "L",
+              "vm_ram_req" => "4096",
+              "vm_removed_date" => nil,
+              "vm_status" => "RUNNING",
+              "vm_username" => "root",
+              "vm_vnc_password" => "8$EOs$Rs",
+              "vnc_port" => "18248"
+            }
+          },
+          "requestid" => "3affbe87-ad45-41de-a1d2-29b522aa88b2"
+        }
+      }
+    }
+    let(:expected_instance) {
+      {
+        "InstanceId" => "153979",
+        "cloned_from" => "",
+        "cu_id" => "17",
+        "disallow_deletion" => "N",
+        "rate_per_hr" => "0.0547",
+        "removed" => "N",
+        "reprovisioning_processed_date" => nil,
+        "resetpwd_processed_date" => nil,
+        "vm_bandwidth" => "600",
+        "vm_cpu_req" => "2",
+        "vm_created_date" => "1440018294",
+        "vm_description" => "apitestserver",
+        "vm_disk_req" => "100",
+        "vm_id" => "153979",
+        "vm_image" => "ubuntu-14.04_64bit",
+        "vm_image_display_name" => "ubuntu-14.04_64bit",
+        "vm_ip_address" => "45.58.35.251",
+        "vm_ip_gateway" => "45.58.34.1",
+        "vm_ip_subnet" => "255.255.254.0",
+        "vm_network_req" => "1",
+        "vm_os_architecture" => "64",
+        "vm_plan_name" => "L",
+        "vm_ram_req" => "4096",
+        "vm_removed_date" => nil,
+        "vm_status" => "RUNNING",
+        "vm_username" => "root",
+        "vm_vnc_password" => "8$EOs$Rs",
+        "vnc_port" => "18248"
+      }
+    }
+
+    it 'calls api_call with describe-instance and returns an instance hash' do
+      expect(subject).to receive(:api_call)
+        .with("describe-instance", {instanceid: instance_id})
+        .and_return(sample_api_response)
+      result = subject.describe_instance(instance_id)
+      expect(result).to eq expected_instance
+    end
+  end
+
+  describe "#terminate_instance" do
+    let(:instance_id) { "234" }
+    let(:sample_api_response) {
+      {
+        "Timestamp" => 1440175812,
+        "terminate-instanceresponse" => {
+          "instancesSet" => {
+            "item" => {
+              "InstanceId" => "154809",
+              "message" => "queued for termination",
+              "result" => "true"
+            }
+          },
+          "requestid" => "4dec8ab5-29e7-48f3-934e-e4bc3101de80"
+        }
+      }
+    }
+    let(:termination_response) {
+      {
+        "InstanceId" => "154809",
+        "message" => "queued for termination",
+        "result" => "true"
+      }
+    }
+
+    it 'calls api_call with terminate-instance and returns a termination response hash' do
+      expect(subject).to receive(:api_call)
+        .with("terminate-instance", {instanceid: instance_id})
+        .and_return(sample_api_response)
+      result = subject.terminate_instance(instance_id)
+      expect(result).to eq termination_response
+    end
+  end
+
+  describe "#run_instance" do
+    let(:sample_api_response) {
+      {
+        "Timestamp" => 1440018190,
+        "run-instanceresponse" => {
+          "instancesSet" => {
+            "item" => {
+              "instanceid" => "153979",
+              "ip_address" => "45.58.35.251",
+              "password" => "8q%Q6KaQ",
+              "username" => "root"
+            }
+          },
+          "requestid" => "6396399d-cb7d-446a-91c6-1334d0f939d8"
+        }
+      }
+    }
+    let(:run_response) {
+      {
+        "instanceid" => "153979",
+        "ip_address" => "45.58.35.251",
+        "password" => "8q%Q6KaQ",
+        "username" => "root"
+      }
+    }
+    
+
+    let(:server_name) {"apitestserver"}
+    let(:image_id) {"ubuntu-14.04_64bit"}
+    let(:plan_name) {"L"}
+    let(:vm_location) {"USEAST2"}
+
+    context "default parameters" do
+      it 'calls the api with the servername, imageid, planname and vm_location' do
+        expect(subject).to receive(:api_call)
+          .with("run-instance", {servername: server_name, imageid: image_id, planname: plan_name, vm_location: vm_location})
+          .and_return(sample_api_response)
+        result = subject.run_instance(server_name, plan_name, vm_location, {image_id: image_id})
+        expect(result).to eq run_response
+      end
+    end
+
+    context "use clone_image instead of image_id" do
+      let(:clone_image) {"17-145607"}
+
+      it 'calls the api with the servername, cloneimage, planname and vm_location' do
+        expect(subject).to receive(:api_call)
+          .with("run-instance", {servername: server_name, cloneimage: clone_image, planname: plan_name, vm_location: vm_location})
+          .and_return(sample_api_response)
+        result = subject.run_instance(server_name, plan_name, vm_location, {clone_image: clone_image})
+        expect(result).to eq run_response
+      end
+    end
+
+    context "no image id or clone image are provided" do
+      it 'raises an error when all the required arguments aren\'t specified' do 
+        expect{subject.run_instance(server_name, plan_name, vm_location)}
+        .to raise_error(ArgumentError)
+      end
+    end
+    
+    context "additional options" do
+      let(:enable_backup) { true }
+      let(:server_quantity) { 2 }
+      let(:key_id) { "yt9p4y64f7dem3e" }
+
+      it 'calls the api with the default arguments, plus enablebackup, serverqty and key_id' do
+        expect(subject).to receive(:api_call)
+          .with("run-instance", {
+            servername: server_name, imageid: image_id, planname: plan_name, vm_location: vm_location,
+            enablebackup: enable_backup, serverqty: server_quantity, key_id: key_id})
+          .and_return(sample_api_response)
+        result = subject.run_instance(server_name, plan_name, vm_location, {
+          image_id: image_id, enable_backup: enable_backup, server_quantity: server_quantity, key_id: key_id
+        })
+        expect(result).to eq run_response
+      end
+    end
+  end
+
+  describe "#describe_images" do
+    let(:sample_api_response) {
+      {
+        "Timestamp" => 1439933643,
+        "describe-imageresponse" => {
+          "imagesset" => {
+            "1item" => {
+              "architecture" => "x86_64",
+              "displayname" => "Ubuntu 14.04 LTS Server 64-Bit",
+              "image_type" => "os",
+              "imageid" => "ubuntu-14.04_64bit",
+              "ostype" => "linux",
+              "owner" => "atlantic",
+              "platform" => "linux",
+              "version" => "14.04 LTS"
+            }
+          },
+          "requestid" => "eb221f31-d023-452d-a7e9-9614fc575a9d"
+        }
+      }
+    }
+    let(:image_descriptions) {
+      [
+        {
+          "architecture" => "x86_64",
+          "displayname" => "Ubuntu 14.04 LTS Server 64-Bit",
+          "image_type" => "os",
+          "imageid" => "ubuntu-14.04_64bit",
+          "ostype" => "linux",
+          "owner" => "atlantic",
+          "platform" => "linux",
+          "version" => "14.04 LTS"
+        }
+      ]
+    }
+
+    context 'default options' do
+      it 'calls api_call with describe-image and returns a list of image hashes' do
+        expect(subject).to receive(:api_call)
+          .with("describe-image")
+          .and_return(sample_api_response)
+        result = subject.describe_images
+        expect(result).to eq image_descriptions
+      end
+    end
+
+    context 'optional imageid' do
+      let(:image_id) { "ubuntu-14.04_64bit" }
+      it 'calls api_call with describe-image and a image_id string and returns a list of image hashes' do
+        expect(subject).to receive(:api_call)
+          .with("describe-image", {imageid: image_id})
+          .and_return(sample_api_response)
+        result = subject.describe_images({image_id: image_id})
+        expect(result).to eq image_descriptions
+      end
+    end
+  end
+
+  describe "#describe_plans" do
+    let(:sample_api_response) {
+      {
+        "Timestamp" => 1439932362,
+        "describe-planresponse" => {
+          "plans" => {
+            "1item" => {
+              "bandwidth" => 600,
+              "centos_capable" => "Y",
+              "cpanel_capable" => "Y",
+              "disk" => "100",
+              "display_bandwidth" => "600Mbits",
+              "display_disk" => "100GB",
+              "display_ram" => "4GB",
+              "free_transfer" => "5",
+              "num_cpu" => "2",
+              "ostype" => "linux",
+              "plan_name" => "L",
+              "platform" => "linux",
+              "ram" => "4096",
+              "rate_per_hr" => 0.0547
+            }
+          },
+          "requestid" => "4aae48ae-af7b-4bbd-9309-58aadbfd02d3"
+        }
+      }
+    }
+    let(:plan_descriptions) {
+      [
+        {
+          "bandwidth" => 600,
+          "centos_capable" => "Y",
+          "cpanel_capable" => "Y",
+          "disk" => "100",
+          "display_bandwidth" => "600Mbits",
+          "display_disk" => "100GB",
+          "display_ram" => "4GB",
+          "free_transfer" => "5",
+          "num_cpu" => "2",
+          "ostype" => "linux",
+          "plan_name" => "L",
+          "platform" => "linux",
+          "ram" => "4096",
+          "rate_per_hr" => 0.0547
+        }
+      ]
+    }
+
+    context 'default options' do
+      it 'calls api_call with describe-plan and returns a list of plan hashes' do
+        expect(subject).to receive(:api_call)
+          .with("describe-plan")
+          .and_return(sample_api_response)
+        result = subject.describe_plans
+        expect(result).to eq plan_descriptions
+      end
+    end
+
+    context 'optional arguments' do
+      let(:plan_name) { "L" }
+      let(:platform) { "linux" }
+      it 'calls api_call with describe-plan plan_name and platform and returns a list of image hashes' do
+        expect(subject).to receive(:api_call)
+          .with("describe-plan", {plan_name: plan_name, platform: platform})
+          .and_return(sample_api_response)
+        result = subject.describe_plans({plan_name: plan_name, platform: platform})
+        expect(result).to eq plan_descriptions
+      end
+    end
+  end
+
+  describe "#list_ssh_keys" do
+    let(:sample_api_response) {
+      {
+        "Timestamp" => 1457105502,
+        "list-sshkeysresponse" => {
+          "KeysSet" => {
+            "item" => {
+              "key_id" => "yt9p4y64f7dem3e",
+              "key_name" => "My Public SSH Key",
+              "public_key" => "ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAsdfAn4sozeeBHWCv6B/tkTcUFz47fg48FgasdfasdfJNp4T5Fyq+3/6BA6fdZoI9skdudkfy3n6IUxHr5fwIUD0tn7QNsn5jp9rpjVRuXqoHUP3OYh6ZSlPBnsVmRNOI2ZWiBqMCIsWaeUkenVfnmvLZ/eMVwoKiDhakHs1dvaB8X4kEc7DnXKDZEyy0hAb+Eei8ppUqs9uMq+utXLEMCk0cPMTtqMialvk1pnz2lMuVPw1HGNRh2mjyGI7+6DoPCHaYurDQMXcyfF+05pSpBZCQAVJWvZFzivGfzUOAc4bgFBLznECQ== user@workstation-206"
+            }
+          },
+          "requestid" => "acea7888-a756-4ea1-b9db-6d2267673247"
+        }
+      }
+    }
+    let(:ssh_keys) {
+      [
+        {
+          "key_id" => "yt9p4y64f7dem3e",
+          "key_name" => "My Public SSH Key",
+          "public_key" => "ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAsdfAn4sozeeBHWCv6B/tkTcUFz47fg48FgasdfasdfJNp4T5Fyq+3/6BA6fdZoI9skdudkfy3n6IUxHr5fwIUD0tn7QNsn5jp9rpjVRuXqoHUP3OYh6ZSlPBnsVmRNOI2ZWiBqMCIsWaeUkenVfnmvLZ/eMVwoKiDhakHs1dvaB8X4kEc7DnXKDZEyy0hAb+Eei8ppUqs9uMq+utXLEMCk0cPMTtqMialvk1pnz2lMuVPw1HGNRh2mjyGI7+6DoPCHaYurDQMXcyfF+05pSpBZCQAVJWvZFzivGfzUOAc4bgFBLznECQ== user@workstation-206"
+        }
+      ]
+    }
+
+    it 'calls api_call with list-sshkeys and returns a list of ssh key hashes' do
+      expect(subject).to receive(:api_call)
+        .with("list-sshkeys")
+        .and_return(sample_api_response)
+      result = subject.list_ssh_keys
+      expect(result).to eq ssh_keys
+    end
+  end
+
+  describe '#api_call' do
+    it 'passes on the action' do
+      expect(transport).to receive(:send_request).with(a_hash_including(Action: 'some-action'))
+      subject.send(:api_call, 'some-action')
+    end
+
+    it 'includes a valid signature, public key, and timestamp' do
+      allow(subject).to receive(:generate_request_id_tuple).and_return([ sample_timestamp, sample_request_id] )
+
+      expect(transport).to receive(:send_request).with(a_hash_including(Signature: sample_signature, ACSAccessKeyId: access_key, Timestamp: sample_timestamp))
+      subject.send(:api_call, 'some-action')
+    end
+
+    it 'passes on any arguments' do
+      expect(transport).to receive(:send_request).with(a_hash_including(Value1: 'some-value-1', Value2: 'some-value-2'))
+      subject.send(:api_call, 'someother-action', {:Value1 => "some-value-1", :Value2 => "some-value-2"})
+    end
+
+    it 'raises an exception if there is an error' do
+      expect(transport).to receive(:send_request).and_return( JSON.parse('{"error":{"message": "Some error occurred"}}') )
+      expect{subject.send(:api_call, 'some-erroneous-action')}.to raise_error(AtlanticNetException)
+    end
+  end
+
+  describe '#generate_request_id' do
+    it 'Uses Time to return epoc timestamp' do
+      expect(Time).to receive(:now).and_return(double(:ts, to_i: 100))
+      expect(subject.send(:generate_request_id_tuple).first).to eq(100)
+    end
+
+    it 'Returns a valid uuid for the request_id' do
+      request_id = subject.send(:generate_request_id_tuple).last
+      expect{ UUIDTools::UUID.parse(request_id)}.not_to raise_error
+    end
+
+    it 'Returns different request_ids for subsequent calls' do
+      request_id1 = subject.send(:generate_request_id_tuple).last
+      request_id2 = subject.send(:generate_request_id_tuple).last
+      expect(request_id1).not_to eq (request_id2)
+    end
+  end
+end
+
+describe AtlanticNet::HttpTransport do
+  let(:transport) { AtlanticNet::HttpTransport.new }
+  let(:sample_data) { {"arg1" => "value1", "arg2" => "value2"} }
+  let(:sample_response) { {"result1" => "response_value_1", "result2" => "response_value_2" }}
+
+  describe "#send_request" do
+    it "Passes the arguments and parses the response" do
+      stub_request(:get, "https://cloudapi.atlantic.net").with(query: sample_data).to_return(body: sample_response.to_json)
+      result = transport.send_request(sample_data)
+      expect(result).to eq sample_response
+    end
+
+    it "raises an exception when request is unsuccessful" do
+      stub_request(:get, "https://cloudapi.atlantic.net").to_return(status: 404)
+      expect{transport.send_request({})}.to raise_error(AtlanticNetException)
+    end
+  end
+end
+
+describe AtlanticNetException do
+  let(:atlantic_net_instance) { double }
+  let(:api_response) { double }
+  let(:message) { "an error message" }
+
+  it 'Has the message, instance and api_response accessible' do
+    atlantic_net_exception = AtlanticNetException.new(atlantic_net_instance, api_response, message)
+    expect(atlantic_net_exception.atlantic_net_instance).to eq atlantic_net_instance
+    expect(atlantic_net_exception.api_response).to eq api_response
+    expect(atlantic_net_exception.message).to eq message
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require "simplecov"
+require "coveralls"
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start { add_filter "/spec/" }
+
+require "atlantic_net"
+require "uuidtools"
+require "webmock/rspec"

metadata

@@ -0,0 +1,210 @@
+--- !ruby/object:Gem::Specification
+name: atlantic_net
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Jamie Starke
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec-given
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: uuidtools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Ruby wrapper of the Atlantic.net API
+email:
+- git@jamiestarke.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- atlantic_net.gemspec
+- lib/atlantic_net.rb
+- spec/atlantic_net_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/jrstarke/atlantic_net
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: A Ruby wrapper of the Atlantic.net API
+test_files:
+- spec/atlantic_net_spec.rb
+- spec/spec_helper.rb