esgob 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f029cb699d12ea2f9ebc3d62538b301ac22c4ce2
-  data.tar.gz: 878e694007c2d41a71ed940fc5f7cf9215a4ad23
+  metadata.gz: 3f360864b7199c78e7842d5792c7557cbbead80e
+  data.tar.gz: ff27595eaf87037c471f87193e9cf4e71075dc94
 SHA512:
-  metadata.gz: 48559b9d9ac0b9a5def0e60cd6ed4242d90e28a2ec617d71fb673c0fedadd4e6aee7a32a81c6db88d649d539a59df04ab8e83e8317c5bfe65f442a13929159f5
-  data.tar.gz: 5ff773471a48fc33e975ae314aec3519f9d7422b8526301bebf66f5328955f886bf9c9a8d0fb03838766d2321df230988108810aca80091a00a9d17079945202
+  metadata.gz: a731e04c8c2d50199ad8222f36773ecb5c223455a4dc0c039c5bd50a41ba709a6cae4c744d663430447cee26c5d09257c5e56a3ac1d8cb4b01784593b165af06
+  data.tar.gz: 6203a00e25e0b844c92814de5f093e569ac6bd2fb0f21cd2c75fe3bf7132729c96c4674dd22623b8efe37e5c6813ae039c088808fe533b971433cda05927e43b

data/README.md

@@ -5,12 +5,17 @@ Esgob Ruby Client
 
 [Esgob Ltd] operate an [international network] of anycast servers.
 Their [Secondary DNS] service is available for free.
-This Ruby Gem provides convenient access to the [Esgob API].
+This Ruby Gem provides convenient access to the [Esgob API] via a command line tool
+and Ruby library.
 
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Install it as a gem using:
+
+    $ gem install esgob
+
+Or add this line to your application's Gemfile:
 
 ```ruby
 gem 'esgob'
@@ -20,20 +25,66 @@ And then execute:
 
     $ bundle
 
-Or install it yourself as:
 
-    $ gem install esgob
+## Command Line Usage
+
+Without any arguments, the ```esgob``` tool will display a list of commands:
+
+```
+Commands:
+  esgob account                        # Display account info
+  esgob config                         # Save the Esgob account and key
+  esgob domains                        # List all domains
+  esgob help [COMMAND]                 # Describe available commands or one specific command
+  esgob slaves                         # List slave domains
+  esgob slaves-add DOMAIN MASTERIP     # Add new slave domain
+  esgob slaves-delete DOMAIN           # Delete a slave domain
+  esgob slaves-sync FILE MASTERIP      # Synronises list of slave domains in a file
+  esgob slaves-transfer DOMAIN         # Force transfer from master of a slave domain
+  esgob slaves-update DOMAIN MASTERIP  # Updates the master IP of a slave domain
+  esgob soacheck DOMAIN                # Fetch domain SOA serial number for all nodes
+  esgob version                        # Show Esgob Ruby Client version
+
+Options:
+  -a, [--account=Account Name]     
+  -k, [--key=API Key]              
+  -v, [--verbose], [--no-verbose]  
+```
+
+To configure the client with some credentials use the ```esgob config``` command:
 
-## Usage
+```
+$ esgob config
+What is your Esgob account name? accountname
+What is your Esgob key? 4472ed80e0f511e4aee13c0754043581
+Configuration written to /home/username/.esgob
+```
+
+
+
+## Library Usage
 
 First create a new client instance, by passing in your account name and API key:
 
     esgob = Esgob::Client.new('account', 'key')
 
-Alternatively, as it is often desirable to keep secrets outside of the source code, it is also possible to pass in the account name and API key using environment variables set in the shell:
+Alternatively, as it is often desirable to keep secrets outside of the source code,
+it is also possible to pass in the account name and API key using a configuration file.
+The following paths are searched in the following order:
+
+    ~/.esgob
+    /usr/local/etc/esgob.conf
+    /etc/esgob.conf
+
+The configuration file should be in the format:
+
+    account some_account_name
+    key kskjhdkjdhkjhdkjdhdkjhdkjhd
+
+Or set using environment variables:
 
     export ESGOB_ACCOUNT=accountname
-    export ESGOB_API_KEY=4472ed80e0f511e4aee13c0754043581
+    export ESGOB_KEY=4472ed80e0f511e4aee13c0754043581
 
 The client instance can then be initialised without passing any arguments:
 

data/lib/esgob.rb

@@ -1,9 +1,12 @@
 module Esgob
   autoload :Client,   'esgob/client'
+  autoload :Config,   'esgob/config'
   autoload :CLI,      'esgob/cli'
   autoload :VERSION,  'esgob/version'
 
+  # Exception raised when the Esgob API returns an error
   class ServerError < StandardError
+    # Get the error code number returned by Esgob
     attr_reader :code
 
     def initialize(message, code = nil)
@@ -11,4 +14,7 @@ module Esgob
       @code = code
     end
   end
+
+  # Exception raised if client is configured
+  class UnconfiguredError < StandardError; end
 end

data/lib/esgob/cli.rb

@@ -22,16 +22,28 @@ class Esgob::CLI < Thor
       super(args, config)
     rescue Esgob::ServerError => err
       $stderr.puts config[:shell].set_color("=> Error: #{err.message} [#{err.code}]", :red, :bold)
+    rescue Esgob::UnconfiguredError => err
+      $stderr.puts config[:shell].set_color("=> Error: #{err.message}", :red, :bold)
+      $stderr.puts "Use the 'esgob config' command to create a configuration file."
     end
   end
 
+  desc "config", "Save the Esgob account and key"
+  def config
+    config = Esgob::Config.new
+    config.account = ask("What is your Esgob account name?")
+    config.key = ask("What is your Esgob key?")
+    config.save
+    say "Configuration written to #{config.filepath}"
+  end
+
   desc "account", "Display account info"
   def account
     client.accounts_get.each_pair do |k, v|
       say sprintf("%8s: %s\n", k, v)
     end
   end
-  
+
   desc "domains", "List all domains"
   def domains
     print_table(
@@ -118,7 +130,11 @@ class Esgob::CLI < Thor
   private ######################################################################
 
   def client
-    @client ||= Esgob::Client.new(options[:account], options[:key])
+    @client ||= if options[:account] and options[:key]
+      Esgob::Client.new(options[:account], options[:key])
+    else
+      Esgob::Client.new
+    end
   end
 
   def check_action
@@ -130,5 +146,5 @@ class Esgob::CLI < Thor
       end
     end
   end
-  
+
 end

data/lib/esgob/client.rb

@@ -3,36 +3,64 @@ require "uri"
 require "json"
 
 class Esgob::Client
-  attr_accessor :endpoint
-  attr_accessor :account
-  attr_accessor :api_key
-
-  DEFAULT_API_ENDPOINT = "https://api.esgob.com/1.0/".freeze
+  # Esgob configuration, used to store account name and key
+  # @return [Esgob::Config]
+  attr_reader :config
 
+  # Create a new Esgob Client instance.
+  #
+  # @overload initialize
+  #   Create a new client, using one of the default configuration files.
+  #   Or the ESGOB_ACCOUNT and ESGOB_KEY environment variables.
+  # @overload initialize(account, key)
+  #   @param [String] account
+  #   @param [String] key
+  # @overload initialize(args)
+  #   @param [Hash] options
+  #   @option options [String] :endpoint The URI of the API endpoint
+  #   @option options [String] :account The account name
+  #   @option options [String] :key The API key
+  # @overload initialize(config)
+  #   @param [Esgob::Config] config
+  # @return [Esgob::Client] A new client instance.
+  # @example
+  #   client = Esgob::Client.new('account', 'key')
   def initialize(*args)
-    if args.first.is_a?(Hash)
-      args.first.each_pair { |k, v| send("#{k}=", v) }
+    if args.empty?
+      # Load configuration from file if no arguments were given
+      @config = Esgob::Config.load
+    elsif args.first.is_a?(Esgob::Config)
+      @config = args.first
+    elsif args.first.is_a?(Hash)
+      @config = Esgob::Config.new(args.first)
+    elsif args.length == 2
+      @config = Esgob::Config.new(:account => args[0], :key => args[1])
     else
-      self.account = args[0]
-      self.api_key = args[1]
+      raise(ArgumentError, "Unsupported arguments for creating Esgob::Client")
     end
 
-    self.account ||= ENV['ESGOB_ACCOUNT']
-    self.api_key ||= ENV['ESGOB_API_KEY']
-    self.endpoint ||= DEFAULT_API_ENDPOINT
+    if config.nil?
+      raise(Esgob::UnconfiguredError, "Unable to load Esgob configuration")
+    end
 
-    if account.nil? or account.empty?
+    if config.account.nil? or config.account.empty?
       raise(ArgumentError, "No account name configured for Esgob")
     end
 
-    if api_key.nil? or api_key.empty?
+    if config.key.nil? or config.key.empty?
       raise(ArgumentError, "No API key configured for Esgob")
     end
   end
 
-  def call(function_name, arguments = {})
-    uri = URI(endpoint + function_name)
-    uri.query = build_query(default_arguments.merge(arguments))
+  # Call a named Esgob API function.
+  #
+  # @param [String] function_name The name of API function.
+  # @param [Hash] args Pairs of argument keys and values.
+  # @return [Hash] The response from the Esgob service, with symbols as keys.
+  # @example client.call('domains.slaves.add', :domain => 'example.com', :masterip => '192.168.0.1')
+  def call(function_name, args = {})
+    uri = URI(config.endpoint + function_name)
+    uri.query = build_query(default_arguments.merge(args))
 
     res = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
       req = Net::HTTP::Get.new(uri.request_uri)
@@ -57,7 +85,8 @@ class Esgob::Client
     end
   end
 
-  # Return account status; credit balance, etc
+  # Return account status; credit balance, etc.
+  # @return [Hash] Key, value pairs, containing account information.
   def accounts_get
     account = call('accounts.get')
     account[:added] = Time.at(account[:added]) if account[:added].is_a?(Fixnum)
@@ -65,12 +94,13 @@ class Esgob::Client
   end
 
   # Returns all hosted domains
+  # @return [Array<Hash>] Array of hashes, one per domain.
   def domains_list
     call('domains.list')[:domains]
   end
 
   # Returns all hosted slave domains as a hash
-  #
+  # @return [Hash] Domain name as key, master ip as value
   def domains_slaves_list
     Hash[
       call('domains.slaves.list')[:domains].map do |item|
@@ -79,14 +109,19 @@ class Esgob::Client
     ]
   end
 
-  # Adds a new slave domain
+  # Adds a new slave domain.
+  # @param [String] domain The name of the domain to add
+  # @param [String] masterip The IP of the master to transfer the zone from.
+  # @return [Hash] The response from the Esgob service, with symbols as keys.
   def domains_slaves_add(domain, masterip)
     result = call('domains.slaves.add', :domain => domain, :masterip => masterip)
     result[:domain] ||= domain
     result
   end
 
-  # Deletes a slave domain
+  # Deletes a slave domain.
+  # @param [String] domain The name of the domain to delete.
+  # @return [Hash] The response from the Esgob service, with symbols as keys.
   def domains_slaves_delete(domain)
     result = call('domains.slaves.delete', :domain => domain)
     result[:domain] ||= domain
@@ -94,6 +129,8 @@ class Esgob::Client
   end
 
   # Force AXFR / transfer from master of a slave domain
+  # @param [String] domain The name of the domain to transfer.
+  # @return [Hash] The response from the Esgob service, with symbols as keys.
   def domains_slaves_forcetransfer(domain)
     result = call('domains.slaves.forcetransfer', :domain => domain)
     result[:domain] ||= domain
@@ -101,6 +138,9 @@ class Esgob::Client
   end
 
   # Updates the master IP of a slave domain
+  # @param [String] domain The name of the domain to update
+  # @param [String] masterip The new IP of the master to transfer the zone from.
+  # @return [Hash] The response from the Esgob service, with symbols as keys.
   def domains_slaves_updatemasterip(domain, masterip)
     result = call('domains.slaves.updatemasterip', :domain => domain, :masterip => masterip)
     result[:domain] ||= domain
@@ -108,6 +148,9 @@ class Esgob::Client
   end
 
   # Add a host allowed to AXFR out
+  # @param [String] domain The name of the domain to update
+  # @param [String] axfrip The new IP of the host to allow transfers to.
+  # @return [Hash] The response from the Esgob service, with symbols as keys.
   def domains_slaves_axfrout_add(domain, axfrip)
     result = call('domains.slaves.axfrout.add', :domain => domain, :axfrip => axfrip)
     result[:domain] ||= domain
@@ -115,6 +158,9 @@ class Esgob::Client
   end
 
   # Account	Delete a host allowed to AXFR out
+  # @param [String] domain The name of the domain to update
+  # @param [String] axfrip The IP of the host to stop allowing transfers to.
+  # @return [Hash] The response from the Esgob service, with symbols as keys.
   def domains_slaves_axfrout_delete(domain, axfrip)
     result = call('domains.slaves.axfrout.delete', :domain => domain, :axfrip => axfrip)
     result[:domain] ||= domain
@@ -122,12 +168,17 @@ class Esgob::Client
   end
 
   # Retrieve the domain SOA serial number from the master and each anycast node
+  # @param [String] domain The name of the domain to look up
+  # @return [Hash] The response from the Esgob service, with symbols as keys.
   def domains_tools_soacheck(domain)
     call('domains.tools.soacheck', :domain => domain)
   end
 
   # Given a list of domains and a master IP, add and delete domains
   # so that the Esgob account matches the local list
+  # @param [Array<String>] domains The an array of domains to add to Esgob
+  # @param [String] masterip The master IP address to use for all the domains
+  # @return [Array<Hash>] A list of responses from the Esgob service
   def domains_slaves_sync(domains, masterip)
     existing_domains = domains_slaves_list
 
@@ -161,8 +212,9 @@ class Esgob::Client
     responses
   end
 
+  # @return [String]
   def inspect
-    "\#<#{self.class} account=#{@account}>"
+    "\#<#{self.class} account=#{config.account}>"
   end
 
   protected
@@ -183,8 +235,8 @@ class Esgob::Client
 
   def default_arguments
     {
-      :account => account,
-      :key => api_key,
+      :account => config.account,
+      :key => config.key,
       :f => 'json'
     }
   end

data/lib/esgob/config.rb

@@ -0,0 +1,104 @@
+class Esgob::Config
+  # Path to the configuration file
+  # @return [String]
+  attr_accessor :filepath
+  # @return [String]
+  attr_accessor :endpoint
+  # @return [String]
+  attr_accessor :account
+  # @return [String]
+  attr_accessor :key
+
+  DEFAULT_API_ENDPOINT = "https://api.esgob.com/1.0/".freeze
+
+  # @param [Hash] args
+  # @option args [String] :account The account name
+  # @option args [String] :key The API key
+  def initialize(args={})
+    args.each_pair { |k, v| send("#{k}=", v) }
+  end
+
+  def endpoint
+    # Use default endpoint if none configured
+    @endpoint || DEFAULT_API_ENDPOINT
+  end
+
+  # Get an ordered list of paths to possible Esgob configuration files
+  # @return [Array<String>] Array of file paths
+  def self.default_filepaths
+    [
+      File.join(ENV['HOME'], '.esgob'),
+      '/usr/local/etc/esgob.conf',
+      '/etc/esgob.conf'
+    ]
+  end
+
+  # Try and read Esgob configuration either from
+  # Environment variables or one of the config files
+  # @param [String] path Optional path to a configuration file
+  # @return Esgob::Config
+  def self.load(path=nil)
+    if !path.nil?
+      load_file(path)
+    elsif ENV['ESGOB_ACCOUNT'] and ENV['ESGOB_KEY']
+      self.new(
+        :account => ENV['ESGOB_ACCOUNT'],
+        :key => ENV['ESGOB_KEY']
+      )
+    else
+      default_filepaths.each do |path|
+        if File.exist?(path)
+          return load_file(path)
+        end
+      end
+
+      # No config file found, return nil
+      nil
+    end
+  end
+
+  # Save Esgob configuration to file
+  # If no filepath is given, save to the default filepath
+  # @param [String] path Optional path to a configuration file
+  def save(path=nil)
+    if !path.nil?
+      self.filepath = path
+    elsif filepath.nil?
+      self.filepath = self.class.default_filepaths.first
+    end
+
+    File.open(filepath, 'wb') do |file|
+      each_pair do |key,value|
+        file.puts "#{key} #{value}"
+      end
+    end
+  end
+
+  # Calls block once for each configuration key value pair,
+  # passing the key and value as parameters.
+  def each_pair
+    instance_variables.sort.each do |var|
+      next if var.to_s == '@filepath'
+      yield(var.to_s.sub(/^@/,''), instance_variable_get(var))
+    end
+  end
+
+
+  protected
+
+  def self.load_file(path)
+    config = self.new(:filepath => path)
+
+    File.foreach(path) do |line|
+      if line =~ /^(\w+)\s+(.+)$/
+        method, value = ["#{$1}=", $2]
+        if config.respond_to?(method)
+          config.send(method, value)
+        end
+      end
+    end
+
+    config
+  end
+
+end

data/lib/esgob/version.rb

@@ -1,3 +1,3 @@
 module Esgob
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/test/esgob_cli_test.rb

@@ -1,6 +1,7 @@
 $:.unshift(File.dirname(__FILE__))
 
 require 'test_helper'
+require 'thor'
 require 'esgob'
 
 class TestCLI < MiniTest::Unit::TestCase
@@ -8,16 +9,29 @@ class TestCLI < MiniTest::Unit::TestCase
     # Run before each test
     FakeWeb.clean_registry
 
-    @client = Esgob::Client.new('acct', 'xxxx')
-    Esgob::Client.stubs(:new).returns(@client)
-
     ENV['THOR_SHELL'] = 'Basic'
+    ENV['ESGOB_ACCOUNT'] = 'acct'
+    ENV['ESGOB_KEY'] = 'xxxx'
   end
 
   def teardown
     # Reset environment variables after each test
     ENV.delete('ESGOB_ACCOUNT')
-    ENV.delete('ESGOB_API_KEY')
+    ENV.delete('ESGOB_KEY')
+  end
+
+  def test_config
+    shell = Thor::Base.shell.new
+    shell.expects(:ask).with("What is your Esgob account name?").returns('ask_acct')
+    shell.expects(:ask).with("What is your Esgob key?").returns('ask_key')
+
+    config = Esgob::Config.new
+    Esgob::Config.expects(:new).with().returns(config)
+    config.filepath = '/etc/esgob.conf'
+    config.expects(:save)
+
+    output = capture(:stdout) { Esgob::CLI.start(%w(config), :shell => shell) }
+    assert_equal "Configuration written to /etc/esgob.conf\n", output
   end
 
   def test_account
@@ -29,6 +43,14 @@ class TestCLI < MiniTest::Unit::TestCase
     assert_match " credits: 48\n", output
   end
 
+  def test_account_unconfigured
+    Esgob::Config.expects(:load).with().returns(nil)
+
+    output = capture(:stderr) { Esgob::CLI.start(%w(account)) }
+    assert_match "=> Error: Unable to load Esgob configuration\n", output
+    assert_match "Use the 'esgob config' command to create a configuration file.\n", output
+  end
+
   def test_account_error
     FakeWeb.register_uri(
       :get, %r{^https?://api\.esgob\.com(:443)?/},
@@ -102,9 +124,11 @@ class TestCLI < MiniTest::Unit::TestCase
   end
 
   def test_slaves_sync
-    @client.expects(:domains_slaves_list).with().returns('a.com' => '195.177.253.169', 'b.com' => '195.177.253.169')
-    @client.expects(:domains_slaves_delete).with('a.com').returns(:action => 'domain deleted')
-    @client.expects(:domains_slaves_add).with('c.com', '195.177.253.169').returns(:action => 'domain added')
+    client = Esgob::Client.new
+    client.expects(:domains_slaves_list).with().returns('a.com' => '195.177.253.169', 'b.com' => '195.177.253.169')
+    client.expects(:domains_slaves_delete).with('a.com').returns(:action => 'domain deleted')
+    client.expects(:domains_slaves_add).with('c.com', '195.177.253.169').returns(:action => 'domain added')
+    Esgob::Client.stubs(:new).returns(client)
 
     output = capture(:stdout) { Esgob::CLI.start(['slaves-sync', fixture_path('sync-domain-list.txt'), '195.177.253.169']) }
     assert_match "a.com => domain deleted\n", output

data/test/esgob_client_test.rb

@@ -5,7 +5,9 @@ require 'esgob'
 
 class TestClient < MiniTest::Unit::TestCase
   def setup
-    # Run before each test
+    # Clear environment variables before each test
+    ENV.delete('ESGOB_ACCOUNT')
+    ENV.delete('ESGOB_KEY')
     FakeWeb.clean_registry
     @client = Esgob::Client.new('acct', 'xxxx')
   end
@@ -13,49 +15,74 @@ class TestClient < MiniTest::Unit::TestCase
   def teardown
     # Reset environment variables after each test
     ENV.delete('ESGOB_ACCOUNT')
-    ENV.delete('ESGOB_API_KEY')
+    ENV.delete('ESGOB_KEY')
   end
 
   def test_new_client_using_environment
     ENV['ESGOB_ACCOUNT'] = 'envacct'
-    ENV['ESGOB_API_KEY'] = 'envkey'
+    ENV['ESGOB_KEY'] = 'envkey'
 
     client = Esgob::Client.new
-    assert_equal 'envacct', client.account
-    assert_equal 'envkey', client.api_key
-    assert_equal 'https://api.esgob.com/1.0/', client.endpoint
+    assert_equal 'envacct', client.config.account
+    assert_equal 'envkey', client.config.key
+    assert_equal 'https://api.esgob.com/1.0/', client.config.endpoint
   end
 
   def test_new_client_using_arguments
     client = Esgob::Client.new('foobar', 'mykey')
-    assert_equal 'foobar', client.account
-    assert_equal 'mykey', client.api_key
-    assert_equal 'https://api.esgob.com/1.0/', client.endpoint
+    assert_equal 'foobar', client.config.account
+    assert_equal 'mykey', client.config.key
+    assert_equal 'https://api.esgob.com/1.0/', client.config.endpoint
   end
 
   def test_new_client_using_hash
     client = Esgob::Client.new(
       :account => 'hashacct',
-      :api_key => 'hashkey',
+      :key => 'hashkey',
       :endpoint => 'http://api.example.com/'
     )
-    assert_equal 'hashacct', client.account
-    assert_equal 'hashkey', client.api_key
-    assert_equal 'http://api.example.com/', client.endpoint
+    assert_equal 'hashacct', client.config.account
+    assert_equal 'hashkey', client.config.key
+    assert_equal 'http://api.example.com/', client.config.endpoint
+  end
+
+  def test_new_client_using_config
+    config = Esgob::Config.new(
+      :account => 'confacct',
+      :key => 'confkey'
+    )
+    client = Esgob::Client.new(config)
+    assert_equal 'confacct', client.config.account
+    assert_equal 'confkey', client.config.key
+  end
+
+  def test_new_client_with_no_config_files
+    Esgob::Config.expects(:default_filepaths).with().returns([])
+    err = assert_raises(Esgob::UnconfiguredError) { Esgob::Client.new }
+    assert_equal 'Unable to load Esgob configuration', err.message
   end
 
   def test_new_client_with_no_account
     ENV.delete('ESGOB_ACCOUNT')
-    assert_raises(ArgumentError) do
+    err = assert_raises(ArgumentError) do
       Esgob::Client.new(nil, 'mykey')
     end
+    assert_equal 'No account name configured for Esgob', err.message
   end
 
-  def test_new_client_with_no_api_key
-    ENV.delete('ESGOB_API_KEY')
-    assert_raises(ArgumentError) do
+  def test_new_client_with_no_key
+    ENV.delete('ESGOB_KEY')
+    err = assert_raises(ArgumentError) do
       Esgob::Client.new('acct', nil)
     end
+    assert_equal 'No API key configured for Esgob', err.message
+  end
+
+  def test_new_client_unsupported_arguments
+    err = assert_raises(ArgumentError) do
+      Esgob::Client.new(1, 2, 3, 4)
+    end
+    assert_equal 'Unsupported arguments for creating Esgob::Client', err.message
   end
 
   def test_call_with_no_parameters
@@ -145,7 +172,7 @@ class TestClient < MiniTest::Unit::TestCase
       {
         :credits => 48,
         :users => [],
-        :added => Time.parse('2015-02-01 12:07:14 +0000'),
+        :added => Time.utc(2015, 2, 1, 12, 07, 14),
         :id => 'xyz',
         :name => 'Person Name'
       },

data/test/esgob_config_test.rb

@@ -0,0 +1,151 @@
+$:.unshift(File.dirname(__FILE__))
+
+require 'test_helper'
+require 'tempfile'
+require 'esgob'
+
+class TestConfig < MiniTest::Unit::TestCase
+  def setup
+    # Clear environment variables before each test
+    ENV.delete('ESGOB_ACCOUNT')
+    ENV.delete('ESGOB_KEY')
+  end
+
+  def teardown
+    # Reset environment variables after each test
+    ENV.delete('ESGOB_ACCOUNT')
+    ENV.delete('ESGOB_KEY')
+  end
+
+  def test_new
+    conf = Esgob::Config.new(:account => 'acct', :key => 'xyz')
+    assert_instance_of(Esgob::Config, conf)
+    assert_equal('acct', conf.account)
+    assert_equal('xyz', conf.key)
+  end
+
+  def test_default_values
+    conf = Esgob::Config.new
+    assert_instance_of(Esgob::Config, conf)
+    assert_equal(nil, conf.account)
+    assert_equal('https://api.esgob.com/1.0/', conf.endpoint)
+    assert_equal(nil, conf.key)
+  end
+
+  def test_default_filepaths
+    ENV['HOME'] = '/home/bob'
+    assert_instance_of(Array, Esgob::Config.default_filepaths)
+    assert_includes(Esgob::Config.default_filepaths, '/home/bob/.esgob')
+    assert_includes(Esgob::Config.default_filepaths, '/etc/esgob.conf')
+  end
+
+  def test_load_from_env
+    ENV['ESGOB_ACCOUNT'] = 'envacct'
+    ENV['ESGOB_KEY'] = 'envkey'
+    conf = Esgob::Config.load
+    assert_instance_of(Esgob::Config, conf)
+    assert_equal('envacct', conf.account)
+    assert_equal('envkey', conf.key)
+    assert_equal(nil, conf.filepath)
+  end
+
+  def test_load_from_specific_file
+    conf = Esgob::Config.load(fixture_path('config.txt'))
+    assert_instance_of(Esgob::Config, conf)
+    assert_equal('fileacct', conf.account)
+    assert_equal('filekey', conf.key)
+    assert_match(/test\/fixtures\/config\.txt$/, conf.filepath)
+  end
+
+  def test_load_from_default_files
+    Esgob::Config.expects(:default_filepaths).with().returns([
+      '/doesnt/exist/shuuKee6',
+      '/doesnt/exist/ebah4kiH',
+      fixture_path('config.txt'),
+      '/doesnt/exist/Va5cu9en',
+    ])
+
+    conf = Esgob::Config.load
+    assert_instance_of(Esgob::Config, conf)
+    assert_equal('fileacct', conf.account)
+    assert_equal('filekey', conf.key)
+    assert_match(/test\/fixtures\/config\.txt$/, conf.filepath)
+  end
+
+  def test_load_unavailable
+    Esgob::Config.expects(:default_filepaths).with().returns([
+      '/doesnt/exist/shuuKee6'
+    ])
+
+    conf = Esgob::Config.load
+    assert_nil(conf)
+  end
+
+  def test_each_pair
+    conf = Esgob::Config.new(:key => 'xyz', :account => 'abc')
+    array = []
+    conf.each_pair { |k, v| array << "#{k}=#{v}" }
+    assert_equal(["account=abc", "key=xyz"], array)
+  end
+
+  def test_save_config_to_default
+    tempfile = Tempfile.new('esgob-config-test')
+    tempfile.close
+
+    Esgob::Config.expects(:default_filepaths).with().returns([tempfile.path])
+
+    config = Esgob::Config.new
+    config.account = 'a'
+    config.key = 'k'
+    config.save
+
+    assert_equal(
+      "account a\n"+
+      "key k\n",
+      tempfile.open.read
+    )
+
+    assert_equal(tempfile.path, config.filepath)
+
+    tempfile.unlink
+  end
+
+  def test_save_config_with_path
+    tempfile = Tempfile.new('esgob-config-test')
+    tempfile.close
+
+    config = Esgob::Config.new
+    config.account = 'a'
+    config.key = 'k'
+    config.save(tempfile.path)
+
+    assert_equal(
+      "account a\n"+
+      "key k\n",
+      tempfile.open.read
+    )
+
+    tempfile.unlink
+  end
+
+  def test_save_config_with_custom_endpoint
+    tempfile = Tempfile.new('esgob-config-test')
+    tempfile.close
+
+    config = Esgob::Config.new
+    config.account = 'a'
+    config.key = 'k'
+    config.endpoint = 'http://esgob.example.com/'
+    config.save(tempfile.path)
+
+    assert_equal(
+      "account a\n"+
+      "endpoint http://esgob.example.com/\n"+
+      "key k\n",
+      tempfile.open.read
+    )
+
+    tempfile.unlink
+  end
+
+end

data/test/fixtures/config.txt

@@ -0,0 +1,5 @@
+# Comments allowed 
+account fileacct
+
+key filekey
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: esgob
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Nicholas Humfrey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-03 00:00:00.000000000 Z
+date: 2015-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -141,13 +141,16 @@ files:
 - lib/esgob.rb
 - lib/esgob/cli.rb
 - lib/esgob/client.rb
+- lib/esgob/config.rb
 - lib/esgob/version.rb
 - test/esgob_cli_test.rb
 - test/esgob_client_test.rb
+- test/esgob_config_test.rb
 - test/esgob_version_test.rb
 - test/fixtures/accounts_get.json
 - test/fixtures/code_1003.json
 - test/fixtures/code_2007.json
+- test/fixtures/config.txt
 - test/fixtures/domains_list.json
 - test/fixtures/domains_slaves_add.json
 - test/fixtures/domains_slaves_axfrout_add.json
@@ -186,10 +189,12 @@ summary: Client library for talking to the Esgob anycast DNS API.
 test_files:
 - test/esgob_cli_test.rb
 - test/esgob_client_test.rb
+- test/esgob_config_test.rb
 - test/esgob_version_test.rb
 - test/fixtures/accounts_get.json
 - test/fixtures/code_1003.json
 - test/fixtures/code_2007.json
+- test/fixtures/config.txt
 - test/fixtures/domains_list.json
 - test/fixtures/domains_slaves_add.json
 - test/fixtures/domains_slaves_axfrout_add.json