async-caldav 1.2.3 → 1.3.0

data/lib/async/caldav/forward_auth.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "scampi"
-require "async/caldav"
-
 module Async
   module Caldav
     module ForwardAuth
@@ -11,16 +7,19 @@ module Async
 
       def extract(env)
         {
-          user: env['HTTP_REMOTE_USER'],
-          email: env['HTTP_REMOTE_EMAIL'],
-          name: env['HTTP_REMOTE_NAME'],
-          groups: parse_groups(env['HTTP_REMOTE_GROUPS'])
+          user:   env['HTTP_REMOTE_USER'],
+          email:  env['HTTP_REMOTE_EMAIL'],
+          name:   env['HTTP_REMOTE_NAME'],
+          groups: parse_groups(env['HTTP_REMOTE_GROUPS']),
         }
       end
 
       def parse_groups(header)
-        return [] if header.nil? || header.empty?
-        header.split(',').map(&:strip).reject(&:empty?)
+        if header.nil? || header.empty?
+          []
+        else
+          header.split(',').map(&:strip).reject(&:empty?)
+        end
       end
 
       private_class_method :parse_groups
@@ -31,9 +30,15 @@ module Async
 
       def inject(env, user: 'admin', email: nil, name: nil, groups: nil)
         env['HTTP_REMOTE_USER'] ||= user
-        env['HTTP_REMOTE_EMAIL'] ||= email if email
-        env['HTTP_REMOTE_NAME'] ||= name if name
-        env['HTTP_REMOTE_GROUPS'] ||= groups if groups
+        if email
+          env['HTTP_REMOTE_EMAIL'] ||= email
+        end
+        if name
+          env['HTTP_REMOTE_NAME'] ||= name
+        end
+        if groups
+          env['HTTP_REMOTE_GROUPS'] ||= groups
+        end
         env
       end
     end
@@ -41,54 +46,56 @@ module Async
 end
 
 
-test do
-  describe "Async::Caldav::ForwardAuth" do
-    it "sets user from HTTP_REMOTE_USER" do
-      result = Async::Caldav::ForwardAuth.extract({ 'HTTP_REMOTE_USER' => 'admin' })
-      result[:user].should.equal 'admin'
-    end
+__END__
 
-    it "leaves user nil when header absent" do
-      result = Async::Caldav::ForwardAuth.extract({})
-      result[:user].should.be.nil
-    end
+require_relative "../caldav"
 
-    it "parses HTTP_REMOTE_GROUPS as comma-separated list" do
-      result = Async::Caldav::ForwardAuth.extract({ 'HTTP_REMOTE_GROUPS' => 'a,b,c' })
-      result[:groups].should.equal ['a', 'b', 'c']
-    end
+describe "Async::Caldav::ForwardAuth" do
+  it "sets user from HTTP_REMOTE_USER" do
+    result = Async::Caldav::ForwardAuth.extract({ 'HTTP_REMOTE_USER' => 'admin' })
+    result[:user].should.equal 'admin'
+  end
 
-    it "trims whitespace around group names" do
-      result = Async::Caldav::ForwardAuth.extract({ 'HTTP_REMOTE_GROUPS' => ' a , b ' })
-      result[:groups].should.equal ['a', 'b']
-    end
+  it "leaves user nil when header absent" do
+    result = Async::Caldav::ForwardAuth.extract({})
+    result[:user].should.be.nil
+  end
 
-    it "empty groups header produces empty list" do
-      result = Async::Caldav::ForwardAuth.extract({ 'HTTP_REMOTE_GROUPS' => '' })
-      result[:groups].should.equal []
-    end
+  it "parses HTTP_REMOTE_GROUPS as comma-separated list" do
+    result = Async::Caldav::ForwardAuth.extract({ 'HTTP_REMOTE_GROUPS' => 'a,b,c' })
+    result[:groups].should.equal ['a', 'b', 'c']
+  end
 
-    it "email and name flow through" do
-      result = Async::Caldav::ForwardAuth.extract({
-        'HTTP_REMOTE_EMAIL' => 'a@b.com',
-        'HTTP_REMOTE_NAME' => 'Admin'
-      })
-      result[:email].should.equal 'a@b.com'
-      result[:name].should.equal 'Admin'
-    end
+  it "trims whitespace around group names" do
+    result = Async::Caldav::ForwardAuth.extract({ 'HTTP_REMOTE_GROUPS' => ' a , b ' })
+    result[:groups].should.equal ['a', 'b']
   end
 
-  describe "Async::Caldav::TestStub" do
-    it "injects defaults when no header present" do
-      env = {}
-      Async::Caldav::TestStub.inject(env)
-      env['HTTP_REMOTE_USER'].should.equal 'admin'
-    end
+  it "empty groups header produces empty list" do
+    result = Async::Caldav::ForwardAuth.extract({ 'HTTP_REMOTE_GROUPS' => '' })
+    result[:groups].should.equal []
+  end
 
-    it "respects existing headers when present" do
-      env = { 'HTTP_REMOTE_USER' => 'existing' }
-      Async::Caldav::TestStub.inject(env)
-      env['HTTP_REMOTE_USER'].should.equal 'existing'
-    end
+  it "email and name flow through" do
+    result = Async::Caldav::ForwardAuth.extract({
+      'HTTP_REMOTE_EMAIL' => 'a@b.com',
+      'HTTP_REMOTE_NAME' => 'Admin'
+    })
+    result[:email].should.equal 'a@b.com'
+    result[:name].should.equal 'Admin'
   end
 end
+
+describe "Async::Caldav::TestStub" do
+  it "injects defaults when no header present" do
+    env = {}
+    Async::Caldav::TestStub.inject(env)
+    env['HTTP_REMOTE_USER'].should.equal 'admin'
+  end
+
+  it "respects existing headers when present" do
+    env = { 'HTTP_REMOTE_USER' => 'existing' }
+    Async::Caldav::TestStub.inject(env)
+    env['HTTP_REMOTE_USER'].should.equal 'existing'
+  end
+end

data/lib/async/caldav/handlers/delete.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "scampi"
-require "async/caldav"
-
 module Async
   module Caldav
     module Handlers
@@ -28,33 +24,35 @@ module Async
   end
 end
 
-test do
-  describe "Async::Caldav::Handlers::Delete" do
-    def call(**opts)
-      Async::Caldav::Handlers::Delete.call(**opts)
-    end
+__END__
 
-    it "deletes an item and returns 204" do
-      s = Async::Caldav::Storage::Mock.new
-      s.create_collection('/calendars/admin/cal/', type: :calendar)
-      s.put_item('/calendars/admin/cal/event.ics', 'data', 'text/calendar')
-      status, = call(path: Protocol::Caldav::Path.new('/calendars/admin/cal/event.ics', storage_class: s), storage: s)
-      status.should.equal 204
-      s.get_item('/calendars/admin/cal/event.ics').should.be.nil
-    end
+require_relative "../../caldav"
 
-    it "deletes a collection and returns 204" do
-      s = Async::Caldav::Storage::Mock.new
-      s.create_collection('/calendars/admin/cal/', type: :calendar)
-      status, = call(path: Protocol::Caldav::Path.new('/calendars/admin/cal/', storage_class: s), storage: s)
-      status.should.equal 204
-      s.collection_exists?('/calendars/admin/cal/').should.equal false
-    end
+describe "Async::Caldav::Handlers::Delete" do
+  def call(**opts)
+    Async::Caldav::Handlers::Delete.call(**opts)
+  end
 
-    it "returns 404 for non-existent resource" do
-      s = Async::Caldav::Storage::Mock.new
-      status, = call(path: Protocol::Caldav::Path.new('/calendars/admin/nope/', storage_class: s), storage: s)
-      status.should.equal 404
-    end
+  it "deletes an item and returns 204" do
+    s = Async::Caldav::Storage::Mock.new
+    s.create_collection('/calendars/admin/cal/', type: :calendar)
+    s.put_item('/calendars/admin/cal/event.ics', 'data', 'text/calendar')
+    status, = call(path: Protocol::Caldav::Path.new('/calendars/admin/cal/event.ics', storage_class: s), storage: s)
+    status.should.equal 204
+    s.get_item('/calendars/admin/cal/event.ics').should.be.nil
   end
-end
+
+  it "deletes a collection and returns 204" do
+    s = Async::Caldav::Storage::Mock.new
+    s.create_collection('/calendars/admin/cal/', type: :calendar)
+    status, = call(path: Protocol::Caldav::Path.new('/calendars/admin/cal/', storage_class: s), storage: s)
+    status.should.equal 204
+    s.collection_exists?('/calendars/admin/cal/').should.equal false
+  end
+
+  it "returns 404 for non-existent resource" do
+    s = Async::Caldav::Storage::Mock.new
+    status, = call(path: Protocol::Caldav::Path.new('/calendars/admin/nope/', storage_class: s), storage: s)
+    status.should.equal 404
+  end
+end

data/lib/async/caldav/handlers/get.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "scampi"
-require "async/caldav"
-
 module Async
   module Caldav
     module Handlers
@@ -35,53 +31,55 @@ module Async
   end
 end
 
-test do
-  describe "Async::Caldav::Handlers::Get" do
-    def call(**opts)
-      Async::Caldav::Handlers::Get.call(**opts)
-    end
+__END__
 
-    def path(p, s)
-      Protocol::Caldav::Path.new(p, storage_class: s)
-    end
+require_relative "../../caldav"
 
-    it "returns item body with 200" do
-      s = Async::Caldav::Storage::Mock.new
-      s.put_item('/cal/ev.ics', 'BEGIN:VCALENDAR', 'text/calendar')
-      status, headers, body = call(path: path('/cal/ev.ics', s), storage: s)
-      status.should.equal 200
-      headers['content-type'].should.equal 'text/calendar'
-      body[0].should.equal 'BEGIN:VCALENDAR'
-    end
+describe "Async::Caldav::Handlers::Get" do
+  def call(**opts)
+    Async::Caldav::Handlers::Get.call(**opts)
+  end
 
-    it "returns 304 on If-None-Match hit" do
-      s = Async::Caldav::Storage::Mock.new
-      item, = s.put_item('/cal/ev.ics', 'data', 'text/calendar')
-      status, = call(path: path('/cal/ev.ics', s), storage: s, headers: { 'if-none-match' => item[:etag] })
-      status.should.equal 304
-    end
+  def path(p, s)
+    Protocol::Caldav::Path.new(p, storage_class: s)
+  end
 
-    it "returns collection contents" do
-      s = Async::Caldav::Storage::Mock.new
-      s.create_collection('/cal/')
-      s.put_item('/cal/a.ics', 'A', 'text/calendar')
-      s.put_item('/cal/b.ics', 'B', 'text/calendar')
-      status, _, body = call(path: path('/cal/', s), storage: s)
-      status.should.equal 200
-      body[0].should.include 'A'
-      body[0].should.include 'B'
-    end
+  it "returns item body with 200" do
+    s = Async::Caldav::Storage::Mock.new
+    s.put_item('/cal/ev.ics', 'BEGIN:VCALENDAR', 'text/calendar')
+    status, headers, body = call(path: path('/cal/ev.ics', s), storage: s)
+    status.should.equal 200
+    headers['content-type'].should.equal 'text/calendar'
+    body[0].should.equal 'BEGIN:VCALENDAR'
+  end
 
-    it "returns 404 for deep non-existent path" do
-      s = Async::Caldav::Storage::Mock.new
-      status, = call(path: path('/calendars/admin/nope/item.ics', s), storage: s)
-      status.should.equal 404
-    end
+  it "returns 304 on If-None-Match hit" do
+    s = Async::Caldav::Storage::Mock.new
+    item, = s.put_item('/cal/ev.ics', 'data', 'text/calendar')
+    status, = call(path: path('/cal/ev.ics', s), storage: s, headers: { 'if-none-match' => item[:etag] })
+    status.should.equal 304
+  end
 
-    it "returns 200 for shallow path" do
-      s = Async::Caldav::Storage::Mock.new
-      status, = call(path: path('/calendars/admin/', s), storage: s)
-      status.should.equal 200
-    end
+  it "returns collection contents" do
+    s = Async::Caldav::Storage::Mock.new
+    s.create_collection('/cal/')
+    s.put_item('/cal/a.ics', 'A', 'text/calendar')
+    s.put_item('/cal/b.ics', 'B', 'text/calendar')
+    status, _, body = call(path: path('/cal/', s), storage: s)
+    status.should.equal 200
+    body[0].should.include 'A'
+    body[0].should.include 'B'
   end
-end
+
+  it "returns 404 for deep non-existent path" do
+    s = Async::Caldav::Storage::Mock.new
+    status, = call(path: path('/calendars/admin/nope/item.ics', s), storage: s)
+    status.should.equal 404
+  end
+
+  it "returns 200 for shallow path" do
+    s = Async::Caldav::Storage::Mock.new
+    status, = call(path: path('/calendars/admin/', s), storage: s)
+    status.should.equal 200
+  end
+end

data/lib/async/caldav/handlers/head.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "scampi"
-require "async/caldav"
-
 module Async
   module Caldav
     module Handlers
@@ -19,18 +15,20 @@ module Async
   end
 end
 
-test do
-  describe "Async::Caldav::Handlers::Head" do
-    it "returns same status and headers as GET but empty body" do
-      s = Async::Caldav::Storage::Mock.new
-      s.put_item('/cal/ev.ics', 'BEGIN:VCALENDAR', 'text/calendar')
-      status, headers, body = Async::Caldav::Handlers::Head.call(
-        path: Protocol::Caldav::Path.new('/cal/ev.ics', storage_class: s),
-        storage: s
-      )
-      status.should.equal 200
-      headers['content-type'].should.equal 'text/calendar'
-      body.should.equal []
-    end
+__END__
+
+require_relative "../../caldav"
+
+describe "Async::Caldav::Handlers::Head" do
+  it "returns same status and headers as GET but empty body" do
+    s = Async::Caldav::Storage::Mock.new
+    s.put_item('/cal/ev.ics', 'BEGIN:VCALENDAR', 'text/calendar')
+    status, headers, body = Async::Caldav::Handlers::Head.call(
+      path: Protocol::Caldav::Path.new('/cal/ev.ics', storage_class: s),
+      storage: s
+    )
+    status.should.equal 200
+    headers['content-type'].should.equal 'text/calendar'
+    body.should.equal []
   end
-end
+end

data/lib/async/caldav/handlers/mkcol.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "scampi"
-require "async/caldav"
-
 module Async
   module Caldav
     module Handlers
@@ -15,81 +11,81 @@ module Async
           col_path = path.ensure_trailing_slash
 
           if storage.collection_exists?(col_path.to_s)
-            return [405, { 'content-type' => 'text/plain' }, ['Collection already exists']]
-          end
-
-          unless col_path.parent_exists?
-            return [409, { 'content-type' => 'text/plain' }, ['Parent collection does not exist']]
-          end
-
-          displayname = Protocol::Caldav::Xml.extract_value(body, 'displayname')
-          description = Protocol::Caldav::Xml.extract_value(body, 'calendar-description')
-          color = Protocol::Caldav::Xml.extract_value(body, 'calendar-color')
-
-          type = if method == 'MKCALENDAR'
-            :calendar
-          elsif body && body.include?('addressbook')
-            :addressbook
+            [405, { 'content-type' => 'text/plain' }, ['Collection already exists']]
           else
-            resource_type || :collection
+            if col_path.parent_exists?
+              displayname = Protocol::Caldav::Xml.extract_value(body, 'displayname')
+              description = Protocol::Caldav::Xml.extract_value(body, 'calendar-description')
+              color = Protocol::Caldav::Xml.extract_value(body, 'calendar-color')
+              if method == 'MKCALENDAR'
+                type = :calendar
+              elsif body && body.include?('addressbook')
+                type = :addressbook
+              else
+                type = resource_type || :collection
+              end
+              storage.create_collection(col_path.to_s, type: type, displayname: displayname, description: description, color: color)
+              [201, {}, ['']]
+            else
+              [409, { 'content-type' => 'text/plain' }, ['Parent collection does not exist']]
+            end
           end
-
-          storage.create_collection(col_path.to_s, type: type, displayname: displayname, description: description, color: color)
-          [201, {}, ['']]
         end
       end
     end
   end
 end
 
-test do
-  describe "Async::Caldav::Handlers::Mkcol" do
-    def call(**opts)
-      Async::Caldav::Handlers::Mkcol.call(**opts)
-    end
+__END__
 
-    def path(p, s)
-      Protocol::Caldav::Path.new(p, storage_class: s)
-    end
+require_relative "../../caldav"
 
-    it "creates a calendar and returns 201" do
-      s = Async::Caldav::Storage::Mock.new
-      s.create_collection('/calendars/admin/')
-      status, = call(
-        path: path('/calendars/admin/work', s), storage: s,
-        body: '<d:displayname>Work</d:displayname>', method: 'MKCALENDAR'
-      )
-      status.should.equal 201
-      col = s.get_collection('/calendars/admin/work/')
-      col[:type].should.equal :calendar
-      col[:displayname].should.equal 'Work'
-    end
+describe "Async::Caldav::Handlers::Mkcol" do
+  def call(**opts)
+    Async::Caldav::Handlers::Mkcol.call(**opts)
+  end
 
-    it "creates an addressbook via MKCOL" do
-      s = Async::Caldav::Storage::Mock.new
-      s.create_collection('/addressbooks/admin/')
-      status, = call(
-        path: path('/addressbooks/admin/contacts', s), storage: s,
-        body: '<resourcetype><addressbook/></resourcetype>', method: 'MKCOL'
-      )
-      status.should.equal 201
-      s.get_collection('/addressbooks/admin/contacts/')[:type].should.equal :addressbook
-    end
+  def path(p, s)
+    Protocol::Caldav::Path.new(p, storage_class: s)
+  end
 
-    it "returns 405 if collection exists" do
-      s = Async::Caldav::Storage::Mock.new
-      s.create_collection('/cal/')
-      status, = call(path: path('/cal/', s), storage: s, body: '', method: 'MKCALENDAR')
-      status.should.equal 405
-    end
+  it "creates a calendar and returns 201" do
+    s = Async::Caldav::Storage::Mock.new
+    s.create_collection('/calendars/admin/')
+    status, = call(
+      path: path('/calendars/admin/work', s), storage: s,
+      body: '<d:displayname>Work</d:displayname>', method: 'MKCALENDAR'
+    )
+    status.should.equal 201
+    col = s.get_collection('/calendars/admin/work/')
+    col[:type].should.equal :calendar
+    col[:displayname].should.equal 'Work'
+  end
 
-    it "returns 409 if parent does not exist" do
-      s = Async::Caldav::Storage::Mock.new
-      status, = call(
-        path: path('/calendars/admin/deep/nested/cal', s), storage: s,
-        body: '', method: 'MKCALENDAR'
-      )
-      status.should.equal 409
-    end
+  it "creates an addressbook via MKCOL" do
+    s = Async::Caldav::Storage::Mock.new
+    s.create_collection('/addressbooks/admin/')
+    status, = call(
+      path: path('/addressbooks/admin/contacts', s), storage: s,
+      body: '<resourcetype><addressbook/></resourcetype>', method: 'MKCOL'
+    )
+    status.should.equal 201
+    s.get_collection('/addressbooks/admin/contacts/')[:type].should.equal :addressbook
   end
-end
+
+  it "returns 405 if collection exists" do
+    s = Async::Caldav::Storage::Mock.new
+    s.create_collection('/cal/')
+    status, = call(path: path('/cal/', s), storage: s, body: '', method: 'MKCALENDAR')
+    status.should.equal 405
+  end
+
+  it "returns 409 if parent does not exist" do
+    s = Async::Caldav::Storage::Mock.new
+    status, = call(
+      path: path('/calendars/admin/deep/nested/cal', s), storage: s,
+      body: '', method: 'MKCALENDAR'
+    )
+    status.should.equal 409
+  end
+end