cronofy 0.0.5 → 0.1.0

data/lib/cronofy/errors.rb

@@ -1,14 +1,11 @@
 module Cronofy
   class CronofyError < StandardError
-
   end
 
   class CredentialsMissingError < CronofyError
-
     def initialize(message=nil)
       super(message || "No credentials supplied")
     end
-
   end
 
   class APIError < CronofyError
@@ -32,28 +29,52 @@ module Cronofy
     end
   end
 
-  class NotFoundError < APIError
+  class BadRequestError < APIError
+  end
 
+  class NotFoundError < APIError
   end
 
   class AuthenticationFailureError < APIError
-
   end
 
   class AuthorizationFailureError < APIError
-
   end
 
   class InvalidRequestError < APIError
-
   end
 
   class TooManyRequestsError < APIError
-
   end
 
   class UnknownError < APIError
-
   end
 
-end
+  # Internal: Helper methods for raising more meaningful errors.
+  class Errors
+    ERROR_MAP = {
+      400 => BadRequestError,
+      401 => AuthenticationFailureError,
+      403 => AuthorizationFailureError,
+      404 => NotFoundError,
+      422 => InvalidRequestError,
+      429 => TooManyRequestsError,
+    }.freeze
+
+    def self.map_error(error)
+      raise_error(error.response)
+    end
+
+    def self.raise_if_error(response)
+      return if response.status == 200
+      raise_error(response)
+    end
+
+    private
+
+    def self.raise_error(response)
+      error_class = ERROR_MAP.fetch(response.status, UnknownError)
+      raise error_class.new(response.headers['status'], response)
+    end
+  end
+end

data/lib/cronofy/response_parser.rb

@@ -1,13 +1,38 @@
 require 'json'
 
 module Cronofy
+  # Internal: Class for dealing with the parsing of API responses.
   class ResponseParser
     def initialize(response)
       @response = response
     end
 
-    def parse_json
-      JSON.parse @response.body
+    def parse_collection(type, attribute = nil)
+      target = parsing_target(attribute)
+      target.map { |item| type.new(item) }
+    end
+
+    def parse_json(type, attribute = nil)
+      target = parsing_target(attribute)
+      type.new(target)
+    end
+
+    def json
+      json_hash.dup
+    end
+
+    private
+
+    def json_hash
+      @json_hash ||= JSON.parse(@response.body)
+    end
+
+    def parsing_target(attribute)
+      if attribute
+        json_hash[attribute]
+      else
+        json_hash
+      end
     end
   end
-end
+end

data/lib/cronofy/types.rb

@@ -0,0 +1,143 @@
+require "date"
+require "hashie"
+
+module Cronofy
+  class Credentials
+    attr_reader :access_token
+    attr_reader :expires_at
+    attr_reader :expires_in
+    attr_reader :refresh_token
+    attr_reader :scope
+
+    def initialize(oauth_token)
+      @access_token = oauth_token.token
+      @expires_at = oauth_token.expires_at
+      @expires_in = oauth_token.expires_in
+      @refresh_token = oauth_token.refresh_token
+      @scope = oauth_token.params['scope']
+    end
+
+    def to_hash
+      {
+        access_token: access_token,
+        expires_at: expires_at,
+        expires_in: expires_in,
+        refresh_token: refresh_token,
+        scope: scope,
+      }
+    end
+  end
+
+  class DateOrTime
+    def initialize(args)
+      # Prefer time if both provided as it is more accurate
+      if args[:time]
+        @time = args[:time]
+      else
+        @date = args[:date]
+      end
+    end
+
+    def self.coerce(value)
+      begin
+        time = Time.strptime(value, '%Y-%m-%dT%H:%M:%SZ')
+      rescue
+        begin
+          date = Date.strptime(value, '%Y-%m-%d')
+        rescue
+        end
+      end
+
+      coerced = self.new(time: time, date: date)
+
+      raise "Failed to coerce \"#{value}\"" unless coerced.time? or coerced.date?
+
+      coerced
+    end
+
+    def date
+      @date
+    end
+
+    def date?
+      !!@date
+    end
+
+    def time
+      @time
+    end
+
+    def time?
+      !!@time
+    end
+
+    def to_date
+      if date?
+        date
+      else
+        time.to_date
+      end
+    end
+
+    def to_time
+      if time?
+        time
+      else
+        # Convert dates to UTC time, not local time
+        Time.utc(date.year, date.month, date.day)
+      end
+    end
+
+    def ==(other)
+      case other
+      when DateOrTime
+        if self.time?
+          other.time? and self.time == other.time
+        elsif self.date?
+          other.date? and self.date == other.date
+        else
+          # Both neither date nor time
+          self.time? == other.time? and self.date? == other.date?
+        end
+      else
+        false
+      end
+    end
+
+    def inspect
+      to_s
+    end
+
+    def to_s
+      if time?
+        "<#{self.class} time=#{self.time}>"
+      elsif date?
+        "<#{self.class} date=#{self.date}>"
+      else
+        "<#{self.class} empty>"
+      end
+    end
+  end
+
+  class Account < Hashie::Mash
+  end
+
+  class Calendar < Hashie::Mash
+  end
+
+  class Channel < Hashie::Mash
+  end
+
+  class Event < Hashie::Mash
+    include Hashie::Extensions::Coercion
+
+    coerce_key :start, DateOrTime
+    coerce_key :end, DateOrTime
+  end
+
+  class PagedEventsResult < Hashie::Mash
+    include Hashie::Extensions::Coercion
+
+    coerce_key :events, Array[Event]
+  end
+end

data/lib/cronofy/version.rb

@@ -1,3 +1,3 @@
 module Cronofy
-  VERSION = "0.0.5"
+  VERSION = "0.1.0".freeze
 end

data/spec/lib/cronofy/auth_spec.rb

@@ -0,0 +1,123 @@
+require_relative '../../spec_helper'
+
+describe Cronofy::Auth do
+  let(:client_id) { 'client_id_123' }
+  let(:client_secret) { 'client_secret_456' }
+
+  let(:code) { 'code_789' }
+  let(:redirect_uri) { 'http://red.ire.ct/Uri' }
+  let(:access_token) { 'access_token_123' }
+  let(:refresh_token) { 'refresh_token_456' }
+
+  let(:new_access_token) { "new_access_token_2342" }
+  let(:new_refresh_token) { "new_refresh_token_7898" }
+  let(:expires_in) { 10000 }
+  let(:scope) { 'read_events list_calendars create_event' }
+
+  before(:all) do
+    WebMock.reset!
+    WebMock.disable_net_connect!(allow_localhost: true)
+  end
+
+  let(:response_status) { 200 }
+
+  before(:each) do
+    stub_request(:post, "https://api.cronofy.com/oauth/token")
+      .with(
+        body: {
+          client_id: client_id,
+          client_secret: client_secret,
+          grant_type: "refresh_token",
+          refresh_token: refresh_token,
+        },
+        headers: {
+          'Content-Type' => 'application/x-www-form-urlencoded',
+          'User-Agent' => "Cronofy Ruby #{Cronofy::VERSION}",
+        }
+      )
+      .to_return(
+        status: response_status,
+        body: {
+          access_token: new_access_token,
+          token_type: 'bearer',
+          expires_in: expires_in,
+          refresh_token: new_refresh_token,
+          scope: scope,
+        }.to_json,
+        headers: {
+          "Content-Type" => "application/json; charset=utf-8"
+        }
+      )
+
+    stub_request(:post, "https://app.cronofy.com/oauth/token")
+      .with(
+        body: {
+          client_id: client_id,
+          client_secret: client_secret,
+          code: code,
+          grant_type: "authorization_code",
+          redirect_uri: redirect_uri,
+        },
+        headers: {
+          'Content-Type' => 'application/x-www-form-urlencoded',
+          'User-Agent' => "Cronofy Ruby #{Cronofy::VERSION}",
+        }
+      )
+      .to_return(
+        status: response_status,
+        body: {
+          access_token: new_access_token,
+          token_type: 'bearer',
+          expires_in: expires_in,
+          refresh_token: new_refresh_token,
+          scope: scope,
+        }.to_json,
+        headers: {
+          "Content-Type" => "application/json; charset=utf-8"
+        }
+      )
+  end
+
+  shared_examples 'an authorization request' do
+    context 'when succeeds' do
+      it 'returns a correct Credentials object' do
+        expect(subject.access_token).to eq new_access_token
+        expect(subject.expires_in).to eq expires_in
+        expect(subject.refresh_token).to eq new_refresh_token
+        expect(subject.scope).to eq scope
+      end
+    end
+
+    context 'when fails' do
+      context 'with 400' do
+        let(:response_status) { 400 }
+
+        it 'throws BadRequestError' do
+          expect{ subject }.to raise_error(Cronofy::BadRequestError)
+        end
+      end
+
+      context 'with unrecognized code' do
+        let(:response_status) { 418 }
+
+        it 'throws Unknown error' do
+          expect{ subject }.to raise_error(Cronofy::UnknownError)
+        end
+      end
+    end
+  end
+
+  describe '#get_token_from_code' do
+    subject { Cronofy::Auth.new(client_id, client_secret).get_token_from_code(code, redirect_uri) }
+
+    it_behaves_like 'an authorization request'
+  end
+
+  describe '#refresh!' do
+    subject do
+      Cronofy::Auth.new(client_id, client_secret, access_token, refresh_token).refresh!
+    end
+
+    it_behaves_like 'an authorization request'
+  end
+end

data/spec/lib/cronofy/client_spec.rb

@@ -0,0 +1,519 @@
+
+require_relative '../../spec_helper'
+
+describe Cronofy::Client do
+  before(:all) do
+    WebMock.reset!
+    WebMock.disable_net_connect!(allow_localhost: true)
+  end
+
+  let(:token) { 'token_123' }
+  let(:base_request_headers) do
+    {
+      "Authorization" => "Bearer #{token}",
+      "User-Agent" => "Cronofy Ruby #{::Cronofy::VERSION}",
+    }
+  end
+
+  let(:json_request_headers) do
+    base_request_headers.merge("Content-Type" => "application/json; charset=utf-8")
+  end
+
+  let(:request_headers) do
+    base_request_headers
+  end
+
+  let(:request_body) { nil }
+
+  let(:client) do
+    Cronofy::Client.new(
+      client_id: 'client_id_123',
+      client_secret: 'client_secret_456',
+      access_token: token,
+      refresh_token: 'refresh_token_456',
+    )
+  end
+
+  let(:correct_response_headers) do
+    { 'Content-Type' => 'application/json; charset=utf-8' }
+  end
+
+  shared_examples 'a Cronofy request with mapped return value' do
+    it 'returns the correct response when no error' do
+      stub_request(method, request_url)
+        .with(headers: request_headers,
+              body: request_body)
+        .to_return(status: correct_response_code,
+                   headers: correct_response_headers,
+                   body: correct_response_body.to_json)
+
+      expect(subject).to eq correct_mapped_result
+    end
+  end
+
+  shared_examples 'a Cronofy request' do
+    it "doesn't raise an error when response is correct" do
+      stub_request(method, request_url)
+        .with(headers: request_headers,
+              body: request_body)
+        .to_return(status: correct_response_code,
+                   headers: correct_response_headers,
+                   body: correct_response_body.to_json)
+
+      expect{ subject }.not_to raise_error
+    end
+
+    it 'raises AuthenticationFailureError on 401s' do
+      stub_request(method, request_url)
+        .with(headers: request_headers,
+              body: request_body)
+        .to_return(status: 401,
+                   headers: correct_response_headers,
+                   body: correct_response_body.to_json)
+      expect{ subject }.to raise_error(Cronofy::AuthenticationFailureError)
+    end
+
+    it 'raises AuthorizationFailureError on 403s' do
+      stub_request(method, request_url)
+        .with(headers: request_headers,
+              body: request_body)
+        .to_return(status: 403,
+                   headers: correct_response_headers,
+                   body: correct_response_body.to_json)
+      expect{ subject }.to raise_error(Cronofy::AuthorizationFailureError)
+    end
+
+    it 'raises NotFoundError on 404s' do
+      stub_request(method, request_url)
+        .with(headers: request_headers,
+              body: request_body)
+        .to_return(status: 404,
+                   headers: correct_response_headers,
+                   body: correct_response_body.to_json)
+      expect{ subject }.to raise_error(::Cronofy::NotFoundError)
+    end
+
+    it 'raises InvalidRequestError on 422s' do
+      stub_request(method, request_url)
+        .with(headers: request_headers,
+              body: request_body)
+        .to_return(status: 422,
+                   headers: correct_response_headers,
+                   body: correct_response_body.to_json)
+      expect{ subject }.to raise_error(::Cronofy::InvalidRequestError)
+    end
+
+    it 'raises AuthenticationFailureError on 401s' do
+      stub_request(method, request_url)
+        .with(headers: request_headers,
+              body: request_body)
+        .to_return(status: 429,
+                   headers: correct_response_headers,
+                   body: correct_response_body.to_json)
+      expect{ subject }.to raise_error(::Cronofy::TooManyRequestsError)
+    end
+  end
+
+  describe '#list_calendars' do
+    let(:request_url) { 'https://api.cronofy.com/v1/calendars' }
+    let(:method) { :get }
+    let(:correct_response_code) { 200 }
+    let(:correct_response_body) do
+      {
+        "calendars" => [
+                        {
+                          "provider_name" => "google",
+                          "profile_name" => "example@cronofy.com",
+                          "calendar_id" => "cal_n23kjnwrw2_jsdfjksn234",
+                          "calendar_name" => "Home",
+                          "calendar_readonly" => false,
+                          "calendar_deleted" => false
+                        },
+                        {
+                          "provider_name" => "google",
+                          "profile_name" => "example@cronofy.com",
+                          "calendar_id" => "cal_n23kjnwrw2_n1k323nkj23",
+                          "calendar_name" => "Work",
+                          "calendar_readonly" => true,
+                          "calendar_deleted" => true
+                        },
+                        {
+                          "provider_name" => "apple",
+                          "profile_name" => "example@cronofy.com",
+                          "calendar_id" => "cal_n23kjnwrw2_3nkj23wejk1",
+                          "calendar_name" => "Bank Holidays",
+                          "calendar_readonly" => true,
+                          "calendar_deleted" => false
+                        }
+                       ]
+      }
+    end
+
+    let(:correct_mapped_result) do
+      correct_response_body["calendars"].map { |cal| Cronofy::Calendar.new(cal) }
+    end
+
+    subject { client.list_calendars }
+
+    it_behaves_like 'a Cronofy request'
+    it_behaves_like 'a Cronofy request with mapped return value'
+  end
+
+  describe 'Events' do
+    describe '#create_or_update_event' do
+      let(:calendar_id) { 'calendar_id_123'}
+      let(:request_url) { "https://api.cronofy.com/v1/calendars/#{calendar_id}/events" }
+      let(:method) { :post }
+      let(:request_headers) { json_request_headers }
+      let(:event) do
+        {
+          :event_id => "qTtZdczOccgaPncGJaCiLg",
+          :summary => "Board meeting",
+          :description => "Discuss plans for the next quarter.",
+          :start => start_datetime,
+          :end => end_datetime,
+          :location => {
+            :description => "Board room"
+          }
+        }
+      end
+      let(:request_body) do
+        hash_including(:event_id => "qTtZdczOccgaPncGJaCiLg",
+                       :summary => "Board meeting",
+                       :description => "Discuss plans for the next quarter.",
+                       :start => start_datetime_string,
+                       :end => end_datetime_string,
+                       :location => {
+                         :description => "Board room"
+                       })
+      end
+      let(:correct_response_code) { 202 }
+      let(:correct_response_body) { nil }
+
+      subject { client.create_or_update_event(calendar_id, event) }
+
+      context 'when start/end are Times' do
+        let(:start_datetime) { Time.utc(2014, 8, 5, 15, 30, 0) }
+        let(:end_datetime) { Time.utc(2014, 8, 5, 17, 0, 0) }
+        let(:start_datetime_string) { "2014-08-05T15:30:00Z" }
+        let(:end_datetime_string) { "2014-08-05T17:00:00Z" }
+
+        it_behaves_like 'a Cronofy request'
+      end
+    end
+
+    describe '#read_events' do
+      before do
+        stub_request(method, request_url)
+          .with(headers: request_headers,
+                body: request_body)
+          .to_return(status: correct_response_code,
+                     headers: correct_response_headers,
+                     body: correct_response_body.to_json)
+
+        stub_request(:get, next_page_url)
+          .with(headers: request_headers)
+          .to_return(status: correct_response_code,
+            headers: correct_response_headers,
+            body: next_page_body.to_json)
+      end
+
+
+      let(:request_url_prefix) { 'https://api.cronofy.com/v1/events' }
+      let(:method) { :get }
+      let(:correct_response_code) { 200 }
+      let(:next_page_url) do
+        "https://next.page.com/08a07b034306679e"
+      end
+
+      let(:params) { Hash.new }
+      let(:request_url) { request_url_prefix + "?tzid=Etc/UTC" }
+
+      let(:correct_response_body) do
+        {
+          'pages' => {
+            'current' => 1,
+            'total' => 2,
+            'next_page' => next_page_url
+          },
+          'events' => [
+                       {
+                         'calendar_id' => 'cal_U9uuErStTG@EAAAB_IsAsykA2DBTWqQTf-f0kJw',
+                         'event_uid' => 'evt_external_54008b1a4a41730f8d5c6037',
+                         'summary' => 'Company Retreat',
+                         'description' => '',
+                         'start' => '2014-09-06',
+                         'end' => '2014-09-08',
+                         'deleted' => false
+                       },
+                       {
+                         'calendar_id' => 'cal_U9uuErStTG@EAAAB_IsAsykA2DBTWqQTf-f0kJw',
+                         'event_uid' => 'evt_external_54008b1a4a41730f8d5c6038',
+                         'summary' => 'Dinner with Laura',
+                         'description' => '',
+                         'start' => '2014-09-13T19:00:00Z',
+                         'end' => '2014-09-13T21:00:00Z',
+                         'deleted' => false,
+                         'location' => {
+                           'description' => 'Pizzeria'
+                         }
+                       }
+                      ]
+        }
+      end
+
+      let(:next_page_body) do
+        {
+          'pages' => {
+            'current' => 2,
+            'total' => 2,
+          },
+          'events' => [
+                       {
+                         'calendar_id' => 'cal_U9uuErStTG@EAAAB_IsAsykA2DBTWqQTf-f0kJw',
+                         'event_uid' => 'evt_external_54008b1a4a4173023402934d',
+                         'summary' => 'Company Retreat Extended',
+                         'description' => '',
+                         'start' => '2014-09-06',
+                         'end' => '2014-09-08',
+                         'deleted' => false
+                       },
+                       {
+                         'calendar_id' => 'cal_U9uuErStTG@EAAAB_IsAsykA2DBTWqQTf-f0kJw',
+                         'event_uid' => 'evt_external_54008b1a4a41198273921312',
+                         'summary' => 'Dinner with Paul',
+                         'description' => '',
+                         'start' => '2014-09-13T19:00:00Z',
+                         'end' => '2014-09-13T21:00:00Z',
+                         'deleted' => false,
+                         'location' => {
+                           'description' => 'Cafe'
+                         }
+                       }
+                      ]
+        }
+      end
+
+      let(:correct_mapped_result) do
+        first_page_events = correct_response_body['events'].map { |event| Cronofy::Event.new(event) }
+        second_page_events = next_page_body['events'].map { |event| Cronofy::Event.new(event) }
+
+        first_page_events + second_page_events
+      end
+
+      subject do
+        # By default force evaluation
+        client.read_events(params).to_a
+      end
+
+      context 'when all params are passed' do
+        let(:params) do
+          {
+            from: Time.new(2014, 9, 1, 0, 0, 1, '+00:00'),
+            to: Time.new(2014, 10, 1, 0, 0, 1, '+00:00'),
+            tzid: 'Etc/UTC',
+            include_deleted: false,
+            include_moved: true,
+            last_modified: Time.new(2014, 8, 1, 0, 0, 1, '+00:00')
+          }
+        end
+        let(:request_url) do
+          "#{request_url_prefix}?from=2014-09-01T00:00:01Z" \
+          "&to=2014-10-01T00:00:01Z&tzid=Etc/UTC&include_deleted=false" \
+          "&include_moved=true&last_modified=2014-08-01T00:00:01Z"
+        end
+
+        it_behaves_like 'a Cronofy request'
+        it_behaves_like 'a Cronofy request with mapped return value'
+      end
+
+      context 'when some params are passed' do
+        let(:params) do
+          {
+            from: Time.new(2014, 9, 1, 0, 0, 1, '+00:00'),
+            include_deleted: false,
+          }
+        end
+        let(:request_url) do
+          "#{request_url_prefix}?from=2014-09-01T00:00:01Z" \
+          "&tzid=Etc/UTC&include_deleted=false"
+        end
+
+        it_behaves_like 'a Cronofy request'
+        it_behaves_like 'a Cronofy request with mapped return value'
+      end
+
+      context "when unknown flags are passed" do
+        let(:params) do
+          {
+            unknown_bool: true,
+            unknown_number: 5,
+            unknown_string: "foo-bar-baz",
+          }
+        end
+
+        let(:request_url) do
+          "#{request_url_prefix}?tzid=Etc/UTC" \
+          "&unknown_bool=true" \
+          "&unknown_number=5" \
+          "&unknown_string=foo-bar-baz"
+        end
+
+        it_behaves_like 'a Cronofy request'
+        it_behaves_like 'a Cronofy request with mapped return value'
+      end
+
+      context "next page not found" do
+        before do
+          stub_request(:get, next_page_url)
+            .with(headers: request_headers)
+            .to_return(status: 404,
+              headers: correct_response_headers)
+        end
+
+        it "raises an error" do
+          expect{ subject }.to raise_error(::Cronofy::NotFoundError)
+        end
+      end
+
+      context "only first event" do
+        before do
+          # Ensure an error if second page is requested
+          stub_request(:get, next_page_url)
+            .with(headers: request_headers)
+            .to_return(status: 404,
+              headers: correct_response_headers)
+        end
+
+        let(:first_event) do
+          Cronofy::Event.new(correct_response_body["events"].first)
+        end
+
+        subject do
+          client.read_events(params).first
+        end
+
+        it "returns the first event from the first page" do
+          expect(subject).to eq(first_event)
+        end
+      end
+    end
+
+    describe '#delete_event' do
+      let(:calendar_id) { 'calendar_id_123'}
+      let(:request_url) { "https://api.cronofy.com/v1/calendars/#{calendar_id}/events" }
+      let(:event_id) { 'event_id_456' }
+      let(:method) { :delete }
+      let(:request_headers) { json_request_headers }
+      let(:request_body) { { :event_id => event_id } }
+      let(:correct_response_code) { 202 }
+      let(:correct_response_body) { nil }
+
+      subject { client.delete_event(calendar_id, event_id) }
+
+      it_behaves_like 'a Cronofy request'
+    end
+  end
+
+  describe 'Channels' do
+    let(:request_url) { 'https://api.cronofy.com/v1/channels' }
+
+    describe '#create_channel' do
+      let(:method) { :post }
+      let(:callback_url) { 'http://call.back/url' }
+      let(:request_headers) { json_request_headers }
+      let(:request_body) { hash_including(:callback_url => callback_url) }
+
+      let(:correct_response_code) { 200 }
+      let(:correct_response_body) do
+        {
+          'channel' => {
+            'channel_id' => 'channel_id_123',
+            'callback_url' => ENV['CALLBACK_URL'],
+            'filters' => {}
+          }
+        }
+      end
+
+      let(:correct_mapped_result) do
+        Cronofy::Channel.new(correct_response_body["channel"])
+      end
+
+      subject { client.create_channel(callback_url) }
+
+      it_behaves_like 'a Cronofy request'
+      it_behaves_like 'a Cronofy request with mapped return value'
+    end
+
+    describe '#list_channels' do
+      let(:method) { :get }
+
+      let(:correct_response_code) { 200 }
+      let(:correct_response_body) do
+        {
+          'channels' => [
+            {
+              'channel_id' => 'channel_id_123',
+              'callback_url' => 'http://call.back/url',
+              'filters' => {}
+            },
+            {
+              'channel_id' => 'channel_id_456',
+              'callback_url' => 'http://call.back/url2',
+              'filters' => {}
+            }
+          ]
+        }
+      end
+
+      let(:correct_mapped_result) do
+        correct_response_body["channels"].map { |ch| Cronofy::Channel.new(ch) }
+      end
+
+      subject { client.list_channels }
+
+      it_behaves_like 'a Cronofy request'
+      it_behaves_like 'a Cronofy request with mapped return value'
+    end
+
+    describe '#close_channel' do
+      let(:channel_id) { "chn_1234567890" }
+      let(:method) { :delete }
+      let(:request_url) { "https://api.cronofy.com/v1/channels/#{channel_id}" }
+
+      let(:correct_response_code) { 202 }
+      let(:correct_response_body) { nil }
+
+      subject { client.close_channel(channel_id) }
+
+      it_behaves_like 'a Cronofy request'
+    end
+  end
+
+  describe "Account" do
+    let(:request_url) { "https://api.cronofy.com/v1/account" }
+
+    describe "#account" do
+      let(:method) { :get }
+
+      let(:correct_response_code) { 200 }
+      let(:correct_response_body) do
+        {
+          "account" => {
+            "account_id" => "acc_id_123",
+            "email" => "foo@example.com",
+          }
+        }
+      end
+
+      let(:correct_mapped_result) do
+        Cronofy::Account.new(correct_response_body["account"])
+      end
+
+      subject { client.account }
+
+      it_behaves_like "a Cronofy request"
+      it_behaves_like "a Cronofy request with mapped return value"
+    end
+  end
+end