cronofy 0.31.2 → 0.36.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ac0a6d45f99b6fc43669a1c8bfae0ae9c040d05ca200c9638cf535fcff3ee71
-  data.tar.gz: 44ce008bc883118eda39dc75a486834083e71bfb37ff2716629db2d9019578ed
+  metadata.gz: e085c07872654ff1e239fcdce81beeb212856ce2ff7d9c3168e71c3f2778e6d5
+  data.tar.gz: 0ce2421b8e0aa2b39c76a72eaeeddd4a474573690a6d3ccdf437c1d57dbf0028
 SHA512:
-  metadata.gz: e9e8ff68fbfa8a4fe9582a259dd885f3d8cd155ec455fccbdab736acc3fdfae655ce2ec17eeb81a954774a6c311172c28d0be24721179ef408b08bb060b3fe9d
-  data.tar.gz: 3f0632f1a75377bcbcca43fbe03557c91dff7492ed1122688bd160e7c5227c0620c0b8765f46cbac54fe53aafb8fd6d2b224fbb07beee41d7d67d3358e7a3b73
+  metadata.gz: 8df4506dfe09d4454c8901e312dbda5d03a27d1ec8a0cb28506327f8802a691fa5abf00abd8028ee6f04d9c09eae73f3a0ea417409e7164b2fa1e0e4530bb2a3
+  data.tar.gz: fe07ce98f72073fa8c0254510a089fbf04d37d5da2a12b7c12d1de77e19e1666c394d14aca6d32d96ad2ee7093b1e276ad5571f0ffcfd615a4d269e70031e07b

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+## [0.36.0]
+
+ * Add support for Available Periods [#81]
+
+## [0.35.0]
+
+ * Add specific errors for network issues [#77]
+
+## [0.34.0]
+
+ * Support removing a participant from a Smart Invite [#75]
+
+## [0.33.0]
+
+ * Support listing Availability Rules [#74]
+
+## [0.32.0]
+
+ * Support Availability Rules and Scheduling Conversations [#64]
+
 ## [0.31.2]
 
  * Support parsing new Availability response formats [#73]
@@ -142,6 +162,11 @@
 [0.31.0]: https://github.com/cronofy/cronofy-ruby/releases/tag/v0.31.0
 [0.31.1]: https://github.com/cronofy/cronofy-ruby/releases/tag/v0.31.1
 [0.31.2]: https://github.com/cronofy/cronofy-ruby/releases/tag/v0.31.2
+[0.32.0]: https://github.com/cronofy/cronofy-ruby/releases/tag/v0.32.0
+[0.33.0]: https://github.com/cronofy/cronofy-ruby/releases/tag/v0.33.0
+[0.34.0]: https://github.com/cronofy/cronofy-ruby/releases/tag/v0.34.0
+[0.35.0]: https://github.com/cronofy/cronofy-ruby/releases/tag/v0.35.0
+[0.36.0]: https://github.com/cronofy/cronofy-ruby/releases/tag/v0.36.0
 
 [#13]: https://github.com/cronofy/cronofy-ruby/pull/13
 [#16]: https://github.com/cronofy/cronofy-ruby/pull/16
@@ -174,6 +199,11 @@
 [#59]: https://github.com/cronofy/cronofy-ruby/pull/59
 [#60]: https://github.com/cronofy/cronofy-ruby/pull/60
 [#62]: https://github.com/cronofy/cronofy-ruby/pull/62
+[#64]: https://github.com/cronofy/cronofy-ruby/pull/64
 [#69]: https://github.com/cronofy/cronofy-ruby/pull/69
 [#72]: https://github.com/cronofy/cronofy-ruby/pull/72
 [#73]: https://github.com/cronofy/cronofy-ruby/pull/73
+[#74]: https://github.com/cronofy/cronofy-ruby/pull/74
+[#75]: https://github.com/cronofy/cronofy-ruby/pull/75
+[#77]: https://github.com/cronofy/cronofy-ruby/pull/77
+[#81]: https://github.com/cronofy/cronofy-ruby/pull/81

data/cronofy.gemspec

@@ -23,5 +23,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", ">=  1.6", "< 3"
   spec.add_development_dependency "rake",    "~> 10.0"
   spec.add_development_dependency "rspec",   "~>  3.2"
-  spec.add_development_dependency "webmock", "~>  1.21"
+  spec.add_development_dependency "webmock", "~>  3.9.1"
 end

data/lib/cronofy/client.rb

@@ -1,3 +1,5 @@
+require 'uri'
+
 module Cronofy
   # Public: Primary class for interacting with the Cronofy API.
   class Client
@@ -1323,6 +1325,32 @@ module Cronofy
       parse_json(SmartInviteResponse, nil, response)
     end
 
+    # Public: Removes an individual recipient from a multiple recipient smart invite
+    #
+    # smart_invite_id - A String uniquely identifying the event for your
+    #                  application (note: this is NOT an ID generated
+    #                  by Cronofy).
+    #
+    # recipient       - A Hash containing the recipient to be removed
+    #                   :email      - A String for the email address of
+    #                                 the recipient to remove.
+    #
+    # See https://docs.cronofy.com/developers/api-alpha/smart-invites/multiple-recipients/#remove-invite-recipient
+    # for reference.
+    #
+    # Returns a SmartInviteResponse
+    #
+    # Raises Cronofy::CredentialsMissingError if no credentials available.
+    # Raises Cronofy::InvalidRequestError if the request contains invalid
+    # parameters.
+    # Raises Cronofy::TooManyRequestsError if the request exceeds the rate
+    # limits for the application.
+    def remove_recipient_smart_invite(body={})
+      body[:method] = 'remove'
+      response = wrapped_request { api_key!.post("/v1/smart_invites", json_request_args(body)) }
+      parse_json(SmartInviteResponse, nil, response)
+    end
+
     # Public: Gets the details for a smart invite.
     #
     # smart_invite_id  - A String uniquely identifying the event for your
@@ -1344,7 +1372,6 @@ module Cronofy
       parse_json(SmartInviteResponse, nil, response)
     end
 
-
     # Public: Creates an element_token to pass to a UI Element
     #
     # options     - A Hash of options for the token
@@ -1371,6 +1398,225 @@ module Cronofy
       parse_json(ElementToken, "element_token", response)
     end
 
+    # Public: Creates or updates an AvailabilityRule.
+    #
+    # availability_rule_id - A String uniquely identifying the availability rule
+    #                        for the authenticated user in your application
+    #                        (note: this is NOT an ID generated by Cronofy).
+    # tzid            - The time zone identifier for the rule.
+    # calendar_ids    - An optional array of calendar_ids that should impact the
+    #                   user's availability.
+    # weekly_periods  - An array of objects describing a weekly recurring available period
+    #                 :day        - A String for the week day
+    #                 :start_time - A String for 24hr time that period starts eg: 09:30
+    #                 :end_time   - A String for 24hr time that period ends eg: 17:30
+    # Examples
+    #
+    #   client.upsert_availability_rule(
+    #     availability_rule_id: "qTtZdczOccgaPncGJaCiLg",
+    #     tzid: "America/Chicago",
+    #     calendar_ids: [
+    #       "cal_n23kjnwrw2_jsdfjksn234"
+    #     ],
+    #     weekly_periods: [
+    #       {
+    #         day: "monday",
+    #         start_time: "09:30",
+    #         end_time: "12:30",
+    #       },
+    #       {
+    #         day: "tuesday",
+    #         start_time: "09:30",
+    #         end_time: "12:30",
+    #       }
+    #     ]
+    #   )
+    #
+    # See http://www.cronofy.com/developers/alpha/api#availability_rules for reference.
+    #
+    # Returns an AvailabilityRuleResponse.
+    #
+    # Raises Cronofy::CredentialsMissingError if no credentials available.
+    # Raises Cronofy::InvalidRequestError if the request contains invalid
+    # parameters.
+    # Raises Cronofy::TooManyRequestsError if the request exceeds the rate
+    # limits for the application.
+    def upsert_availability_rule(body)
+      response = wrapped_request { post("/v1/availability_rules", body) }
+      parse_json(AvailabilityRule, 'availability_rule', response)
+    end
+
+    # Public: Gets an AvailabilityRule.
+    #
+    # availability_rule_id - A String uniquely identifying the availability rule
+    #                        for the authenticated user in your application
+    #
+    # Returns an AvailabilityRuleResponse.
+    #
+    # Raises Cronofy::CredentialsMissingError if no credentials available.
+    # Raises Cronofy::InvalidRequestError if the request contains invalid
+    # parameters.
+    # Raises Cronofy::TooManyRequestsError if the request exceeds the rate
+    # limits for the application.
+    def get_availability_rule(availability_rule_id)
+      response = wrapped_request { get("/v1/availability_rules/#{availability_rule_id}") }
+      parse_json(AvailabilityRule, 'availability_rule', response)
+    end
+
+    # Public: Gets all AvailabilityRules for an account.
+    #
+    # Returns an array of AvailabilityRules.
+    #
+    # Raises Cronofy::CredentialsMissingError if no credentials available.
+    # Raises Cronofy::InvalidRequestError if the request contains invalid
+    # parameters.
+    # Raises Cronofy::TooManyRequestsError if the request exceeds the rate
+    # limits for the application.
+    def get_availability_rules
+      response = wrapped_request { get("/v1/availability_rules") }
+      parse_collection(AvailabilityRule, 'availability_rules', response)
+    end
+
+    # Public: Deletes an AvailabilityRule.
+    #
+    # availability_rule_id - A String uniquely identifying the availability rule
+    #                        for the authenticated user in your application
+    #
+    # Returns nothing.
+    #
+    # Raises Cronofy::CredentialsMissingError if no credentials available.
+    # Raises Cronofy::InvalidRequestError if the request contains invalid
+    # parameters.
+    # Raises Cronofy::TooManyRequestsError if the request exceeds the rate
+    # limits for the application.
+    def delete_availability_rule(availability_rule_id)
+      wrapped_request { delete("/v1/availability_rules/#{availability_rule_id}") }
+      nil
+    end
+
+    # Public: Creates or updates an AvailablePeriod.
+    #
+    # available_period_id - A String uniquely identifying the available period
+    #                       for the authenticated user in your application
+    #                       (note: this is NOT an ID generated by Cronofy).
+    # body                - A Hash describing the available period with
+    #                       symbolized keys:
+    #                       :start - A String (ISO-8601 date/time)
+    #                       :end   - A String (ISO-8601 date/time)
+    #
+    # See https://docs.cronofy.com/developers/api/scheduling/available-periods/upsert/
+    # for reference.
+    #
+    # Returns nothing.
+    #
+    # Raises Cronofy::CredentialsMissingError if no credentials available.
+    # Raises Cronofy::InvalidRequestError if the request contains invalid
+    # parameters.
+    # Raises Cronofy::TooManyRequestsError if the request exceeds the rate
+    # limits for the application.
+    def upsert_available_period(available_period_id, body)
+      payload = body.merge(available_period_id: available_period_id)
+      wrapped_request { post("/v1/available_periods", payload) }
+      nil
+    end
+
+    # Public: Gets all AvailablePeriods for an account.
+    #
+    # options - The Hash options used to refine the selection (default: {}):
+    #           :from            - The minimum Date from which to return periods
+    #                              (optional).
+    #           :to              - The Date to return periods up until (optional).
+    #           :tzid            - A String representing a known time zone
+    #                              identifier from the IANA Time Zone Database
+    #                              (default: Etc/UTC).
+    #           :localized_times - A Boolean specifying whether the start and
+    #                              end times should be returned with any
+    #                              available localization information
+    #                              (optional).
+    #
+    # Returns an array of AvailablePeriods.
+    #
+    # Raises Cronofy::CredentialsMissingError if no credentials available.
+    # Raises Cronofy::InvalidRequestError if the request contains invalid
+    # parameters.
+    # Raises Cronofy::TooManyRequestsError if the request exceeds the rate
+    # limits for the application.
+    def get_available_periods(options={})
+      query = {}
+      query[:from] = to_iso8601(options[:from]) if options[:from]
+      query[:to] = to_iso8601(options[:to]) if options[:to]
+      query[:tzid] = options[:tzid] if options[:tzid]
+      query[:localized_times] = options[:localized_times] if options[:localized_times]
+      if query.any?
+        query_string = "?#{URI.encode_www_form(query)}"
+      end
+
+      response = wrapped_request { get("/v1/available_periods#{query_string}") }
+      parse_collection(AvailablePeriod, 'available_periods', response)
+    end
+
+    # Public: Deletes an AvailablePeriod.
+    #
+    # available_period_id - A String uniquely identifying the available period
+    #                      for the authenticated user in your application
+    #
+    # Returns nothing.
+    #
+    # Raises Cronofy::CredentialsMissingError if no credentials available.
+    # Raises Cronofy::InvalidRequestError if the request contains invalid
+    # parameters.
+    # Raises Cronofy::TooManyRequestsError if the request exceeds the rate
+    # limits for the application.
+    def delete_available_period(available_period_id)
+      wrapped_request { delete("/v1/available_periods", available_period_id: available_period_id) }
+      nil
+    end
+
+    # Public: Creates a scheduling conversation
+    #
+    # pre release end-point documentation to follow
+    #
+    def create_scheduling_conversation(body)
+      response = wrapped_request { post("/v1/scheduling_conversations", body) }
+      parse_json(SchedulingConversation, 'scheduling_conversation', response)
+    end
+
+    # Public: Creates a scheduling conversation
+    #
+    # pre release end-point documentation to follow
+    #
+    def get_scheduling_conversation(id)
+      response = wrapped_request { get("/v1/scheduling_conversations/#{id}") }
+      parse_json(SchedulingConversation, 'scheduling_conversation', response)
+    end
+
+    # Public: Looks up a scheduling conversation with a token returned by a redirect
+    #
+    # pre release end-point documentation to follow
+    #
+    def lookup_scheduling_conversation(token)
+      response = wrapped_request { get("/v1/scheduling_conversations?token=#{token}") }
+      parse_json(SchedulingConversationResponse, nil, response)
+    end
+
+    # Public: List available slots for a scheduling conversation
+    #
+    # pre release end-point documentation to follow
+    #
+    def list_scheduling_conversation_participant_slots(url)
+      response = wrapped_request { get(url) }
+      parse_collection(SchedulingConversationSlot, "slots", response )
+    end
+
+    # Public: Choose one or more slots for a scheduling conversation
+    #
+    # pre release end-point documentation to follow
+    #
+    def select_scheduling_conversation_participant_slots(url, args)
+      response = wrapped_request { post(url, args)}
+      parse_json(SchedulingConversation, 'scheduling_conversation', response)
+    end
+
     private
 
     def translate_available_periods(periods)

data/lib/cronofy/errors.rb

@@ -68,6 +68,18 @@ module Cronofy
   class PaymentRequiredError < APIError
   end
 
+  class ServiceUnreachableError < APIError
+  end
+
+  class BadGatewayError < ServiceUnreachableError
+  end
+
+  class ServiceUnavailableError < ServiceUnreachableError
+  end
+
+  class GatewayTimeoutError < ServiceUnreachableError
+  end
+
   class UnknownError < APIError
   end
 
@@ -83,6 +95,9 @@ module Cronofy
       423 => AccountLockedError,
       429 => TooManyRequestsError,
       500 => ServerError,
+      502 => BadGatewayError,
+      503 => ServiceUnavailableError,
+      504 => GatewayTimeoutError,
     }.freeze
 
     def self.map_error(error)

data/lib/cronofy/types.rb

@@ -387,4 +387,30 @@ module Cronofy
 
   class ElementToken < CronofyMash
   end
+
+  class SchedulingConversation < CronofyMash
+  end
+
+  class SchedulingConversationResponse < CronofyMash
+    coerce_key :participant, Participant
+    coerce_key :scheduling_conversation, SchedulingConversation
+  end
+
+  class SchedulingConversationSlot < CronofyMash
+    coerce_key :start, EventTime
+    coerce_key :end, EventTime
+  end
+
+  class WeeklyPeriod < CronofyMash
+  end
+
+  module WeeklyPeriodEnumerable
+    def self.coerce(values)
+      values.map { |v| WeeklyPeriod.new(v) }
+    end
+  end
+
+  class AvailabilityRule < CronofyMash
+    coerce_key :weekly_periods, WeeklyPeriodEnumerable
+  end
 end

data/lib/cronofy/version.rb

@@ -1,3 +1,3 @@
 module Cronofy
-  VERSION = "0.31.2".freeze
+  VERSION = "0.36.0".freeze
 end

data/spec/lib/cronofy/client_spec.rb

@@ -2630,6 +2630,67 @@ describe Cronofy::Client do
 
   end
 
+  describe "Remove Recipient Smart Invite", test: true do
+    let(:request_url) { "https://api.cronofy.com/v1/smart_invites" }
+    let(:method) { :post }
+
+    let(:request_headers) do
+      {
+        "Authorization" => "Bearer #{client_secret}",
+        "User-Agent" => "Cronofy Ruby #{::Cronofy::VERSION}",
+        "Content-Type" => "application/json; charset=utf-8",
+      }
+    end
+
+    let(:client_id) { 'example_id' }
+    let(:client_secret) { 'example_secret' }
+
+    let(:client) do
+      Cronofy::Client.new(
+        client_id: client_id,
+        client_secret: client_secret,
+      )
+    end
+
+    let(:args) do
+      {
+        smart_invite_id: "qTtZdczOccgaPncGJaCiLg",
+        recipient: {
+          email: "example@example.com"
+        }
+      }
+    end
+
+    let(:request_body) do
+      {
+        method: 'remove',
+        smart_invite_id: "qTtZdczOccgaPncGJaCiLg",
+        recipient: {
+          email: "example@example.com"
+        }
+      }
+    end
+    let(:correct_response_code) { 202 }
+    let(:correct_response_body) do
+      request_body.merge({
+        attachments: {
+          removed: {
+            email: "example@example.com"
+          }
+        }
+      })
+    end
+
+    let(:correct_mapped_result) do
+      Cronofy::SmartInviteResponse.new(correct_response_body)
+    end
+
+    subject { client.remove_recipient_smart_invite(request_body) }
+
+    it_behaves_like 'a Cronofy request'
+    it_behaves_like 'a Cronofy request with mapped return value'
+  end
+
   describe "Batch requests" do
     context "upserting an event" do
       let(:calendar_id) { 'calendar_id_123'}
@@ -2841,4 +2902,410 @@ describe Cronofy::Client do
       end
     end
   end
+
+  describe '#create_scheduling_conversation' do
+    let(:request_url) { 'https://api.cronofy.com/v1/scheduling_conversations' }
+    let(:method) { :post }
+    let(:request_body) do
+      {
+        "participants" => [
+          {
+            "participant_id" => "@grace",
+            "sub" => "acc_567236000909002",
+            "slots" => {
+              "choice_method" => "auto"
+            }
+          },
+          {
+            "participant_id" => "@karl"
+          }
+        ],
+        "required_duration" => { "minutes" => 60 },
+        "available_periods" => [
+          {
+            "start" => "2018-05-01T00:00:00Z",
+            "end" => "2018-05-08T23:59:59Z"
+          }
+        ]
+      }
+    end
+
+    let(:correct_response_code) { 200 }
+    let(:correct_response_body) do
+      {
+        "scheduling_conversation" => {
+          "scheduling_conversation_id" => "abcd1234"
+        }
+      }
+    end
+
+    let(:correct_mapped_result) do
+      Cronofy::SchedulingConversation.new(scheduling_conversation_id: "abcd1234")
+    end
+
+    subject { client.create_scheduling_conversation(request_body) }
+
+    it_behaves_like 'a Cronofy request'
+    it_behaves_like 'a Cronofy request with mapped return value'
+  end
+
+  describe '#lookup_scheduling_conversation' do
+    let(:token) { "hagsdau7g3d" }
+    let(:request_url) { "https://api.cronofy.com/v1/scheduling_conversations?token=#{token}" }
+    let(:method) { :get }
+
+    let(:correct_response_code) { 200 }
+    let(:correct_response_body) do
+      {
+        "participant" => {
+          "participant_id" => "83o38hoa"
+        },
+        "scheduling_conversation" => {
+          "scheduling_conversation_id" => "abcd1234"
+        },
+      }
+    end
+
+    let(:correct_mapped_result) do
+      Cronofy::SchedulingConversationResponse.new(
+        participant: Cronofy::Participant.new(participant_id: "83o38hoa"),
+        scheduling_conversation: Cronofy::SchedulingConversation.new(scheduling_conversation_id: "abcd1234"),
+        )
+    end
+
+    subject { client.lookup_scheduling_conversation(token) }
+
+    it_behaves_like 'a Cronofy request'
+    it_behaves_like 'a Cronofy request with mapped return value'
+  end
+
+  describe '#upsert_availability_rule' do
+    let(:request_url) { 'https://api.cronofy.com/v1/availability_rules' }
+    let(:method) { :post }
+    let(:request_body) do
+      {
+        "availability_rule_id" => "default",
+        "tzid" => "America/Chicago",
+        "calendar_ids" => [
+          "cal_n23kjnwrw2_jsdfjksn234"
+        ],
+        "weekly_periods" => [
+          {
+            "day" => "monday",
+            "start_time" => "09:30",
+            "end_time" => "16:30"
+          },
+          {
+            "day" => "wednesday",
+            "start_time" => "09:30",
+            "end_time" => "16:30"
+          }
+        ]
+      }
+    end
+
+    let(:correct_response_code) { 200 }
+    let(:correct_response_body) do
+      {
+        "availability_rule" => {
+          "availability_rule_id" => "default",
+          "tzid" => "America/Chicago",
+          "calendar_ids" => [
+            "cal_n23kjnwrw2_jsdfjksn234"
+          ],
+          "weekly_periods" => [
+            {
+              "day" => "monday",
+              "start_time" => "09:30",
+              "end_time" => "16:30"
+            },
+            {
+              "day" => "wednesday",
+              "start_time" => "09:30",
+              "end_time" => "16:30"
+            }
+          ]
+        }
+      }
+    end
+
+    let(:correct_mapped_result) do
+      Cronofy::AvailabilityRule.new(
+        availability_rule_id: request_body['availability_rule_id'],
+        tzid: request_body['tzid'],
+        calendar_ids: request_body['calendar_ids'],
+        weekly_periods: request_body['weekly_periods'].map { |wp| Cronofy::WeeklyPeriod.new(wp) },
+        )
+    end
+
+    subject { client.upsert_availability_rule(request_body) }
+
+    it_behaves_like 'a Cronofy request'
+    it_behaves_like 'a Cronofy request with mapped return value'
+  end
+
+  describe "#get_availability_rule" do
+    let(:availability_rule_id) { 'default'}
+    let(:request_url) { "https://api.cronofy.com/v1/availability_rules/#{availability_rule_id}" }
+    let(:method) { :get }
+
+    let(:correct_response_code) { 200 }
+    let(:correct_response_body) do
+      {
+        "availability_rule" => {
+          "availability_rule_id" => "default",
+          "tzid" => "America/Chicago",
+          "calendar_ids" => [
+            "cal_n23kjnwrw2_jsdfjksn234"
+          ],
+          "weekly_periods" => [
+            {
+              "day" => "monday",
+              "start_time" => "09:30",
+              "end_time" => "16:30"
+            },
+            {
+              "day" => "wednesday",
+              "start_time" => "09:30",
+              "end_time" => "16:30"
+            }
+          ]
+        }
+      }
+    end
+
+    let(:correct_mapped_result) do
+      rule = correct_response_body['availability_rule']
+      Cronofy::AvailabilityRule.new(
+        availability_rule_id: rule['availability_rule_id'],
+        tzid: rule['tzid'],
+        calendar_ids: rule['calendar_ids'],
+        weekly_periods: rule['weekly_periods'].map { |wp| Cronofy::WeeklyPeriod.new(wp) },
+        )
+    end
+
+    subject { client.get_availability_rule(availability_rule_id) }
+
+    it_behaves_like 'a Cronofy request'
+    it_behaves_like 'a Cronofy request with mapped return value'
+  end
+
+  describe "#get_availability_rules" do
+    let(:request_url) { "https://api.cronofy.com/v1/availability_rules" }
+    let(:method) { :get }
+
+    let(:correct_response_code) { 200 }
+    let(:correct_response_body) do
+      {
+        "availability_rules" => [
+          {
+            "availability_rule_id" => "default",
+            "tzid" => "America/Chicago",
+            "calendar_ids" => [
+              "cal_n23kjnwrw2_jsdfjksn234"
+            ],
+            "weekly_periods" => [
+              {
+                "day" => "monday",
+                "start_time" => "09:30",
+                "end_time" => "16:30"
+              },
+              {
+                "day" => "wednesday",
+                "start_time" => "09:30",
+                "end_time" => "16:30"
+              }
+            ]
+          }
+        ]
+      }
+    end
+
+    let(:correct_mapped_result) do
+      rule = correct_response_body['availability_rules'][0]
+
+      [
+        Cronofy::AvailabilityRule.new(
+          availability_rule_id: rule['availability_rule_id'],
+          tzid: rule['tzid'],
+          calendar_ids: rule['calendar_ids'],
+          weekly_periods: rule['weekly_periods'].map { |wp| Cronofy::WeeklyPeriod.new(wp) },
+          )
+      ]
+    end
+
+    subject { client.get_availability_rules }
+
+    it_behaves_like 'a Cronofy request'
+    it_behaves_like 'a Cronofy request with mapped return value'
+  end
+
+  describe '#delete_availability_rule' do
+    let(:availability_rule_id) { 'default'}
+    let(:request_url) { "https://api.cronofy.com/v1/availability_rules/#{availability_rule_id}" }
+    let(:method) { :delete }
+    let(:request_body) { nil }
+    let(:correct_response_code) { 202 }
+    let(:correct_response_body) { nil }
+
+    subject { client.delete_availability_rule(availability_rule_id) }
+
+    it_behaves_like 'a Cronofy request'
+  end
+
+  describe "#upsert_available_period" do
+    let(:request_url) { 'https://api.cronofy.com/v1/available_periods' }
+    let(:method) { :post }
+    let(:available_period_id) { "test" }
+    let(:request_body) do
+      {
+        available_period_id: available_period_id,
+        start: "2020-07-26T15:30:00Z",
+        end: "2020-07-26T17:00:00Z"
+      }
+    end
+
+    let(:correct_response_code) { 202 }
+    let(:correct_response_body) { "" }
+    let(:correct_mapped_result) { nil }
+
+    subject {
+      client.upsert_available_period(available_period_id,
+        start: request_body[:start],
+        end: request_body[:end]
+      )
+    }
+
+    it_behaves_like 'a Cronofy request'
+    it_behaves_like 'a Cronofy request with mapped return value'
+  end
+
+  describe "#get_available_periods" do
+    context "unfiltered" do
+      let(:request_url) { "https://api.cronofy.com/v1/available_periods" }
+      let(:method) { :get }
+
+      let(:correct_response_code) { 200 }
+      let(:correct_response_body) do
+        {
+          "available_periods" => [
+            {
+              "available_period_id" => "qTtZdczOccgaPncGJaCiLg",
+              "start" => "2020-07-26T15:30:00Z",
+              "end" => "2020-07-26T17:00:00Z"
+            }
+          ]
+        }
+      end
+
+      let(:correct_mapped_result) do
+        period = correct_response_body['available_periods'][0]
+
+        [
+          Cronofy::AvailablePeriod.new(
+            available_period_id: period['available_period_id'],
+            start: period['start'],
+            end: period['end']
+          )
+        ]
+      end
+
+      subject { client.get_available_periods }
+
+      it_behaves_like 'a Cronofy request'
+      it_behaves_like 'a Cronofy request with mapped return value'
+    end
+
+    context "filterd by date range" do
+      let(:tzid) { "America/New_York" }
+      let(:from) { "2020-07-01" }
+      let(:to) { "2020-07-31" }
+      let(:request_url) { "https://api.cronofy.com/v1/available_periods?from=#{from}&to=#{to}&tzid=#{tzid}" }
+      let(:method) { :get }
+
+      let(:correct_response_code) { 200 }
+      let(:correct_response_body) do
+        {
+          "available_periods" => [
+            {
+              "available_period_id" => "qTtZdczOccgaPncGJaCiLg",
+              "start" => "2020-07-26T15:30:00Z",
+              "end" => "2020-07-26T17:00:00Z"
+            }
+          ]
+        }
+      end
+
+      let(:correct_mapped_result) do
+        period = correct_response_body['available_periods'][0]
+
+        [
+          Cronofy::AvailablePeriod.new(
+            available_period_id: period['available_period_id'],
+            start: period['start'],
+            end: period['end']
+          )
+        ]
+      end
+
+      subject { client.get_available_periods(from: from, to: to, tzid: tzid) }
+
+      it_behaves_like 'a Cronofy request'
+      it_behaves_like 'a Cronofy request with mapped return value'
+    end
+
+    context "requesting localized times" do
+      let(:tzid) { "America/New_York" }
+      let(:localized_times) { true }
+      let(:request_url) { "https://api.cronofy.com/v1/available_periods?tzid=#{tzid}&localized_times=true" }
+      let(:method) { :get }
+
+      let(:correct_response_code) { 200 }
+      let(:correct_response_body) do
+        {
+          "available_periods" => [
+            {
+              "available_period_id" => "qTtZdczOccgaPncGJaCiLg",
+              "start" => "2020-07-26T15:30:00Z",
+              "end" => "2020-07-26T17:00:00Z"
+            }
+          ]
+        }
+      end
+
+      let(:correct_mapped_result) do
+        period = correct_response_body['available_periods'][0]
+
+        [
+          Cronofy::AvailablePeriod.new(
+            available_period_id: period['available_period_id'],
+            start: period['start'],
+            end: period['end']
+          )
+        ]
+      end
+
+      subject { client.get_available_periods(tzid: tzid, localized_times: true) }
+
+      it_behaves_like 'a Cronofy request'
+      it_behaves_like 'a Cronofy request with mapped return value'
+    end
+  end
+
+  describe '#delete_available_period' do
+    let(:available_period_id) { 'default'}
+    let(:request_url) { "https://api.cronofy.com/v1/available_periods" }
+    let(:method) { :delete }
+    let(:request_body) {
+      { available_period_id: available_period_id}
+    }
+    let(:correct_response_code) { 202 }
+    let(:correct_response_body) { "" }
+    let(:correct_mapped_result) { nil }
+
+    subject { client.delete_available_period(available_period_id) }
+
+    it_behaves_like 'a Cronofy request'
+    it_behaves_like 'a Cronofy request with mapped return value'
+  end
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: cronofy
 version: !ruby/object:Gem::Version
-  version: 0.31.2
+  version: 0.36.0
 platform: ruby
 authors:
 - Sergii Paryzhskyi
 - Garry Shutler
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-06-11 00:00:00.000000000 Z
+date: 2020-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oauth2
@@ -99,14 +99,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.21'
+        version: 3.9.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.21'
+        version: 3.9.1
 description: Ruby wrapper for Cronofy's unified calendar API
 email:
 - parizhskiy@gmail.com
@@ -141,7 +141,7 @@ homepage: https://github.com/cronofy/cronofy-ruby
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -156,8 +156,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Cronofy - one API for all the calendars
 test_files: