calendav 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e72b5067dad00dc1074cbd5cf7d0b3c28845b624d47ff5e992e3b78a9a65fa0d
-  data.tar.gz: 11c9e3e362f36c91323141650a0d3415914f87aed208ea4716d8b0253ffd2c6e
+  metadata.gz: 6564ba6fca723cd571c786aee0028dd36179fd90ee7bba76a7fbd3526a939b64
+  data.tar.gz: 670e804269e4f341fee602a5ffad34360ae2d8ae5c15e88167c354227848ce03
 SHA512:
-  metadata.gz: 89da478d32baf4bbcfbd3c13ca2f89d5071f2dd4953889830d6f996d54bc4b5fb14feeac89af0c03891f047bf0e5b67fe7d88267df9ab0998a825387dbabf159
-  data.tar.gz: 05737755ec19e2c6b1e1f06b3f9273428e92d69381c19aee5cca14738bb9d63f243181a3c02b8d3d69ceb7e1b8c851847932aec8a81ae770a2d7c28d19357f12
+  metadata.gz: 63cd2f961d63585f35c46f137b510b5d8378d699e94c54cb195d702961abb0a557d9bcc6a159cdd9d133318290c1cd71921c54f4fc8ed2d38763fe95ef193a06
+  data.tar.gz: 4fb05941471d086aa9c13aad6a3dca6349106e5d1d527f3b1fae1b7da02a6c8b993cfe55c718c0ddad7371f5db6c18228a4b8f850b1d3c13622f824bcf31c1fa

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ...
 
+## 0.1.1 - 2021-06-28
+
+* Fix reports lists to just the relevant calendar.
+
 ## 0.1.0 - 2021-06-14
 
 * Support creating and deleting calendars.

data/README.md

@@ -10,7 +10,7 @@ Calendav has support for a few calendar providers built-in by default: Apple, Fa
 
 ```ruby
 credentials = Calendav.credentials(
-  :apple, username: "example@icloud.com", password: "app-specific-password"
+  :apple, "example@icloud.com", "app-specific-password"
 )
 ```
 

data/lib/calendav/endpoint.rb

@@ -22,11 +22,11 @@ module Calendav
     end
 
     def get(url:)
-      request(:get, url: url)
+      parse request(:get, url: url)
     end
 
     def mkcalendar(body, url:)
-      request(
+      parse request(
         :mkcalendar,
         body,
         url: url,
@@ -39,7 +39,7 @@ module Calendav
     end
 
     def propfind(body, url: nil, depth: 0)
-      request(
+      parse request(
         :propfind,
         body,
         url: url,
@@ -48,7 +48,7 @@ module Calendav
     end
 
     def proppatch(body, url: nil)
-      request(
+      parse request(
         :proppatch,
         body,
         url: url,
@@ -57,7 +57,7 @@ module Calendav
     end
 
     def put(body, url:, content_type: nil, etag: nil)
-      request(
+      parse request(
         :put,
         body,
         url: url,
@@ -66,7 +66,7 @@ module Calendav
     end
 
     def report(body, url: nil, depth: 0)
-      request(
+      parse request(
         :report,
         body,
         url: url,
@@ -107,13 +107,11 @@ module Calendav
         verb, ContextualURL.call(credentials.host, url), body: body
       )
 
-      if response.status.success?
-        parse(response)
-      elsif response.status.code == 412
-        raise PreconditionError, response
-      else
-        raise RequestError, response
-      end
+      return response if response.status.success?
+
+      raise PreconditionError, response if response.status.code == 412
+
+      raise RequestError, response
     end
 
     def parse(response)

data/lib/calendav/event.rb

@@ -24,6 +24,14 @@ module Calendav
       inner_event.summary
     end
 
+    def dtstart
+      inner_event.dtstart
+    end
+
+    def dtend
+      inner_event.dtend
+    end
+
     def unloaded?
       calendar_data.nil?
     end

data/lib/calendav/parsers/calendar_xml.rb

@@ -32,15 +32,15 @@ module Calendav
       attr_reader :element
 
       def components
-        element
-          .xpath(".//caldav:supported-calendar-component-set/caldav:comp")
-          .collect { |node| node["name"] }
+        element.xpath(
+          ".//caldav:supported-calendar-component-set/caldav:comp"
+        ).collect { |node| node["name"] }
       end
 
       def reports
-        element
-          .xpath("//dav:supported-report-set/dav:supported-report/dav:report/*")
-          .collect(&:name)
+        element.xpath(
+          ".//dav:supported-report-set/dav:supported-report/dav:report/*"
+        ).collect(&:name)
       end
 
       def value(xpath)

data/spec/acceptance/apple_spec.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require "icalendar"
-require "icalendar/tzinfo"
 require "securerandom"
-require "uri"
+
+require_relative "./shared"
 
 RSpec.describe "Apple" do
   let(:provider) { :apple }
   let(:username) { ENV.fetch("APPLE_USERNAME") }
   let(:password) { ENV.fetch("APPLE_PASSWORD") }
   let(:credentials) { Calendav.credentials(provider, username, password) }
+  let(:host) { "https://p49-caldav.icloud.com/20264203208/calendars/" }
 
   subject { Calendav.client(credentials) }
 
@@ -23,195 +23,19 @@ RSpec.describe "Apple" do
       .to eq_encoded_url("https://p49-caldav.icloud.com/20264203208/calendars/")
   end
 
-  it "supports calendar creation" do
-    expect(subject.calendars.create?).to eq(true)
-  end
-
-  it "can create, find, update and delete calendars" do
-    identifier = SecureRandom.uuid
-    time_zone = TZInfo::Timezone.get "UTC"
-    ical_time_zone = time_zone.ical_timezone Time.now.utc
-
-    url = subject.calendars.create(
-      identifier,
-      display_name: "Calendav Test",
-      description: "For test purposes only",
-      color: "#00FF00",
-      time_zone: ical_time_zone.to_ical
-    )
-    expect(url).to include(URI.decode_www_form_component(identifier))
-    expect(url).to start_with("https://")
-
-    calendars = subject.calendars.list
-    expect(calendars.collect(&:display_name)).to include("Calendav Test")
-
-    expect(
-      subject.calendars.update(url, display_name: "Calendav Update")
-    ).to eq(true)
-
-    calendars = subject.calendars.list
-    expect(calendars.collect(&:display_name)).to include("Calendav Update")
-
-    subject.calendars.delete(url)
-  end
+  it_behaves_like "supporting calendar management"
 
   context "with a calendar" do
     let(:calendar_url) do
       subject.calendars.create(SecureRandom.uuid, display_name: "Calendav Test")
     end
     let(:calendar) { subject.calendars.find(calendar_url) }
-    let(:identifier) { "#{SecureRandom.uuid}.ics" }
-    let(:start) { Time.new 2021, 6, 1, 10, 30 }
-    let(:finish) { Time.new 2021, 6, 1, 12, 30 }
 
     after :each do
-      subject.calendars.delete(calendar_url)
-    end
-
-    it "supports events" do
-      expect(calendar.components).to include("VEVENT")
+      subject.calendars.delete(calendar.url)
     end
 
-    it "supports WebDAV-Sync" do
-      expect(calendar.reports).to include("sync-collection")
-    end
-
-    it "can create, find, update and delete events" do
-      ics = Icalendar::Calendar.new
-      ics.event do |event|
-        event.dtstart = start.utc
-        event.dtend = finish.utc
-        event.summary = "Brunch"
-      end
-      ics.publish
-
-      # Create an event
-      event_url = subject.events.create(calendar.url, identifier, ics.to_ical)
-      expect(event_url).to include(URI.decode_www_form_component(calendar.url))
-
-      # Search for the event
-      events = subject.events.list(
-        calendar.url, from: Time.new(2021, 6, 1), to: Time.new(2021, 6, 2)
-      )
-      expect(events.length).to eq(1)
-      expect(events.first.summary).to eq("Brunch")
-      expect(events.first.url).to eq_encoded_url(event_url)
-
-      # Update the event
-      ics.events.first.dtstart = Time.new(2021, 7, 1, 10, 30).utc
-      ics.events.first.dtend = Time.new(2021, 7, 1, 12, 30).utc
-      subject.events.update(event_url, ics.to_ical)
-
-      # Search again
-      events = subject.events.list(
-        calendar.url, from: Time.new(2021, 7, 1), to: Time.new(2021, 7, 2)
-      )
-      expect(events.length).to eq(1)
-      expect(events.first.summary).to eq("Brunch")
-      expect(events.first.url).to eq_encoded_url(event_url)
-
-      # Create another event
-      ics = Icalendar::Calendar.new
-      ics.event do |event|
-        event.dtstart = start.utc
-        event.dtend = finish.utc
-        event.summary = "Brunch"
-      end
-      ics.publish
-
-      another_url = subject.events.create(
-        calendar.url, "#{SecureRandom.uuid}.ics", ics.to_ical
-      )
-
-      # Search for all events
-      events = subject.events.list(calendar.url)
-      expect(events.length).to eq(2)
-
-      # Delete the events
-      expect(subject.events.delete(event_url)).to eq(true)
-      expect(subject.events.delete(another_url)).to eq(true)
-    end
-
-    it "respects etag conditions with updates and deletions" do
-      ics = Icalendar::Calendar.new
-      ics.event do |event|
-        event.dtstart = start.utc
-        event.dtend = finish.utc
-        event.summary = "Brunch"
-      end
-      ics.publish
-
-      event_url = subject.events.create(calendar.url, identifier, ics.to_ical)
-      event = subject.events.find(event_url)
-
-      ics.events.first.summary = "Coffee"
-      expect(
-        subject.events.update(event_url, ics.to_ical, etag: event.etag)
-      ).to eq(true)
-
-      expect(subject.events.find(event_url).summary).to eq("Coffee")
-
-      # Updating with the old etag should fail
-      ics.events.first.summary = "Brunch"
-      expect(
-        subject.events.update(event_url, ics.to_ical, etag: event.etag)
-      ).to eq(false)
-
-      expect(subject.events.find(event_url).summary).to eq("Coffee")
-
-      expect(subject.events.delete(event_url, etag: event.etag)).to eq(false)
-      expect(subject.events.delete(event_url)).to eq(true)
-    end
-
-    it "handles synchronisation requests" do
-      first = Icalendar::Calendar.new
-      first.event do |event|
-        event.dtstart = start.utc
-        event.dtend = finish.utc
-        event.summary = "Brunch"
-      end
-      first.publish
-
-      first_url = subject.events.create(calendar.url, identifier, first.to_ical)
-      token = subject.calendars.find(calendar.url, sync: true).sync_token
-
-      events = subject.events.list(calendar.url)
-      expect(events.length).to eq(1)
-
-      second = Icalendar::Calendar.new
-      second.event do |event|
-        event.dtstart = start.utc
-        event.dtend = finish.utc
-        event.summary = "Brunch Again"
-      end
-      second.publish
-      second_url = subject.events.create(
-        calendar.url, "#{SecureRandom.uuid}.ics", second.to_ical
-      )
-
-      first.events.first.summary = "Coffee"
-      subject.events.update(first_url, first.to_ical)
-
-      collection = subject.calendars.sync(calendar.url, token)
-      expect(collection.changes.collect(&:url))
-        .to match_encoded_urls([first_url, second_url])
-
-      expect(collection.deletions).to be_empty
-
-      first.events.first.summary = "Brunch"
-      subject.events.update(first_url, first.to_ical)
-
-      subject.events.delete(second_url)
-
-      collection = subject.calendars.sync(calendar.url, collection.sync_token)
-      urls = collection.changes.collect(&:url)
-      expect(urls.length).to eq(1)
-      expect(urls[0]).to eq_encoded_url(first_url)
-
-      expect(collection.deletions.length).to eq(1)
-      expect(collection.deletions.first).to eq_encoded_url(second_url)
-
-      subject.events.delete(first_url)
-    end
+    it_behaves_like "supporting event management"
+    it_behaves_like "supporting event deletion with etags"
   end
 end

data/spec/acceptance/google_spec.rb

@@ -5,6 +5,8 @@ require "icalendar"
 require "securerandom"
 require "uri"
 
+require_relative "./shared"
+
 RSpec.describe "Google" do
   let(:provider) { :google }
   let(:username) { ENV.fetch("GOOGLE_USERNAME") }
@@ -62,174 +64,30 @@ RSpec.describe "Google" do
     let(:calendar) do
       calendars.detect { |cal| cal.display_name == "Calendav Test" }
     end
-    let(:identifier) { "#{SecureRandom.uuid}.ics" }
-    let(:start) { Time.new 2021, 6, 1, 10, 30 }
-    let(:finish) { Time.new 2021, 6, 1, 12, 30 }
-
-    it "supports events" do
-      expect(calendar.components).to include("VEVENT")
-    end
 
-    it "supports WebDAV-Sync" do
-      expect(calendar.reports).to include("sync-collection")
+    after :each do
+      subject
+        .events
+        .list(calendar.url)
+        .each { |event| subject.events.delete(event.url) }
     end
 
-    it "can create, find, update and delete events" do
-      ics = Icalendar::Calendar.new
-      ics.event do |event|
-        event.dtstart = start.utc
-        event.dtend = finish.utc
-        event.summary = "Brunch"
-      end
-      ics.publish
-
-      # Create an event
-      event_url = subject.events.create(calendar.url, identifier, ics.to_ical)
-      expect(event_url).to include(URI.decode_www_form_component(calendar.url))
-
-      # Search for the event
-      events = subject.events.list(
-        calendar.url, from: Time.new(2021, 6, 1), to: Time.new(2021, 6, 2)
-      )
-      expect(events.length).to eq(1)
-      expect(events.first.summary).to eq("Brunch")
-      expect(events.first.url).to eq_encoded_url(event_url)
-
-      # Update the event
-      ics.events.first.dtstart = Time.new(2021, 7, 1, 10, 30).utc
-      ics.events.first.dtend = Time.new(2021, 7, 1, 12, 30).utc
-      subject.events.update(event_url, ics.to_ical)
-
-      # Search again
-      events = subject.events.list(
-        calendar.url, from: Time.new(2021, 7, 1), to: Time.new(2021, 7, 2)
-      )
-      expect(events.length).to eq(1)
-      expect(events.first.summary).to eq("Brunch")
-      expect(events.first.url).to eq_encoded_url(event_url)
-
-      # Create another event
-      ics = Icalendar::Calendar.new
-      ics.event do |event|
-        event.dtstart = start.utc
-        event.dtend = finish.utc
-        event.summary = "Brunch"
-      end
-      ics.publish
-
-      another_url = subject.events.create(
-        calendar.url, "#{SecureRandom.uuid}.ics", ics.to_ical
-      )
-
-      # Search for all events
-      events = subject.events.list(calendar.url)
-      expect(events.length).to eq(2)
-
-      # Delete the events
-      expect(subject.events.delete(event_url)).to eq(true)
-      expect(subject.events.delete(another_url)).to eq(true)
-    end
-
-    it "respects etag conditions with updates" do
-      ics = Icalendar::Calendar.new
-      ics.event do |event|
-        event.dtstart = start.utc
-        event.dtend = finish.utc
-        event.summary = "Brunch"
-      end
-      ics.publish
-
-      event_url = subject.events.create(calendar.url, identifier, ics.to_ical)
-      event = subject.events.find(event_url)
-
-      ics.events.first.summary = "Coffee"
-      expect(
-        subject.events.update(event_url, ics.to_ical, etag: event.etag)
-      ).to eq(true)
-
-      expect(subject.events.find(event_url).summary).to eq("Coffee")
-
-      # Updating with the old etag should fail
-      ics.events.first.summary = "Brunch"
-      expect(
-        subject.events.update(event_url, ics.to_ical, etag: event.etag)
-      ).to eq(false)
-
-      expect(subject.events.find(event_url).summary).to eq("Coffee")
-
-      expect(subject.events.delete(event_url)).to eq(true)
-    end
+    it_behaves_like "supporting event management"
 
     it "does not respect etag conditions for deletions" do
-      ics = Icalendar::Calendar.new
-      ics.event do |event|
-        event.dtstart = start.utc
-        event.dtend = finish.utc
-        event.summary = "Brunch"
-      end
-      ics.publish
-
-      event_url = subject.events.create(calendar.url, identifier, ics.to_ical)
+      event_url = subject.events.create(
+        calendar.url, event_identifier, ical_event("Brunch", 10, 30)
+      )
       event = subject.events.find(event_url)
 
-      ics.events.first.summary = "Coffee"
       expect(
-        subject.events.update(event_url, ics.to_ical, etag: event.etag)
+        subject.events.update(
+          event_url, update_summary(event, "Coffee"), etag: event.etag
+        )
       ).to eq(true)
 
       # Google doesn't care about the If-Match header on DELETE requests :(
       expect(subject.events.delete(event_url, etag: event.etag)).to eq(true)
     end
-
-    it "handles synchronisation requests" do
-      first = Icalendar::Calendar.new
-      first.event do |event|
-        event.dtstart = start.utc
-        event.dtend = finish.utc
-        event.summary = "Brunch"
-      end
-      first.publish
-
-      first_url = subject.events.create(calendar.url, identifier, first.to_ical)
-      token = subject.calendars.find(calendar.url, sync: true).sync_token
-
-      events = subject.events.list(calendar.url)
-      expect(events.length).to eq(1)
-
-      second = Icalendar::Calendar.new
-      second.event do |event|
-        event.dtstart = start.utc
-        event.dtend = finish.utc
-        event.summary = "Brunch Again"
-      end
-      second.publish
-      second_url = subject.events.create(
-        calendar.url, "#{SecureRandom.uuid}.ics", second.to_ical
-      )
-
-      first.events.first.summary = "Coffee"
-      subject.events.update(first_url, first.to_ical)
-
-      collection = subject.calendars.sync(calendar.url, token)
-      expect(collection.changes.collect(&:url))
-        .to match_encoded_urls([first_url, second_url])
-
-      expect(collection.deletions).to be_empty
-
-      first.events.first.summary = "Brunch"
-      subject.events.update(first_url, first.to_ical)
-
-      subject.events.delete(second_url)
-
-      collection = subject.calendars.sync(calendar.url, collection.sync_token)
-      urls = collection.changes.collect(&:url)
-      expect(urls.length).to eq(1)
-      expect(urls[0]).to eq_encoded_url(first_url)
-
-      expect(collection.deletions.length).to eq(1)
-      expect(collection.deletions.first).to eq_encoded_url(second_url)
-
-      subject.events.delete(first_url)
-    end
   end
 end

data/spec/acceptance/radicale_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+require_relative "./shared"
+
+RSpec.describe "Radicale" do
+  let(:provider) { :radicale }
+  let(:username) { ENV.fetch("RADICALE_USERNAME") }
+  let(:password) { ENV.fetch("RADICALE_PASSWORD") }
+  let(:host) { ENV.fetch("RADICALE_HOST") }
+  let(:credentials) do
+    Calendav::Credentials::Standard.new(
+      host: host,
+      username: username,
+      password: password,
+      authentication: :basic_auth
+    )
+  end
+
+  subject { Calendav.client(credentials) }
+
+  it "determines the user's principal URL" do
+    expect(subject.principal_url)
+      .to eq_encoded_url("#{host}/test/")
+  end
+
+  it "determines the user's calendar URL" do
+    expect(subject.calendars.home_url)
+      .to eq_encoded_url("#{host}/test/")
+  end
+
+  it_behaves_like "supporting calendar management"
+
+  context "with a calendar" do
+    let(:calendar_url) do
+      subject.calendars.create(SecureRandom.uuid, display_name: "Calendav Test")
+    end
+    let(:calendar) { subject.calendars.find(calendar_url) }
+
+    after :each do
+      subject.calendars.delete(calendar.url)
+    end
+
+    it_behaves_like "supporting event management"
+    it_behaves_like "supporting event deletion with etags"
+  end
+end

data/spec/acceptance/shared.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "icalendar"
+require "icalendar/tzinfo"
+require "securerandom"
+require "uri"
+
+RSpec.shared_examples "supporting calendar management" do
+  it "supports calendar creation" do
+    expect(subject.calendars.create?).to eq(true)
+  end
+
+  it "can create, find, update and delete calendars" do
+    identifier = SecureRandom.uuid
+    time_zone = TZInfo::Timezone.get "UTC"
+    ical_time_zone = time_zone.ical_timezone Time.now.utc
+
+    url = subject.calendars.create(
+      identifier,
+      display_name: "Calendav Test",
+      description: "For test purposes only",
+      color: "#00FF00",
+      time_zone: ical_time_zone.to_ical
+    )
+    expect(url).to include(URI.decode_www_form_component(identifier))
+    expect(url).to start_with(host)
+
+    calendars = subject.calendars.list
+    expect(calendars.collect(&:display_name)).to include("Calendav Test")
+
+    expect(
+      subject.calendars.update(url, display_name: "Calendav Update")
+    ).to eq(true)
+
+    calendars = subject.calendars.list
+    expect(calendars.collect(&:display_name)).to include("Calendav Update")
+
+    subject.calendars.delete(url)
+  end
+end
+
+RSpec.shared_examples "supporting event management" do
+  it "supports events" do
+    expect(calendar.components).to include("VEVENT")
+  end
+
+  it "supports WebDAV-Sync" do
+    expect(calendar.reports).to include("sync-collection")
+  end
+
+  it "can create, find, update and delete events" do
+    # Create an event
+    event_url = subject.events.create(
+      calendar.url, event_identifier, ical_event("Brunch", 10, 30)
+    )
+    expect(event_url).to include(URI.decode_www_form_component(calendar.url))
+    event = subject.events.find(event_url)
+
+    # Search for the event
+    events = subject.events.list(
+      calendar.url, from: time_at(0, 0), to: time_at(23, 59)
+    )
+    expect(events.length).to eq(1)
+    expect(events.first.summary).to eq("Brunch")
+    expect(events.first.dtstart.to_time).to eq(time_at(10, 30))
+    expect(events.first.url).to eq_encoded_url(event_url)
+
+    # Update the event
+    subject.events.update(event_url, update_summary(event, "Coffee"))
+
+    # Search again
+    events = subject.events.list(
+      calendar.url, from: time_at(0, 0), to: time_at(23, 59)
+    )
+    expect(events.length).to eq(1)
+    expect(events.first.summary).to eq("Coffee")
+    expect(events.first.dtstart.to_time).to eq(time_at(10, 30))
+    expect(events.first.url).to eq_encoded_url(event_url)
+
+    # Create another event
+    another_url = subject.events.create(
+      calendar.url, event_identifier, ical_event("Brunch", 10, 30)
+    )
+
+    # Search for all events
+    events = subject.events.list(calendar.url)
+    expect(events.length).to eq(2)
+
+    # Delete the events
+    expect(subject.events.delete(event_url)).to eq(true)
+    expect(subject.events.delete(another_url)).to eq(true)
+  end
+
+  it "respects etag conditions with updates" do
+    event_url = subject.events.create(
+      calendar.url, event_identifier, ical_event("Brunch", 10, 30)
+    )
+    event = subject.events.find(event_url)
+
+    expect(
+      subject.events.update(
+        event_url, update_summary(event, "Coffee"), etag: event.etag
+      )
+    ).to eq(true)
+
+    expect(subject.events.find(event_url).summary).to eq("Coffee")
+
+    # Updating with the old etag should fail
+    expect(
+      subject.events.update(
+        event_url, update_summary(event, "Brunch"), etag: event.etag
+      )
+    ).to eq(false)
+
+    expect(subject.events.find(event_url).summary).to eq("Coffee")
+
+    expect(subject.events.delete(event_url)).to eq(true)
+  end
+
+  it "handles synchronisation requests" do
+    first_url = subject.events.create(
+      calendar.url, event_identifier, ical_event("Brunch", 10, 30)
+    )
+    first = subject.events.find(first_url)
+    token = subject.calendars.find(calendar.url, sync: true).sync_token
+
+    events = subject.events.list(calendar.url)
+    expect(events.length).to eq(1)
+
+    second_url = subject.events.create(
+      calendar.url, event_identifier, ical_event("Brunch Again", 11, 30)
+    )
+
+    subject.events.update(first_url, update_summary(first, "Coffee"))
+    first = subject.events.find(first_url)
+
+    collection = subject.calendars.sync(calendar.url, token)
+    expect(collection.changes.collect(&:url))
+      .to match_encoded_urls([first_url, second_url])
+
+    expect(collection.deletions).to be_empty
+
+    subject.events.update(first_url, update_summary(first, "Brunch"))
+    subject.events.delete(second_url)
+
+    collection = subject.calendars.sync(calendar.url, collection.sync_token)
+    urls = collection.changes.collect(&:url)
+    expect(urls.length).to eq(1)
+    expect(urls[0]).to eq_encoded_url(first_url)
+
+    expect(collection.deletions.length).to eq(1)
+    expect(collection.deletions.first).to eq_encoded_url(second_url)
+
+    subject.events.delete(first_url)
+  end
+end
+
+RSpec.shared_examples "supporting event deletion with etags" do
+  it "respects etag conditions with deletions" do
+    event_url = subject.events.create(
+      calendar.url, event_identifier, ical_event("Brunch", 10, 30)
+    )
+    event = subject.events.find(event_url)
+
+    expect(
+      subject.events.update(
+        event_url, update_summary(event, "Coffee"), etag: event.etag
+      )
+    ).to eq(true)
+    expect(subject.events.find(event_url).summary).to eq("Coffee")
+
+    expect(subject.events.delete(event_url, etag: event.etag)).to eq(false)
+    expect(subject.events.delete(event_url)).to eq(true)
+  end
+end

data/spec/data/radicale/config.ini

@@ -0,0 +1,10 @@
+[auth]
+type = htpasswd
+htpasswd_filename = /var/radicale/users
+htpasswd_encryption = bcrypt
+
+[server]
+hosts = 0.0.0.0:8000
+
+[storage]
+filesystem_folder = /var/radicale/collections

data/spec/data/radicale/users

@@ -0,0 +1 @@
+test:$2y$05$O.Z0365vM0GOv.YN1WlIEOnd0gaGEB/SmoRiSjIHnstXIm6ZURl/y

data/spec/spec_helper.rb

@@ -6,6 +6,7 @@ require "dotenv"
 Dotenv.load
 
 require_relative "support/encoded_matchers"
+require_relative "support/event_helpers"
 
 RSpec.configure do |config|
   config.disable_monkey_patching!

data/spec/support/event_helpers.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "icalendar"
+require "securerandom"
+
+module EventHelpers
+  def event_identifier
+    "#{SecureRandom.uuid}.ics"
+  end
+
+  def ical_event(summary, hour, minute)
+    start = time_at(hour, minute)
+
+    ics = Icalendar::Calendar.new
+
+    ics.event do |event|
+      event.dtstart = start
+      event.dtend = start + 3600
+      event.summary = summary
+    end
+
+    ics.tap(&:publish).to_ical
+  end
+
+  def time_at(hour, minute = 0)
+    now = Time.now
+
+    Time.utc(now.year, now.month, now.day, hour, minute)
+  end
+
+  def update_summary(event, summary)
+    ics = Icalendar::Calendar.parse(event.calendar_data).first
+
+    ics.events.first.summary = summary
+
+    ics.to_ical
+  end
+end
+
+RSpec.configure do |config|
+  config.include EventHelpers
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: calendav
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Pat Allan
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-06-14 00:00:00.000000000 Z
+date: 2021-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http
@@ -178,8 +178,13 @@ files:
 - lib/calendav/sync_collection.rb
 - spec/acceptance/apple_spec.rb
 - spec/acceptance/google_spec.rb
+- spec/acceptance/radicale_spec.rb
+- spec/acceptance/shared.rb
+- spec/data/radicale/config.ini
+- spec/data/radicale/users
 - spec/spec_helper.rb
 - spec/support/encoded_matchers.rb
+- spec/support/event_helpers.rb
 homepage: https://github.com/pat/calendav
 licenses:
 - Hippocratic-2.1
@@ -209,8 +214,13 @@ summary: CalDAV client
 test_files:
 - spec/acceptance/apple_spec.rb
 - spec/acceptance/google_spec.rb
+- spec/acceptance/radicale_spec.rb
+- spec/acceptance/shared.rb
+- spec/data/radicale/config.ini
+- spec/data/radicale/users
 - spec/spec_helper.rb
 - spec/support/encoded_matchers.rb
+- spec/support/event_helpers.rb
 - ".rspec"
 - Gemfile
 - Rakefile