shanesveller-webbynode-api 0.1.0 → 0.1.2

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.2

data/lib/webbynode-api/data.rb

@@ -67,90 +67,4 @@ class WebbyNode
       @data = auth_get("/api/xml/webbies")["hash"]["webbies"]
     end
   end
-
-  # Represents the DNS zones present on the API account
-  #
-  # @author Shane Sveller
-  # @since 0.0.2
-  # @version 0.1.0
-  class DNS < WebbyNode::APIObject
-    # Holds the ID used internally at WebbyNode that represents a given zone.
-    attr_accessor :id
-
-    # Fetches either a single zone or an Array of all zones based on the presence
-    # of the id parameter.
-    #
-    # @option options [String] :email E-mail address used for API access
-    # @option options [String] :token API token used for API access
-    # @option options [Integer] :id ID that represents an individual zone
-    # @raise [ArgumentError] Raises ArgumentError if the :id option is missing
-    #   from the optins parameter.
-    def initialize(options = {})
-      raise ArgumentError, ":id is a required argument" unless options[:id]
-      super(options)
-      @id = options[:id]
-      @data = auth_get("/api/xml/dns/#{@id}")["hash"]["zone"]
-    end
-
-    # @since 0.0.3
-    # @return [Array<Hash>] Array of a zones' records, each individually is a Hash.
-    def records
-      raise "This method should only be called on DNS instances with an id" unless @id
-      auth_get("/api/xml/dns/#{@id}/records")["hash"]["records"]
-    end
-
-    # @since 0.0.6
-    # @option options [String] :email E-mail address used for API access
-    # @option options [String] :token API token used for API access
-    # @option options [optional, String] :status Optional argument to set the
-    #   status of the zone. Valid values include 'Active' or 'Inactive' only.
-    # @return [Hash] Hash of the new zone's information
-    # @raise [ArgumentError] Raises ArgumentError if :token, :email, :domain,
-    #   or :ttl are missing from the options parameter.
-    def self.new_zone(options = {})
-      raise ArgumentError, "API access information via :email and :token are required arguments" unless options[:email] && options[:token]
-      raise ArgumentError, ":domain and :ttl are required arguments" unless options[:domain] && options[:ttl]
-      if options[:status]
-        raise ArgumentError, ":status must be 'Active' or 'Inactive'" unless %w(Active Inactive).include? options[:status]
-      end
-      zone_data = auth_post("/api/xml/dns/new", :query =>
-        {
-          :email => options[:email],
-          :token => options[:token],
-          "zone[domain]" => options[:domain],
-          "zone[ttl]" => options[:ttl],
-          "zone[status]" => options[:status]
-        })
-      return zone_data["hash"]
-    end
-
-    # @since 0.0.6
-    # @option options [String] :email E-mail address used for API access
-    # @option options [String] :token API token used for API access
-    # @option options [Integer] :id WebbyNode's internally-used ID that idenftifies the zone
-    # @return [Boolean] Returns true upon succesful deletion of the zone.
-    # @raise [ArgumentError] Raises ArgumentError if :token, :email, or :id are
-    # missing from the options parameter.
-    def self.delete_zone(options = {})
-      raise ArgumentError, "API access information via :email and :token are required arguments" unless options[:email] && options[:token]
-      raise ArgumentError, ":id is a required argument" unless options[:id]
-      return auth_post("/api/xml/dns/#{options[:id]}/delete", :query => options)["hash"]["success"]
-    end
-  end
-
-  # Represents an Array of all DNS zones present on the API account
-  #
-  # @author Shane Sveller
-  # @since 0.1.0
-  # @version 0.1.0
-  class DNSList < WebbyNode::APIObject
-    # Fetches an Array of all zones into @data.
-    #
-    # @option options [String] :email E-mail address used for API access
-    # @option options [String] :token API token used for API access
-    def initialize(options = {})
-      super(options)
-      @data = auth_get("/api/xml/dns")["hash"]["zones"]
-    end
-  end
 end

data/lib/webbynode-api/dns.rb

@@ -0,0 +1,130 @@
+class WebbyNode
+  class DNS
+    # Represents the DNS zones present on the API account
+    #
+    # @author Shane Sveller
+    # @since 0.0.2
+    # @version 0.1.0
+    class Zone < WebbyNode::APIObject
+      # Holds the ID used internally at WebbyNode that represents a given zone.
+      attr_accessor :id
+
+      # Fetches either a single zone or an Array of all zones based on the presence
+      # of the id parameter.
+      #
+      # @option options [String] :email E-mail address used for API access
+      # @option options [String] :token API token used for API access
+      # @option options [Integer] :id ID that represents an individual zone
+      # @raise [ArgumentError] Raises ArgumentError if the :id option is missing
+      #   from the optins parameter.
+      # @example Get a zone with ID 100
+      #   @zone = WebbyNode::DNS::Zone.new(:email => email, :token => token, :id => 100)
+      def initialize(options = {})
+        raise ArgumentError, ":id is a required argument" unless options[:id]
+        super(options)
+        @id = options[:id]
+        @data = auth_get("/api/xml/dns/#{@id}")["hash"]["zone"]
+      end
+
+      # Activates a DNS zone in WebbyNode's DNS servers
+      #
+      # @since 0.1.2
+      # @return [String] Returns "Active" if successful
+      # @example Activate a zone with ID 100
+      #   @zone = WebbyNode::DNS::Zone.new(:email => email, :token => token, :id => 100)
+      #   @zone.status
+      #   # => "Inactive"
+      #   @zone.activate
+      #   # => "Active"
+      def activate
+        status = auth_post("/api/xml/dns/#{@id}", {:query => {"zone[status]" => "Active", :email => @email, :token => @token}})["hash"]["status"]
+        raise "Unable to activate zone" unless status == "Active"
+        return status
+      end
+
+      # Activates a DNS zone in WebbyNode's DNS servers
+      #
+      # @since 0.1.2
+      # @return [String] Returns "Inactive" if successful
+      # @example Deactivate a zone with ID 100
+      #   @zone = WebbyNode::DNS::Zone.new(:email => email, :token => token, :id => 100)
+      #   @zone.status
+      #   # => "Active"
+      #   @zone.deactivate
+      #   # => "Inactive"
+      def deactivate
+        status = auth_post("/api/xml/dns/#{@id}", {:query => {"zone[status]" => "Inactive", :email => @email, :token => @token}})["hash"]["status"]
+        raise "Unable to deactivate zone" unless status == "Inactive"
+        return status
+      end
+
+      # @since 0.0.6
+      # @option options [String] :email E-mail address used for API access
+      # @option options [String] :token API token used for API access
+      # @option options [optional, String] :status Optional argument to set the
+      #   status of the zone. Valid values include 'Active' or 'Inactive' only.
+      # @return [Hash] Hash of the new zone's information
+      # @raise [ArgumentError] Raises ArgumentError if :token, :email, :domain,
+      #   or :ttl are missing from the options parameter.
+      def self.create_zone(options = {})
+        raise ArgumentError, "API access information via :email and :token are required arguments" unless options[:email] && options[:token]
+        raise ArgumentError, ":domain and :ttl are required arguments" unless options[:domain] && options[:ttl]
+        if options[:status]
+          raise ArgumentError, ":status must be 'Active' or 'Inactive'" unless %w(Active Inactive).include? options[:status]
+        end
+        zone_data = auth_post("/api/xml/dns/new", :query =>
+          {
+            :email => options[:email],
+            :token => options[:token],
+            "zone[domain]" => options[:domain],
+            "zone[ttl]" => options[:ttl],
+            "zone[status]" => options[:status]
+          })
+        return zone_data["hash"]
+      end
+
+      # @since 0.0.6
+      # @option options [String] :email E-mail address used for API access
+      # @option options [String] :token API token used for API access
+      # @option options [Integer] :id WebbyNode's internally-used ID that idenftifies the zone
+      # @return [Boolean] Returns true upon succesful deletion of the zone.
+      # @raise [ArgumentError] Raises ArgumentError if :token, :email, or :id are
+      # missing from the options parameter.
+      def self.delete_zone(options = {})
+        raise ArgumentError, "API access information via :email and :token are required arguments" unless options[:email] && options[:token]
+        raise ArgumentError, ":id is a required argument" unless options[:id]
+        return auth_post("/api/xml/dns/#{options[:id]}/delete", :query => options)["hash"]["success"]
+      end
+    end
+
+    # Represents an Array of all DNS zones present on the API account
+    #
+    # @author Shane Sveller
+    # @since 0.1.0
+    # @version 0.1.0
+    class ZoneList < WebbyNode::APIObject
+      # Fetches an Array of all zones into @data.
+      #
+      # @option options [String] :email E-mail address used for API access
+      # @option options [String] :token API token used for API access
+      def initialize(options = {})
+        super(options)
+        @data = auth_get("/api/xml/dns")["hash"]["zones"]
+      end
+    end
+
+    # Represents an Array of all DNS records for a given zone
+    #
+    # @author Shane Sveller
+    # @since 0.1.1
+    # @version 0.1.0
+    class RecordList < WebbyNode::APIObject
+      def initialize(options = {})
+        raise ArgumentError, ":id is a required argument" unless options[:id]
+        super(options)
+        @id = options[:id]
+        @data = auth_get("/api/xml/dns/#{@id}/records")["hash"]["records"]
+      end
+    end
+  end
+end

data/lib/webbynode-api.rb

@@ -82,4 +82,4 @@ class WebbyNode
   end
 end
 
-require File.join(File.dirname(__FILE__), 'webbynode-api', 'data')
+Dir["#{File.dirname(__FILE__)}/webbynode-api/*.rb"].each {|file| require file}

data/test/apiobject_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+class WebbyNodeAPIObjectTest < Test::Unit::TestCase
+  context "with bad API token or email" do
+    setup do
+      @email ="example@email.com"
+      @token = "123456"
+      data_path = File.join(File.dirname(__FILE__), "data")
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/client\?\w+/i, :body => File.read("#{data_path}/bad-auth.xml"))
+      FakeWeb.register_uri(:post, /^https:\/\/manager\.webbynode\.com\/.+$/, :body => "")
+    end
+    should "raise ArgumentError if no API data given" do
+      # for auth_get
+      assert_raise(ArgumentError, "API information is missing or incomplete"){ WebbyNode::Client.new(:email => nil, :token => nil) }
+      assert_raise(ArgumentError, "API information is missing or incomplete"){ WebbyNode::Client.new(:email => @email, :token => nil) }
+      assert_raise(ArgumentError, "API information is missing or incomplete"){ WebbyNode::Client.new(:email => nil, :token => @token) }
+      # for auth_post
+      assert_raise(ArgumentError, "API information is missing or incomplete"){ WebbyNode::APIObject.new(:email => nil, :token => nil).auth_post("",{}) }
+      assert_raise(ArgumentError, "API information is missing or incomplete"){ WebbyNode::APIObject.new(:email => @email, :token => nil).auth_post("",{}) }
+      assert_raise(ArgumentError, "API information is missing or incomplete"){ WebbyNode::APIObject.new(:email => nil, :token => @token).auth_post("",{}) }
+    end
+    should "raise ArgumentError if bad API data given" do
+      assert_raise(ArgumentError, "Probable bad API information given"){ WebbyNode::Client.new(@email, @token) }
+      # TODO: Need XML fixture file for this
+      # assert_raise(ArgumentError, "Probable bad API information given"){ WebbyNode::APIObject.new(@email, @token).auth_post("",{}) }
+    end
+  end
+end

data/test/client_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+class WebbyNodeClientTest < Test::Unit::TestCase
+  context "fetching client data from API" do
+    setup do
+      email = "example@email.com"
+      token = "123456"
+      data_path = File.join(File.dirname(__FILE__), "data")
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/client\?.+/i, :body => File.read("#{data_path}/client.xml"))
+      @api = WebbyNode::Client.new(:email => email, :token => token)
+    end
+
+    should "use method missing to get values for present keys" do
+      @api.methods.include?("firstname").should == false
+      @api.firstname.should == "Shane"
+    end
+
+    should "return nil for missing keys" do
+      @api.blank.should be(nil)
+    end
+
+    should "fetch physical address information" do
+      @api.address1.should == "1234 Nonexistent Lane"
+      @api.city.should == "Nameless City"
+      @api.postcode.should == "65432"
+      @api.state.should == "My State"
+      @api.country.should == "US"
+    end
+
+    should "fetch user name, email and status" do
+      @api.firstname.should == "Shane"
+      @api.lastname.should == "Sveller"
+      @api.email.should == "example@email.com"
+      @api.status.should == "Active"
+      @api.datecreated.should == Date.new(2009,06,30)
+    end
+
+    should "fetch company name, phone number and credits" do
+      @api.credit.should == 1.5
+      @api.companyname.should == "Phantom Inc."
+      @api.phonenumber.should == "555-867-5309"
+    end
+  end
+end

data/test/data/activate-zone.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<hash>
+  <status>Active</status>
+  <ttl type="integer">86400</ttl>
+  <domain>example.com.</domain>
+  <id type="integer">171</id>
+</hash>

data/test/data/deactivate-zone.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<hash>
+  <status>Inactive</status>
+  <ttl type="integer">86400</ttl>
+  <domain>example.com.</domain>
+  <id type="integer">171</id>
+</hash>

data/test/dns_test.rb

@@ -0,0 +1,143 @@
+require 'test_helper'
+
+class WebbyNodeDNSTest < Test::Unit::TestCase
+  context "fetching all DNS data from API" do
+    setup do
+      email = "example@email.com"
+      token = "123456"
+      data_path = File.join(File.dirname(__FILE__), "data")
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\?.+/i, :body => File.read("#{data_path}/dns.xml"))
+      @zones = WebbyNode::DNS::ZoneList.new(:email => email, :token => token)
+    end
+    should "return an array of zones with domain, status, id, and TTL" do
+      @zones.data.is_a?(Array).should be(true)
+      @zones.data.size.should == 3
+      zone = @zones.data.first
+      zone["id"].should == 1
+      zone["status"].should == "Active"
+      zone["domain"].should == "example.com."
+      zone["ttl"].should == 86400
+      zone = @zones.data.last
+      zone["id"].should == 132
+      zone["status"].should == "Inactive"
+      zone["domain"].should == "inactive.com."
+      zone["ttl"].should == 86400
+    end
+  end
+  context "fetching DNS data from API with id" do
+    setup do
+      email = "example@email.com"
+      token = "123456"
+      id = 1
+      data_path = File.join(File.dirname(__FILE__), "data")
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\/\d+\?.+/i, :body => File.read("#{data_path}/dns-1.xml"))
+      @dns = WebbyNode::DNS::Zone.new(:email => email, :token => token, :id => id)
+    end
+    should "return domain name, status, id and TTL" do
+      @dns.domain.should == "example.com."
+      @dns.id.should == 1
+      @dns.ttl.should == 86400
+      @dns.status.should == "Active"
+    end
+  end
+  context "creating a new DNS zone" do
+    setup do
+      @email = "example@email.com"
+      @token = "123456"
+      @domain = "example.com."
+      @ttl = 86400
+      data_path = File.join(File.dirname(__FILE__), "data")
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:post, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\/new\?.+/i, :body => File.read("#{data_path}/new-zone.xml"))
+    end
+    should "raise ArgumentError if API information isn't present" do
+      assert_raise(ArgumentError,"API access information via :email and :token are required arguments"){ WebbyNode::DNS::Zone.create_zone(:token => @token, :domain => @domain, :ttl => @ttl) }
+      assert_raise(ArgumentError,"API access information via :email and :token are required arguments"){ WebbyNode::DNS::Zone.create_zone(:email => @email, :domain => @domain, :ttl => @ttl) }
+    end
+    should "raise ArgumentError if :domain or :ttl aren't included in method call" do
+      assert_raise(ArgumentError, ":domain and :ttl are required arguments"){ WebbyNode::DNS::Zone.create_zone(:email => @email, :token => @token, :ttl => @ttl) }
+      assert_raise(ArgumentError, ":domain and :ttl are required arguments"){ WebbyNode::DNS::Zone.create_zone(:email => @email, :token => @token, :domain => @domain) }
+    end
+    should "raise ArgumentError if :status is not a valid option" do
+      assert_raise(ArgumentError, ":domain and :ttl are required arguments"){ WebbyNode::DNS::Zone.create_zone(:email => @email, :token => @token, :ttl => @ttl, :status => "Not active") }
+      assert_nothing_raised(ArgumentError){ WebbyNode::DNS::Zone.create_zone(:email => @email, :token => @token, :domain => @domain, :ttl => @ttl, :status => "Active") }
+      assert_nothing_raised(ArgumentError){ WebbyNode::DNS::Zone.create_zone(:email => @email, :token => @token, :domain => @domain, :ttl => @ttl, :status => "Inactive") }
+      assert_nothing_raised(ArgumentError){ WebbyNode::DNS::Zone.create_zone(:email => @email, :token => @token, :domain => @domain, :ttl => @ttl, :status => nil) }
+    end
+    should "return a Hash containing the new zone's information" do
+      @new_zone =  WebbyNode::DNS::Zone.create_zone(:email => @email, :token => @token, :domain => @domain, :ttl => @ttl, :status => "Inactive")
+      @new_zone["id"].should == 171
+      @new_zone["domain"].should == "example.com."
+      @new_zone["ttl"].should == 86400
+    end
+  end
+  context "deleting a DNS zone" do
+    setup do
+      @email = "example@email.com"
+      @token = "123456"
+      @id = 171
+      data_path = File.join(File.dirname(__FILE__), "data")
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:post, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\/\d+\/delete\?.+/i, :body => File.read("#{data_path}/delete-zone.xml"))
+    end
+    should "return a boolean true for succesful deletion" do
+      WebbyNode::DNS::Zone.delete_zone(:email => @email, :token => @token, :id => @id)
+    end
+  end
+  context "activating and deactivating a zone" do
+    setup do
+      @email = "example@email.com"
+      @token = "123456"
+      @id = 171
+    end
+    should "raise RuntimeError if the action is unsuccesful" do
+      data_path = File.join(File.dirname(__FILE__), "data")
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\/\d+\?.+/i, :body => File.read("#{data_path}/dns-1.xml"))
+      FakeWeb.register_uri(:post, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\/\d+\?.+/i, :body => File.read("#{data_path}/deactivate-zone.xml"))
+      assert_raise(RuntimeError, "Unable to activate zone"){ WebbyNode::DNS::Zone.new(:email => @email, :token => @token, :id => @id).activate }
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\/\d+\?.+/i, :body => File.read("#{data_path}/dns-1.xml"))
+      FakeWeb.register_uri(:post, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\/\d+\?.+/i, :body => File.read("#{data_path}/activate-zone.xml"))
+      assert_raise(RuntimeError, "Unable to deactivate zone"){ WebbyNode::DNS::Zone.new(:email => @email, :token => @token, :id => @id).deactivate }
+    end
+    should "return the new status when activating or deactivating" do
+      data_path = File.join(File.dirname(__FILE__), "data")
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\/\d+\?.+/i, :body => File.read("#{data_path}/dns-1.xml"))
+      FakeWeb.register_uri(:post, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\/\d+\?.+/i, :body => File.read("#{data_path}/activate-zone.xml"))
+      WebbyNode::DNS::Zone.new(:email => @email, :token => @token, :id => @id).activate.should == "Active"
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\/\d+\?.+/i, :body => File.read("#{data_path}/dns-1.xml"))
+      FakeWeb.register_uri(:post, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\/\d+\?.+/i, :body => File.read("#{data_path}/deactivate-zone.xml"))
+      WebbyNode::DNS::Zone.new(:email => @email, :token => @token, :id => @id).deactivate.should == "Inactive"
+    end
+  end
+  context "listing a DNS zone's records" do
+    setup do
+      @email = "example@email.com"
+      @token = "123456"
+      @id = 1
+      data_path = File.join(File.dirname(__FILE__), "data")
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\/\d+\/records\?.+/i, :body => File.read("#{data_path}/dns-records.xml"))
+    end
+    should "raise ArgumentError if :id argument is absent" do
+      assert_raise(ArgumentError, ":id is a required argument"){ WebbyNode::DNS::RecordList.new(:email => @email, :token => @token, :id => nil)}
+      assert_nothing_raised { WebbyNode::DNS::RecordList.new(:email => @email, :token => @token, :id => @id)}
+    end
+    should "set @data to an Array of records" do
+      @records = WebbyNode::DNS::RecordList.new(:email => @email, :token => @token, :id => @id)
+      @records.data.is_a?(Array).should be(true)
+      record = @records.data.first
+      record["id"].should == 51
+      record["ttl"].should == 86400
+      record["data"].should == "200.100.200.100"
+      record["name"].should be(nil)
+      record["aux"].should == 0
+      record["type"].should == "A"
+    end
+  end
+end

data/test/webby_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+class WebbyNodeWebbyTest < Test::Unit::TestCase
+  context "fetching webby data from API" do
+    setup do
+      email = "example@email.com"
+      token = "123456"
+      hostname = "webby1"
+      data_path = File.join(File.dirname(__FILE__), "data")
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/webby\/\w+\/start\?.+/i, :body => File.read("#{data_path}/webby-start.xml"))
+      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/webby\/\w+\/shutdown\?.+/i, :body => File.read("#{data_path}/webby-shutdown.xml"))
+      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/webby\/\w+\/reboot\?.+/i, :body => File.read("#{data_path}/webby-reboot.xml"))
+      @webby = WebbyNode::Webby.new(:email => email, :token => token, :hostname => hostname)
+    end
+    should "return a job ID when starting, shutting down, or rebooting" do
+      @webby.start.should == 2562
+      @webby.shutdown.should == 2561
+      @webby.reboot.should == 2564
+    end
+    should "return a valid status" do
+      data_path = File.join(File.dirname(__FILE__), "data")
+      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/webby\/\w+\/status\?.+/i, :body => File.read("#{data_path}/webby-status.xml"))
+      @webby.status.should == "on"
+      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/webby\/\w+\/status\?.+/i, :body => File.read("#{data_path}/webby-status-shutdown.xml"))
+      @webby.status.should == "Shutting down"
+      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/webby\/\w+\/status\?.+/i, :body => File.read("#{data_path}/webby-status-off.xml"))
+      @webby.status.should == "off"
+      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/webby\/\w+\/status\?.+/i, :body => File.read("#{data_path}/webby-status-reboot.xml"))
+      @webby.status.should == "Rebooting"
+    end
+  end
+  context "fetching webbies data from API" do
+    setup do
+      email = "example@email.com"
+      token = "123456"
+      data_path = File.join(File.dirname(__FILE__), "data")
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/webbies\?.+/i, :body => File.read("#{data_path}/webbies.xml"))
+      @webbies = WebbyNode::WebbyList.new(:email => email, :token => token)
+    end
+    should "return a array of webbies" do
+      @webbies.data.is_a?(Array).should be(true)
+      webby = @webbies.data.first
+      webby["status"].should == "on"
+      webby["ip"].should == "222.111.222.111"
+      webby["node"].should == "location-a01"
+      webby["plan"].should == "Webby_384"
+      webby["name"].should == "webby1"
+      webby["notes"].should be(nil)
+    end
+  end
+end

data/webbynode-api.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{webbynode-api}
-  s.version = "0.1.0"
+  s.version = "0.1.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Shane Sveller"]
@@ -23,8 +23,13 @@ Gem::Specification.new do |s|
      "VERSION",
      "lib/webbynode-api.rb",
      "lib/webbynode-api/data.rb",
+     "lib/webbynode-api/dns.rb",
+     "test/apiobject_test.rb",
+     "test/client_test.rb",
+     "test/data/activate-zone.xml",
      "test/data/bad-auth.xml",
      "test/data/client.xml",
+     "test/data/deactivate-zone.xml",
      "test/data/delete-zone.xml",
      "test/data/dns-1.xml",
      "test/data/dns-records.xml",
@@ -38,8 +43,9 @@ Gem::Specification.new do |s|
      "test/data/webby-status-reboot.xml",
      "test/data/webby-status-shutdown.xml",
      "test/data/webby-status.xml",
+     "test/dns_test.rb",
      "test/test_helper.rb",
-     "test/webbynode-api_test.rb",
+     "test/webby_test.rb",
      "webbynode-api.gemspec"
   ]
   s.has_rdoc = true
@@ -49,8 +55,11 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.1}
   s.summary = %q{wraps the WebbyNode API into nice Ruby objects}
   s.test_files = [
-    "test/test_helper.rb",
-     "test/webbynode-api_test.rb"
+    "test/apiobject_test.rb",
+     "test/client_test.rb",
+     "test/dns_test.rb",
+     "test/test_helper.rb",
+     "test/webby_test.rb"
   ]
 
   if s.respond_to? :specification_version then

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: shanesveller-webbynode-api
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors: 
 - Shane Sveller
@@ -33,8 +33,13 @@ files:
 - VERSION
 - lib/webbynode-api.rb
 - lib/webbynode-api/data.rb
+- lib/webbynode-api/dns.rb
+- test/apiobject_test.rb
+- test/client_test.rb
+- test/data/activate-zone.xml
 - test/data/bad-auth.xml
 - test/data/client.xml
+- test/data/deactivate-zone.xml
 - test/data/delete-zone.xml
 - test/data/dns-1.xml
 - test/data/dns-records.xml
@@ -48,8 +53,9 @@ files:
 - test/data/webby-status-reboot.xml
 - test/data/webby-status-shutdown.xml
 - test/data/webby-status.xml
+- test/dns_test.rb
 - test/test_helper.rb
-- test/webbynode-api_test.rb
+- test/webby_test.rb
 - webbynode-api.gemspec
 has_rdoc: true
 homepage: http://github.com/shanesveller/webbynode-api
@@ -78,5 +84,8 @@ signing_key:
 specification_version: 2
 summary: wraps the WebbyNode API into nice Ruby objects
 test_files: 
+- test/apiobject_test.rb
+- test/client_test.rb
+- test/dns_test.rb
 - test/test_helper.rb
-- test/webbynode-api_test.rb
+- test/webby_test.rb

data/test/webbynode-api_test.rb

@@ -1,219 +0,0 @@
-require 'test_helper'
-
-class WebbynodeApiTest < Test::Unit::TestCase
-  context "with bad API token or email" do
-    setup do
-      @email ="example@email.com"
-      @token = "123456"
-      data_path = File.join(File.dirname(__FILE__), "data")
-      FakeWeb.clean_registry
-      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/client\?\w+/i, :body => File.read("#{data_path}/bad-auth.xml"))
-      FakeWeb.register_uri(:post, /^https:\/\/manager\.webbynode\.com\/.+$/, :body => "")
-    end
-    should "raise ArgumentError if no API data given" do
-      # for auth_get
-      assert_raise(ArgumentError, "API information is missing or incomplete"){ WebbyNode::Client.new(:email => nil, :token => nil) }
-      assert_raise(ArgumentError, "API information is missing or incomplete"){ WebbyNode::Client.new(:email => @email, :token => nil) }
-      assert_raise(ArgumentError, "API information is missing or incomplete"){ WebbyNode::Client.new(:email => nil, :token => @token) }
-      # for auth_post
-      assert_raise(ArgumentError, "API information is missing or incomplete"){ WebbyNode::APIObject.new(:email => nil, :token => nil).auth_post("",{}) }
-      assert_raise(ArgumentError, "API information is missing or incomplete"){ WebbyNode::APIObject.new(:email => @email, :token => nil).auth_post("",{}) }
-      assert_raise(ArgumentError, "API information is missing or incomplete"){ WebbyNode::APIObject.new(:email => nil, :token => @token).auth_post("",{}) }
-    end
-    should "raise ArgumentError if bad API data given" do
-      assert_raise(ArgumentError, "Probable bad API information given"){ WebbyNode::Client.new(@email, @token) }
-      # TODO: Need XML fixture file for this
-      # assert_raise(ArgumentError, "Probable bad API information given"){ WebbyNode::APIObject.new(@email, @token).auth_post("",{}) }
-    end
-  end
-  context "fetching client data from API" do
-    setup do
-      email = "example@email.com"
-      token = "123456"
-      data_path = File.join(File.dirname(__FILE__), "data")
-      FakeWeb.clean_registry
-      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/client\?.+/i, :body => File.read("#{data_path}/client.xml"))
-      @api = WebbyNode::Client.new(:email => email, :token => token)
-    end
-
-    should "use method missing to get values for present keys" do
-      @api.methods.include?("firstname").should == false
-      @api.firstname.should == "Shane"
-    end
-
-    should "return nil for missing keys" do
-      @api.blank.should be(nil)
-    end
-
-    should "fetch physical address information" do
-      @api.address1.should == "1234 Nonexistent Lane"
-      @api.city.should == "Nameless City"
-      @api.postcode.should == "65432"
-      @api.state.should == "My State"
-      @api.country.should == "US"
-    end
-
-    should "fetch user name, email and status" do
-      @api.firstname.should == "Shane"
-      @api.lastname.should == "Sveller"
-      @api.email.should == "example@email.com"
-      @api.status.should == "Active"
-      @api.datecreated.should == Date.new(2009,06,30)
-    end
-
-    should "fetch company name, phone number and credits" do
-      @api.credit.should == 1.5
-      @api.companyname.should == "Phantom Inc."
-      @api.phonenumber.should == "555-867-5309"
-    end
-  end
-
-  context "fetching webby data from API" do
-    setup do
-      email = "example@email.com"
-      token = "123456"
-      hostname = "webby1"
-      data_path = File.join(File.dirname(__FILE__), "data")
-      FakeWeb.clean_registry
-      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/webby\/\w+\/start\?.+/i, :body => File.read("#{data_path}/webby-start.xml"))
-      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/webby\/\w+\/shutdown\?.+/i, :body => File.read("#{data_path}/webby-shutdown.xml"))
-      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/webby\/\w+\/reboot\?.+/i, :body => File.read("#{data_path}/webby-reboot.xml"))
-      @webby = WebbyNode::Webby.new(:email => email, :token => token, :hostname => hostname)
-    end
-    should "return a job ID when starting, shutting down, or rebooting" do
-      @webby.start.should == 2562
-      @webby.shutdown.should == 2561
-      @webby.reboot.should == 2564
-    end
-    should "return a valid status" do
-      data_path = File.join(File.dirname(__FILE__), "data")
-      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/webby\/\w+\/status\?.+/i, :body => File.read("#{data_path}/webby-status.xml"))
-      @webby.status.should == "on"
-      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/webby\/\w+\/status\?.+/i, :body => File.read("#{data_path}/webby-status-shutdown.xml"))
-      @webby.status.should == "Shutting down"
-      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/webby\/\w+\/status\?.+/i, :body => File.read("#{data_path}/webby-status-off.xml"))
-      @webby.status.should == "off"
-      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/webby\/\w+\/status\?.+/i, :body => File.read("#{data_path}/webby-status-reboot.xml"))
-      @webby.status.should == "Rebooting"
-    end
-  end
-  context "fetching webbies data from API" do
-    setup do
-      email = "example@email.com"
-      token = "123456"
-      data_path = File.join(File.dirname(__FILE__), "data")
-      FakeWeb.clean_registry
-      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/webbies\?.+/i, :body => File.read("#{data_path}/webbies.xml"))
-      @webbies = WebbyNode::WebbyList.new(:email => email, :token => token)
-    end
-    should "return a array of webbies" do
-      @webbies.data.is_a?(Array).should be(true)
-      webby = @webbies.data.first
-      webby["status"].should == "on"
-      webby["ip"].should == "222.111.222.111"
-      webby["node"].should == "location-a01"
-      webby["plan"].should == "Webby_384"
-      webby["name"].should == "webby1"
-      webby["notes"].should be(nil)
-    end
-  end
-
-  context "fetching all DNS data from API" do
-    setup do
-      email = "example@email.com"
-      token = "123456"
-      data_path = File.join(File.dirname(__FILE__), "data")
-      FakeWeb.clean_registry
-      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\?.+/i, :body => File.read("#{data_path}/dns.xml"))
-      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\/\d+\?.+/i, :body => File.read("#{data_path}/dns-1.xml"))
-      @zones = WebbyNode::DNSList.new(:email => email, :token => token)
-    end
-    should "return an array of zones with domain, status, id, and TTL" do
-      @zones.data.is_a?(Array).should be(true)
-      @zones.data.size.should == 3
-      zone = @zones.data.first
-      zone["id"].should == 1
-      zone["status"].should == "Active"
-      zone["domain"].should == "example.com."
-      zone["ttl"].should == 86400
-      zone = @zones.data.last
-      zone["id"].should == 132
-      zone["status"].should == "Inactive"
-      zone["domain"].should == "inactive.com."
-      zone["ttl"].should == 86400
-    end
-  end
-  context "fetching DNS data from API with id" do
-    setup do
-      email = "example@email.com"
-      token = "123456"
-      id = 1
-      data_path = File.join(File.dirname(__FILE__), "data")
-      FakeWeb.clean_registry
-      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\?.+/i, :body => File.read("#{data_path}/dns.xml"))
-      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\/\d+\?.+/i, :body => File.read("#{data_path}/dns-1.xml"))
-      FakeWeb.register_uri(:get, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\/\d+\/records\?.+/i, :body => File.read("#{data_path}/dns-records.xml"))
-      @dns = WebbyNode::DNS.new(:email => email, :token => token, :id => id)
-    end
-    should "return domain name, status, id and TTL" do
-      @dns.domain.should == "example.com."
-      @dns.id.should == 1
-      @dns.ttl.should == 86400
-      @dns.status.should == "Active"
-    end
-    should "return an array of records with id, type, name, data, auxiliary data, and TTL" do
-      @dns.records.is_a?(Array).should be(true)
-      record = @dns.records.first
-      record["id"].should == 51
-      record["ttl"].should == 86400
-      record["data"].should == "200.100.200.100"
-      record["name"].should be(nil)
-      record["aux"].should == 0
-      record["type"].should == "A"
-    end
-  end
-  context "creating a new DNS zone" do
-    setup do
-      @email = "example@email.com"
-      @token = "123456"
-      @domain = "example.com."
-      @ttl = 86400
-      data_path = File.join(File.dirname(__FILE__), "data")
-      FakeWeb.clean_registry
-      FakeWeb.register_uri(:post, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\/new\?.+/i, :body => File.read("#{data_path}/new-zone.xml"))
-    end
-    should "raise ArgumentError if API information isn't present" do
-      assert_raise(ArgumentError,"API access information via :email and :token are required arguments"){ WebbyNode::DNS.new_zone(:token => @token, :domain => @domain, :ttl => @ttl) }
-      assert_raise(ArgumentError,"API access information via :email and :token are required arguments"){ WebbyNode::DNS.new_zone(:email => @email, :domain => @domain, :ttl => @ttl) }
-    end
-    should "raise ArgumentError if :domain or :ttl aren't included in method call" do
-      assert_raise(ArgumentError, ":domain and :ttl are required arguments"){ WebbyNode::DNS.new_zone(:email => @email, :token => @token, :ttl => @ttl) }
-      assert_raise(ArgumentError, ":domain and :ttl are required arguments"){ WebbyNode::DNS.new_zone(:email => @email, :token => @token, :domain => @domain) }
-    end
-    should "raise ArgumentError if :status is not a valid option" do
-      assert_raise(ArgumentError, ":domain and :ttl are required arguments"){ WebbyNode::DNS.new_zone(:email => @email, :token => @token, :ttl => @ttl, :status => "Not active") }
-      assert_nothing_raised(ArgumentError){ WebbyNode::DNS.new_zone(:email => @email, :token => @token, :domain => @domain, :ttl => @ttl, :status => "Active") }
-      assert_nothing_raised(ArgumentError){ WebbyNode::DNS.new_zone(:email => @email, :token => @token, :domain => @domain, :ttl => @ttl, :status => "Inactive") }
-      assert_nothing_raised(ArgumentError){ WebbyNode::DNS.new_zone(:email => @email, :token => @token, :domain => @domain, :ttl => @ttl, :status => nil) }
-    end
-    should "return a Hash containing the new zone's information" do
-      @new_zone =  WebbyNode::DNS.new_zone(:email => @email, :token => @token, :domain => @domain, :ttl => @ttl, :status => "Inactive")
-      @new_zone["id"].should == 171
-      @new_zone["domain"].should == "example.com."
-      @new_zone["ttl"].should == 86400
-    end
-  end
-  context "deleting a DNS zone" do
-    setup do
-      @email = "example@email.com"
-      @token = "123456"
-      @id = 171
-      data_path = File.join(File.dirname(__FILE__), "data")
-      FakeWeb.clean_registry
-      FakeWeb.register_uri(:post, /^https:\/\/manager\.webbynode\.com\/api\/xml\/dns\/\d+\/delete\?.+/i, :body => File.read("#{data_path}/delete-zone.xml"))
-    end
-    should "return a boolean true for succesful deletion" do
-      WebbyNode::DNS.delete_zone(:email => @email, :token => @token, :id => @id)
-    end
-  end
-end