fog-dnsimple 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0354086ffbb0b1f2866f487a18268ba11eb6be51
-  data.tar.gz: ccfcba77bec25c5a529c1f0458fd324e7ada83dc
+  metadata.gz: 7ae36b9bfa292d8ec1b6f188e38f00c38250b6cb
+  data.tar.gz: 4a8d56b5b4a8c37113305ec80fa61283964c60b1
 SHA512:
-  metadata.gz: 7ef2487be043841076620e863a78c8553f658710b315b1fed129cdf67b28460998fb0016d89a8def934f3727ceae2a8819aeb014ac02d9f242d1b7a37072be7c
-  data.tar.gz: 48ff4ad4dc4d169df5d2527d98a0e1d85b8111cda50351c6e0a8ad3db7d93ca5c480ca9fbb4035f77787fd28ba66951ce5c1064784b6b79d500953a734a1bb16
+  metadata.gz: bd86df711ff013b7f711afb7edaf0897a5ccc4788ea13a52beb05b12d8f19e2c802de6c3cd611403fa03e949a7bbb257453297a9a5d136eaec8590ecbf254173
+  data.tar.gz: 50533cd840e2002326d4ce7c17251289a82dc1607bb0033ec5726ed2a504a2565d5d9e0bbdae0ae69144fa55b84a72aa685787707be4a1409d9940fcf0781ab5

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+
+#### Release 2.0
+
+Upgrade to DNSimple API v2.
+https://developer.dnsimple.com/v2/
+
+In order to use API v2 you need an API v2 Oauth token, and the accound ID. The account ID is the ID visible in the URL of the page, after /a.
+
+    https://dnsimple.com/a/1234/domains/example.com
+    -> 1234
+
+
 #### Release 1.0
 
 Initial version, extracted from `fog`.

data/README.md

@@ -35,9 +35,9 @@ Initialize a `Fog::DNS` object using the DNSimple provider.
 
 ```ruby
 dns = Fog::DNS.new({
-  provider:       "DNSimple",
-  dnsimple_email: "YOUR_EMAIL",
-  dnsimple_token: "YOUR_API_V1_TOKEN",
+  provider:         "DNSimple",
+  dnsimple_token:   "YOUR_API_TOKEN",
+  dnsimple_account: "YOUR_ACCOUNT_ID",
 })
 ```
 
@@ -45,11 +45,11 @@ This can then be used like other [Fog DNS](http://fog.io/dns/) providers.
 
 ```ruby
 zone = dns.zones.create(
-  domain: "example.com
+  domain: "example.com"
 )
 record = zone.records.create(
-  name: "example.com,
-  value: "1.2.3.4,
+  name: "foo",
+  value: "1.2.3.4",
   type: "A"
 )
 ```
@@ -60,18 +60,6 @@ The following configurations are supported:
 dns = Fog::DNS.new({
   # Use dnsimple_url to provide a different base URL, e.g. the Sandbox URL
   dnsimple_url:   "https://api.sandbox.dnsimple.com/",
-
-  # API v1 token-based authentication
-  dnsimple_email: "...",
-  dnsimple_token: "...",
-
-  # API v1 basic-auth
-  dnsimple_email: "...",
-  dnsimple_password: "...",
-
-  # API v1 domain-token authentication
-  dnsimple_domain: "example.com",
-  dnsimple_token: "...",
 })
 ```
 

data/fog-dnsimple.gemspec

@@ -16,13 +16,14 @@ Gem::Specification.new do |spec|
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.12"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", "~> 12.0"
   spec.add_development_dependency "shindo", "~> 0.3"
 
-  spec.add_dependency 'fog-core',  '~> 1.38'
+  spec.add_dependency 'fog-core',  '>= 1.38', '< 3'
   spec.add_dependency 'fog-json',  '~> 1.0'
 end

data/lib/fog/bin/dnsimple.rb

@@ -13,7 +13,7 @@ class Dnsimple < Fog::Bin
       @@connections ||= Hash.new do |hash, key|
         hash[key] = case key
         when :dns
-          Fog::DNS.new(:provider => 'Dnsimple')
+          Fog::DNS.new(provider: "Dnsimple")
         else
           raise ArgumentError, "Unrecognized service: #{key.inspect}"
         end

data/lib/fog/dnsimple/dns.rb

@@ -4,7 +4,7 @@ require "fog/json"
 module Fog
   module DNS
     class Dnsimple < Fog::Service
-      recognizes :dnsimple_email, :dnsimple_password, :dnsimple_token, :dnsimple_domain, :dnsimple_url
+      recognizes :dnsimple_token, :dnsimple_account, :dnsimple_url
 
       model_path 'fog/dnsimple/models/dns'
       model       :record
@@ -27,8 +27,8 @@ module Fog
         def self.data
           @data ||= Hash.new do |hash, key|
             hash[key] = {
-                :domains => [],
-                :records => {}
+                domains: [],
+                records: {}
             }
           end
         end
@@ -37,28 +37,23 @@ module Fog
           @data = nil
         end
 
-        def initialize(options={})
-          @dnsimple_email = options[:dnsimple_email]
-          @dnsimple_password  = options[:dnsimple_password]
+        def initialize(options = {})
           @dnsimple_token = options[:dnsimple_token]
-          @dnsimple_domain = options[:dnsimple_domain]
         end
 
         def data
-          self.class.data[@dnsimple_email]
+          self.class.data[@dnsimple_token]
         end
 
         def reset_data
-          self.class.data.delete(@dnsimple_email)
+          self.class.data.delete(@dnsimple_token)
         end
       end
 
       class Real
-        def initialize(options={})
-          @dnsimple_email = options[:dnsimple_email]
-          @dnsimple_password  = options[:dnsimple_password]
+        def initialize(options = {})
           @dnsimple_token = options[:dnsimple_token]
-          @dnsimple_domain = options[:dnsimple_domain]
+          @dnsimple_account = options[:dnsimple_account]
 
           if options[:dnsimple_url]
             uri = URI.parse(options[:dnsimple_url])
@@ -74,7 +69,7 @@ module Fog
           host       = options[:host]        || "api.dnsimple.com"
           persistent = options[:persistent]  || false
           port       = options[:port]        || 443
-          scheme     = options[:scheme]      || 'https'
+          scheme     = options[:scheme]      || "https"
           @connection = Fog::Core::Connection.new("#{scheme}://#{host}:#{port}", persistent, connection_options)
         end
 
@@ -85,15 +80,8 @@ module Fog
         def request(params)
           params[:headers] ||= {}
 
-          if(@dnsimple_password)
-            key = "#{@dnsimple_email}:#{@dnsimple_password}"
-            params[:headers].merge!("Authorization" => "Basic " + Base64.encode64(key).gsub("\n",''))
-          elsif(@dnsimple_token)
-            if(@dnsimple_domain)
-              params[:headers].merge!("X-DNSimple-Domain-Token" => @dnsimple_token)
-            else
-              params[:headers].merge!("X-DNSimple-Token" => "#{@dnsimple_email}:#{@dnsimple_token}")
-            end
+          if @dnsimple_token && @dnsimple_account
+            params[:headers].merge!("Authorization" => "Bearer #{@dnsimple_token}")
           else
             raise ArgumentError.new("Insufficient credentials to properly authenticate!")
           end
@@ -102,8 +90,8 @@ module Fog
               "Content-Type" => "application/json"
           )
 
-          version = params.delete(:version) || 'v1'
-          params[:path] = File.join('/', version, params[:path])
+          version = params.delete(:version) || "v2"
+          params[:path] = File.join("/", version, params[:path])
 
           response = @connection.request(params)
 

data/lib/fog/dnsimple/models/dns/record.rb

@@ -6,16 +6,16 @@ module Fog
       class Record < Fog::Model
         identity :id
 
-        attribute :zone_id,     :aliases => "domain_id"
+        attribute :zone_id,     aliases: "domain_id"
         attribute :name
-        attribute :value,       :aliases => "content"
+        attribute :value,       aliases: "content"
         attribute :ttl
-        attribute :priority,    :aliases => "prio"
-        attribute :type,        :aliases => "record_type"
+        attribute :priority
+        attribute :type
         attribute :created_at
         attribute :updated_at
 
-        def initialize(attributes={})
+        def initialize(attributes = {})
           super
         end
 
@@ -31,8 +31,7 @@ module Fog
         def save
           requires :name, :type, :value
           options = {}
-          options[:prio] = priority if priority
-          options[:ttl]  = ttl if ttl
+          options[:ttl] = ttl if ttl
 
           # decide whether its a new record or update of an existing
           if id.nil?
@@ -44,7 +43,7 @@ module Fog
             data = service.update_record(zone.id, id, options)
           end
 
-          merge_attributes(data.body["record"])
+          merge_attributes(data.body["data"])
           true
         end
 

data/lib/fog/dnsimple/models/dns/records.rb

@@ -12,13 +12,13 @@ module Fog
         def all
           requires :zone
           clear
-          data = service.list_records(zone.id).body.map {|record| record['record']}
+          data = service.list_records(zone.id).body["data"]
           load(data)
         end
 
         def get(record_id)
           requires :zone
-          data = service.get_record(zone.id, record_id).body["record"]
+          data = service.get_record(zone.id, record_id).body["data"]
           new(data)
         rescue Excon::Errors::NotFound
           nil
@@ -26,7 +26,7 @@ module Fog
 
         def new(attributes = {})
           requires :zone
-          super({ :zone => zone }.merge!(attributes))
+          super({ zone: zone }.merge!(attributes))
         end
       end
     end

data/lib/fog/dnsimple/models/dns/zone.rb

@@ -7,7 +7,7 @@ module Fog
       class Zone < Fog::Model
         identity :id
 
-        attribute :domain,     :aliases => 'name'
+        attribute :domain,     aliases: "name"
         attribute :created_at
         attribute :updated_at
 
@@ -36,7 +36,7 @@ module Fog
 
         def save
           requires :domain
-          data = service.create_domain(domain).body["domain"]
+          data = service.create_domain(domain).body["data"]
           merge_attributes(data)
           true
         end

data/lib/fog/dnsimple/models/dns/zones.rb

@@ -9,12 +9,12 @@ module Fog
 
         def all
           clear
-          data = service.list_domains.body.map {|zone| zone['domain']}
+          data = service.list_domains.body["data"]
           load(data)
         end
 
         def get(zone_id)
-          data = service.get_domain(zone_id).body['domain']
+          data = service.get_domain(zone_id).body["data"]
           new(data)
         rescue Excon::Errors::NotFound
           nil

data/lib/fog/dnsimple/requests/dns/create_domain.rb

@@ -5,55 +5,47 @@ module Fog
         # Create a single domain in DNSimple in your account.
         #
         # ==== Parameters
-        # * name<~String> - domain name to host (ie example.com)
+        # * zone_name<~String> - zone name to host (ie example.com)
         #
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Hash>:
-        #     * 'domain'<~Hash> The representation of the domain.
-        def create_domain(name)
+        #     * "data"<~Hash> The representation of the domain.
+        def create_domain(zone_name)
           body = {
-            "domain" => {
-              "name" => name
-            }
+            "name" => zone_name
           }
 
           request(
-            :body     => Fog::JSON.encode(body),
-            :expects  => 201,
-            :method   => 'POST',
-            :path     => "/domains"
+            body:     Fog::JSON.encode(body),
+            expects:  201,
+            method:   "POST",
+            path:     "/#{@dnsimple_account}/domains"
           )
         end
       end
 
       class Mock
-        def create_domain(name)
+        def create_domain(zone_name)
           body = {
-            "domain" =>  {
-              "id"                 => Fog::Mock.random_numbers(1).to_i,
-              "user_id"            => 1,
-              "registrant_id"      => nil,
-              "name"               => name,
-              "unicode_name"       => name,
-              "token"              => "4fIFYWYiJayvL2tkf_mkBkqC4L+4RtYqDA",
-              "state"              => "registered",
-              "language"           => nil,
-              "lockable"           => true,
-              "auto_renew"         => nil,
-              "whois_protected"    => false,
-              "record_count"       => 0,
-              "service_count"      => 0,
-              "expires_on"         => Date.today + 365,
-              "created_at"         => Time.now.iso8601,
-              "updated_at"         => Time.now.iso8601,
-            }
+            "id"                 => Fog::Mock.random_numbers(1).to_i,
+            "account_id"         => @dnsimple_account,
+            "registrant_id"      => nil,
+            "name"               => zone_name,
+            "unicode_name"       => zone_name,
+            "token"              => "4fIFYWYiJayvL2tkf_mkBkqC4L+4RtYqDA",
+            "state"              => "registered",
+            "auto_renew"         => nil,
+            "private_whois"     => false,
+            "expires_on"         => Date.today + 365,
+            "created_at"         => Time.now.iso8601,
+            "updated_at"         => Time.now.iso8601,
           }
           self.data[:domains] << body
 
           response = Excon::Response.new
           response.status = 201
-          response.body = body
+          response.body = { "data" => body }
           response
         end
       end

data/lib/fog/dnsimple/requests/dns/create_record.rb

@@ -5,7 +5,7 @@ module Fog
         # Create a new host in the specified zone
         #
         # ==== Parameters
-        # * domain<~String> - domain name or numeric ID
+        # * zone_name<~String> - zone name
         # * name<~String>
         # * type<~String>
         # * content<~String>
@@ -17,48 +17,43 @@ module Fog
         # * response<~Excon::Response>:
         #   * body<~Hash>:
         #     * 'record'<~Hash> The representation of the record.
-        def create_record(domain, name, type, content, options = {})
+        def create_record(zone_name, name, type, content, options = {})
           body = {
-            "record" => {
-              "name" => name,
-              "record_type" => type,
-              "content" => content
-            }
+            "name" => name,
+            "type" => type,
+            "content" => content
           }
-
-          body["record"].merge!(options)
+          body.merge!(options)
 
           request(
-            :body     => Fog::JSON.encode(body),
-            :expects  => 201,
-            :method   => 'POST',
-            :path     => "/domains/#{domain}/records"
+            body:     Fog::JSON.encode(body),
+            expects:  201,
+            method:   "POST",
+            path:     "/#{@dnsimple_account}/zones/#{zone_name}/records"
           )
         end
       end
 
       class Mock
-        def create_record(domain, name, type, content, options = {})
+        def create_record(zone_name, name, type, content, options = {})
           body = {
-            "record" => {
-              "id" => Fog::Mock.random_numbers(1).to_i,
-              "domain_id" => domain,
-              "name" => name,
-              "content" => content,
-              "ttl" => 3600,
-              "prio" => nil,
-              "record_type" => type,
-              "system_record" => nil,
-              "created_at" => Time.now.iso8601,
-              "updated_at" => Time.now.iso8601,
-            }.merge(options)
-          }
-          self.data[:records][domain] ||= []
-          self.data[:records][domain] << body
+            "id" => Fog::Mock.random_numbers(1).to_i,
+            "domain_id" => 1,
+            "name" => name,
+            "content" => content,
+            "ttl" => 3600,
+            "priority" => 0,
+            "type" => type,
+            "system_record" => false,
+            "created_at" => Time.now.iso8601,
+            "updated_at" => Time.now.iso8601,
+          }.merge(options)
+          self.data[:records][zone_name] ||= []
+          self.data[:records][zone_name] << body
 
           response = Excon::Response.new
           response.status = 201
-          response.body = body
+          response.body = { "data" => body }
           response
         end
       end

data/lib/fog/dnsimple/requests/dns/delete_domain.rb

@@ -9,24 +9,25 @@ module Fog
         # DNSimple this will not delete the domain from the registry.
         #
         # ==== Parameters
-        # * domain<~String> - domain name or numeric ID
+        # * account_id<~String> - the account the domain belong to
+        # * zone_name<~String> - zone name
         #
-        def delete_domain(domain)
+        def delete_domain(zone_name)
           request(
-            :expects  => 200,
-            :method   => 'DELETE',
-            :path     => "/domains/#{domain}"
+            expects:  204,
+            method:   "DELETE",
+            path:     "/#{@dnsimple_account}/domains/#{zone_name}"
           )
         end
       end
 
       class Mock
-        def delete_domain(name)
-          self.data[:records].delete name
-          self.data[:domains].reject! { |domain| domain["domain"]["name"] == name }
+        def delete_domain(zone_name)
+          self.data[:records].delete(zone_name)
+          self.data[:domains].reject! { |domain| domain["name"] == zone_name }
 
           response = Excon::Response.new
-          response.status = 200
+          response.status = 204
           response
         end
       end

data/lib/fog/dnsimple/requests/dns/delete_record.rb

@@ -5,23 +5,23 @@ module Fog
         # Delete the record with the given ID for the given domain.
         #
         # ==== Parameters
-        # * domain<~String> - domain name or numeric ID
+        # * zone_name<~String> - zone name
         # * record_id<~String>
-        def delete_record(domain, record_id)
+        def delete_record(zone_name, record_id)
           request(
-            :expects  => 200,
-            :method   => "DELETE",
-            :path     => "/domains/#{domain}/records/#{record_id}"
+            expects:  204,
+            method:   "DELETE",
+            path:     "/#{@dnsimple_account}/zones/#{zone_name}/records/#{record_id}"
           )
         end
       end
 
       class Mock
-        def delete_record(domain, record_id)
-          self.data[:records][domain].reject! { |record| record["record"]["id"] == record_id }
+        def delete_record(zone_name, record_id)
+          self.data[:records][zone_name].reject! { |record| record["id"] == record_id }
 
           response = Excon::Response.new
-          response.status = 200
+          response.status = 204
           response
         end
       end

data/lib/fog/dnsimple/requests/dns/get_domain.rb

@@ -7,30 +7,30 @@ module Fog
         # itself.
         #
         # ==== Parameters
-        # * domain<~String> - domain name or numeric ID
+        # * zone_name<~String> - zone name
         #
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Hash>:
-        #     * 'domain'<~Hash> The representation of the domain.
-        def get_domain(domain)
+        #     * "data"<~Hash> The representation of the domain.
+        def get_domain(zone_name)
           request(
-            :expects  => 200,
-            :method   => "GET",
-            :path     => "/domains/#{domain}"
+            expects:  200,
+            method:   "GET",
+            path:     "/#{@dnsimple_account}/domains/#{zone_name}"
           )
         end
       end
 
       class Mock
-        def get_domain(id)
+        def get_domain(zone_name)
           domain = self.data[:domains].find do |domain|
-            domain["domain"]["id"] == id || domain["domain"]["name"] == id
+            domain["id"] == zone_name || domain["name"] == zone_name
           end
 
           response = Excon::Response.new
           response.status = 200
-          response.body = domain
+          response.body = { "data" => domain }
           response
         end
       end

data/lib/fog/dnsimple/requests/dns/get_record.rb

@@ -5,29 +5,29 @@ module Fog
         # Gets record from given domain.
         #
         # ==== Parameters
-        # * domain<~String> - domain name or numeric ID
+        # * zone_name<~String> - zone name
         # * record_id<~String>
         #
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Hash>:
-        #     * 'record'<~Hash> The representation of the record.
-        def get_record(domain, record_id)
+        #     * "data"<~Hash> The representation of the record.
+        def get_record(zone_name, record_id)
           request(
-            :expects  => 200,
-            :method   => "GET",
-            :path     => "/domains/#{domain}/records/#{record_id}"
+            expects:  200,
+            method:   "GET",
+            path:     "/#{@dnsimple_account}/zones/#{zone_name}/records/#{record_id}"
           )
         end
       end
 
       class Mock
-        def get_record(domain, record_id)
+        def get_record(zone_name, record_id)
           response = Excon::Response.new
 
-          if self.data[:records].key?(domain)
+          if self.data[:records].key?(zone_name)
             response.status = 200
-            response.body = self.data[:records][domain].find { |record| record["record"]["id"] == record_id }
+            response.body = { "data" => self.data[:records][zone_name].find { |record| record["id"] == record_id }}
 
             if response.body.nil?
               response.status = 404
@@ -38,7 +38,7 @@ module Fog
           else
             response.status = 404
             response.body = {
-              "error" => "Couldn't find Domain with name = #{domain}"
+              "error" => "Couldn't find Domain with name = #{zone_name}"
             }
           end
           response

data/lib/fog/dnsimple/requests/dns/list_domains.rb

@@ -2,21 +2,20 @@ module Fog
   module DNS
     class Dnsimple
       class Real
-        # Get the details for a specific domain in your account. You
-        # may pass either the domain numeric ID or the domain name itself.
+        # Get the list of domains in the account.
         #
         # ==== Parameters
         #
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Hash>:
-        #     * <~Array>:
-        #       * 'domain'<~Hash> The representation of the domain.
+        #     * "data"<~Array>:
+        #       * <~Hash> The representation of the domain.
         def list_domains
           request(
-            :expects  => 200,
-            :method   => 'GET',
-            :path     => '/domains'
+            expects:  200,
+            method:   "GET",
+            path:     "/#{@dnsimple_account}/domains"
           )
         end
       end
@@ -25,7 +24,7 @@ module Fog
         def list_domains
           response = Excon::Response.new
           response.status = 200
-          response.body = self.data[:domains]
+          response.body = { "data" => self.data[:domains] }
           response
         end
       end

data/lib/fog/dnsimple/requests/dns/list_records.rb

@@ -5,27 +5,27 @@ module Fog
         # Get the list of records for the specific domain.
         #
         # ==== Parameters
-        # * domain<~String> - domain name or numeric ID
+        # * zone_name<~String> - zone name
         #
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Hash>:
-        #     * <~Array>:
-        #       * 'record'<~Hash> The representation of the record.
-        def list_records(domain)
+        #     * "data"<~Array>:
+        #       * <~Hash> The representation of the record.
+        def list_records(zone_name)
           request(
-            :expects  => 200,
-            :method   => "GET",
-            :path     => "/domains/#{domain}/records"
+            expects:  200,
+            method:   "GET",
+            path:     "/#{@dnsimple_account}/zones/#{zone_name}/records"
           )
         end
       end
 
       class Mock
-        def list_records(domain)
+        def list_records(zone_name)
           response = Excon::Response.new
           response.status = 200
-          response.body = self.data[:records][domain] || []
+          response.body = { "data" => self.data[:records][zone_name] || [] }
           response
         end
       end

data/lib/fog/dnsimple/requests/dns/update_record.rb

@@ -5,7 +5,7 @@ module Fog
         # Update the given record for the given domain.
         #
         # ==== Parameters
-        # * domain<~String> - domain name or numeric ID
+        # * zone_name<~String> - zone name
         # * record_id<~String>
         # * options<~Hash> - optional
         #   * type<~String>
@@ -16,33 +16,31 @@ module Fog
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Hash>:
-        #     * 'record'<~Hash> The representation of the record.
-        def update_record(domain, record_id, options)
-          body = {
-            "record" => options
-          }
+        #     * "data"<~Hash> The representation of the record.
+        def update_record(zone_name, record_id, options)
+          body = options
 
           request(
-            :body     => Fog::JSON.encode(body),
-            :expects  => 200,
-            :method   => "PUT",
-            :path     => "/domains/#{domain}/records/#{record_id}"
+            body:     Fog::JSON.encode(body),
+            expects:  200,
+            method:   "PATCH",
+            path:     "/#{@dnsimple_account}/zones/#{zone_name}/records/#{record_id}"
           )
         end
       end
 
       class Mock
-        def update_record(domain, record_id, options)
-          record = self.data[:records][domain].find { |record| record["record"]["id"] == record_id }
+        def update_record(zone_name, record_id, options)
+          record = self.data[:records][zone_name].find { |record| record["id"] == record_id }
           response = Excon::Response.new
 
           if record.nil?
             response.status = 400
           else
             response.status = 200
-            record["record"].merge!(options)
-            record["record"]["updated_at"] = Time.now.iso8601
-            response.body = record
+            record.merge!(options)
+            record["updated_at"] = Time.now.iso8601
+            response.body = { "data" => record }
           end
 
           response

data/lib/fog/dnsimple/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module Dnsimple
-    VERSION = "1.0.0"
+    VERSION = "2.0.0"
   end
 end

data/tests/requests/dns/dns_tests.rb

@@ -6,9 +6,9 @@ Shindo.tests('Fog::DNS[:dnsimple] | DNS requests', ['dnsimple', 'dns']) do
   tests("success") do
 
     test("get current domain count") do
-      response = Fog::DNS[:dnsimple].list_domains()
+      response = Fog::DNS[:dnsimple].list_domains
       if response.status == 200
-        @domain_count = response.body.size
+        @domain_count = response.body["data"].size
       end
 
       response.status == 200
@@ -18,7 +18,7 @@ Shindo.tests('Fog::DNS[:dnsimple] | DNS requests', ['dnsimple', 'dns']) do
       domain = generate_unique_domain
       response = Fog::DNS[:dnsimple].create_domain(domain)
       if response.status == 201
-        @domain = response.body["domain"]
+        @domain = response.body["data"]
       end
 
       response.status == 201
@@ -37,7 +37,7 @@ Shindo.tests('Fog::DNS[:dnsimple] | DNS requests', ['dnsimple', 'dns']) do
       response = Fog::DNS[:dnsimple].create_record(domain, name, type, content)
 
       if response.status == 201
-        @record = response.body["record"]
+        @record = response.body["data"]
       end
 
       response.status == 201
@@ -49,7 +49,7 @@ Shindo.tests('Fog::DNS[:dnsimple] | DNS requests', ['dnsimple', 'dns']) do
       name = ""
       type = "MX"
       content = "mail.#{domain}"
-      options = { "ttl" => 60, "prio" => 10 }
+      options = { "ttl" => 60, "priority" => 10 }
       response = Fog::DNS[:dnsimple].create_record(domain, name, type, content, options)
 
       test "MX record creation returns 201" do
@@ -57,11 +57,11 @@ Shindo.tests('Fog::DNS[:dnsimple] | DNS requests', ['dnsimple', 'dns']) do
       end
 
       options.each do |key, value|
-        test("MX record has option #{key}") { value == response.body["record"][key.to_s] }
+        test("MX record has option #{key}") { value == response.body["data"][key.to_s] }
       end
 
       test "MX record is correct type" do
-        response.body["record"]["record_type"] == "MX"
+        response.body["data"]["type"] == "MX"
       end
     end
 
@@ -71,7 +71,7 @@ Shindo.tests('Fog::DNS[:dnsimple] | DNS requests', ['dnsimple', 'dns']) do
 
       response = Fog::DNS[:dnsimple].get_record(domain, record_id)
 
-      (response.status == 200) and (@record == response.body["record"])
+      (response.status == 200) and (@record == response.body["data"])
     end
 
     test("update a record") do
@@ -86,11 +86,11 @@ Shindo.tests('Fog::DNS[:dnsimple] | DNS requests', ['dnsimple', 'dns']) do
       response = Fog::DNS[:dnsimple].list_records(@domain["name"])
 
       if response.status == 200
-        @records = response.body
+        @records = response.body["data"]
       end
 
       test "list records returns all records for domain" do
-        @records.reject { |record| record["record"]["system_record"] }.size == 2
+        @records.reject { |record| record["system_record"] }.size == 2
       end
 
       response.status == 200
@@ -101,9 +101,9 @@ Shindo.tests('Fog::DNS[:dnsimple] | DNS requests', ['dnsimple', 'dns']) do
 
       result = true
       @records.each do |record|
-        next if record["record"]["system_record"]
-        response = Fog::DNS[:dnsimple].delete_record(domain, record["record"]["id"])
-        if response.status != 200
+        next if record["system_record"]
+        response = Fog::DNS[:dnsimple].delete_record(domain, record["id"])
+        if response.status != 204
           result = false
           break
         end
@@ -114,7 +114,7 @@ Shindo.tests('Fog::DNS[:dnsimple] | DNS requests', ['dnsimple', 'dns']) do
 
     test("delete domain") do
       response = Fog::DNS[:dnsimple].delete_domain(@domain["name"])
-      response.status == 200
+      response.status == 204
     end
 
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fog-dnsimple
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Simone Carletti
 autorequire: 
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2016-07-11 00:00:00.000000000 Z
+date: 2018-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.0'
 - !ruby/object:Gem::Dependency
   name: shindo
   requirement: !ruby/object:Gem::Requirement
@@ -56,16 +56,22 @@ dependencies:
   name: fog-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.38'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.38'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: fog-json
   requirement: !ruby/object:Gem::Requirement
@@ -85,9 +91,7 @@ description: |-
                           to use the DNSimple in applications.
 email:
 - weppos@weppos.net
-executables:
-- console
-- setup
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
@@ -147,7 +151,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Module for the 'fog' gem to support DNSimple.