vpim2 0.0.1

data/test/test_field.rb

@@ -0,0 +1,156 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'pp'
+require 'vpim/field'
+
+Field=Vpim::DirectoryInfo::Field
+
+class TestField < Test::Unit::TestCase
+
+  def test_encode_decode_text()
+    enc_in = "+\\\\+\\n+\\N+\\,+\\;+\\a+\\b+\\c+"
+    dec = Vpim.decode_text(enc_in)
+    #puts("<#{enc_in}> => <#{dec}>")
+    assert_equal("+\\+\n+\n+,+;+a+b+c+", dec)
+    enc_out = Vpim.encode_text(dec)
+    should_be = "+\\\\+\\n+\\n+\\,+\\;+a+b+c+"
+    # Note a, b, and c are allowed to be escaped, but shouldn't be and 
+    # aren't in output
+    #puts("<#{dec}> => <#{enc_out}>")
+    assert_equal(should_be, enc_out)
+
+  end
+
+  def test_field4
+    line = 't;e=a,b: 4 '
+    part = Field.decode0(line)
+    assert_equal("4", part[ 3 ])
+  end
+
+  def test_field3
+    line = 't;e=a,b:4'
+    part = Field.decode0(line)
+    assert_equal("4", part[ 3 ])
+    assert_equal( {'E' => [ 'a','b' ] }, part[ 2 ])
+  end
+
+  def test_field2
+    line = 'tel;type=work,voice,msg:+1 313 747-4454'
+    part = Field.decode0(line)
+    assert_equal("+1 313 747-4454", part[ 3 ])
+    assert_equal( {'TYPE' => [ 'work','voice','msg' ] }, part[ 2 ])
+  end
+
+  def test_field1
+    line = 'ORGANIZER;CN="xxxx, xxxx [SC100:370:EXCH]":MAILTO:xxxx@americasm01.nt.com'
+    parts = Field.decode0(line)
+
+    assert_equal(nil, parts[0])
+    assert_equal('ORGANIZER', parts[1])
+    assert_equal({ 'CN' => [ "xxxx, xxxx [SC100:370:EXCH]" ] }, parts[2])
+    assert_equal('MAILTO:xxxx@americasm01.nt.com', parts[3])
+  end
+
+=begin this can not be done :-(
+  def test_case_equiv
+    line = 'ORGANIZER;CN="xxxx, xxxx [SC100:370:EXCH]":MAILTO:xxxx@americasm01.nt.com'
+    field = Field.decode(line)
+    assert_equal(true, field.name?('organIZER'))
+    assert_equal(true, field === 'organIZER')
+
+    b = nil
+    case field
+    when 'organIZER'
+      b = true
+    end
+
+    assert_equal(true, b)
+  end
+=end
+
+  def test_field0
+    assert_equal('name:', line = Field.encode0(nil, 'name'))
+    assert_equal([ nil, 'NAME', {}, ''], Field.decode0(line))
+
+    assert_equal('name:value', line = Field.encode0(nil, 'name', {}, 'value'))
+    assert_equal([ nil, 'NAME', {}, 'value'], Field.decode0(line))
+
+    assert_equal('name;encoding=B:dmFsdWU=', line = Field.encode0(nil, 'name', { 'encoding'=>:b64 }, 'value'))
+    assert_equal([ nil, 'NAME', { 'ENCODING'=>['B']}, ['value'].pack('m').chomp ], Field.decode0(line))
+
+    assert_equal('group.name:value', line = Field.encode0('group', 'name', {}, 'value'))
+    assert_equal([ 'GROUP', 'NAME', {}, 'value'], Field.decode0(line))
+  end
+
+  def tEst_invalid_fields
+    [
+      'g.:',
+      ':v',
+    ].each do |line|
+      assert_raises(Vpim::InvalidEncodingError) { Field.decode0(line) }
+    end
+  end
+
+  def test_date_encode
+    assert_equal("DTSTART:20040101\n", Field.create('DTSTART',  Date.new(2004, 1, 1) ).to_s)
+    assert_equal("DTSTART:20040101\n", Field.create('DTSTART', [Date.new(2004, 1, 1)]).to_s)
+  end
+
+  def test_field_modify
+    f = Field.create('name')
+
+    assert_equal('', f.value)
+    f.value = ''
+    assert_equal('', f.value)
+    f.value = 'z'
+    assert_equal('z', f.value)
+
+    f.group = 'z.b'
+    assert_equal('Z.B', f.group)
+    assert_equal("z.b.NAME:z\n", f.encode)
+
+    assert_raises(TypeError) { f.value = :group }
+
+    assert_equal('Z.B', f.group)
+
+    assert_equal("z.b.NAME:z\n", f.encode)
+
+    assert_raises(TypeError) { f.group = :group }
+
+    assert_equal("z.b.NAME:z\n", f.encode)
+    assert_equal('Z.B', f.group)
+
+    f['p0'] = "hi julie"
+
+    assert_equal("Z.B.NAME;P0=hi julie:z\n", f.encode)
+    assert_equal(['hi julie'], f.param('p0'))
+    assert_equal(['hi julie'], f['p0'])
+    assert_equal('NAME', f.name)
+    assert_equal('Z.B', f.group)
+
+    # FAIL   assert_raises(ArgumentError) { f.group = 'z.b:' }
+
+    assert_equal('Z.B', f.group)
+
+    f.value = 'some text'
+    
+    assert_equal('some text', f.value)
+    assert_equal('some text', f.value_raw)
+
+    f['encoding'] = :b64
+
+    assert_equal('some text', f.value)
+    assert_equal([ 'some text' ].pack('m*').chomp, f.value_raw)
+  end
+
+  def test_field_wrapping
+    assert_equal("0:x\n",             Vpim::DirectoryInfo::Field.create('0', 'x' * 1).encode(4))
+    assert_equal("0:xx\n",            Vpim::DirectoryInfo::Field.create('0', 'x' * 2).encode(4))
+    assert_equal("0:xx\n x\n",        Vpim::DirectoryInfo::Field.create('0', 'x' * 3).encode(4))
+    assert_equal("0:xx\n xx\n",       Vpim::DirectoryInfo::Field.create('0', 'x' * 4).encode(4))
+    assert_equal("0:xx\n xxxx\n",     Vpim::DirectoryInfo::Field.create('0', 'x' * 6).encode(4))
+    assert_equal("0:xx\n xxxx\n x\n", Vpim::DirectoryInfo::Field.create('0', 'x' * 7).encode(4))
+  end
+end
+

data/test/test_ical.rb

@@ -0,0 +1,415 @@
+#!/usr/bin/env ruby
+
+require 'vpim/icalendar'
+require 'test/unit'
+
+
+# Sorry for the donkey patching...
+module Enumerable
+  def first
+    find{true}
+  end
+end
+
+include Vpim
+
+Req_1 =<<___
+BEGIN:VCALENDAR
+METHOD:REQUEST
+PRODID:-//Lotus Development Corporation//NONSGML Notes 6.0//EN
+VERSION:2.0
+X-LOTUS-CHARSET:UTF-8
+BEGIN:VTIMEZONE
+TZID:Pacific
+BEGIN:STANDARD
+DTSTART:19501029T020000
+TZOFFSETFROM:-0700
+TZOFFSETTO:-0800
+RRULE:FREQ=YEARLY;BYMINUTE=0;BYHOUR=2;BYDAY=-1SU;BYMONTH=10
+END:STANDARD
+BEGIN:DAYLIGHT
+DTSTART:19500402T020000
+TZOFFSETFROM:-0800
+TZOFFSETTO:-0700
+RRULE:FREQ=YEARLY;BYMINUTE=0;BYHOUR=2;BYDAY=1SU;BYMONTH=4
+END:DAYLIGHT
+END:VTIMEZONE
+BEGIN:VEVENT
+ATTENDEE;ROLE=CHAIR;PARTSTAT=ACCEPTED;CN="Gary Pope/Certicom"
+ ;RSVP=FALSE:mailto:gpope@certicom.com
+ATTENDEE;ROLE=REQ-PARTICIPANT;PARTSTAT=NEEDS-ACTION
+ ;CN="Mike Harvey/Certicom";RSVP=TRUE:mailto:MHarvey@certicom.com
+ATTENDEE;ROLE=REQ-PARTICIPANT;PARTSTAT=NEEDS-ACTION;RSVP=TRUE
+ :mailto:rgallant@emilpost.certicom.com
+ATTENDEE;ROLE=REQ-PARTICIPANT;PARTSTAT=NEEDS-ACTION
+ ;CN="Sam Roberts/Certicom";RSVP=TRUE:mailto:SRoberts@certicom.com
+ATTENDEE;ROLE=REQ-PARTICIPANT;PARTSTAT=NEEDS-ACTION
+ ;CN="Tony Walters/Certicom";RSVP=TRUE:mailto:TWalters@certicom.com
+CLASS:PUBLIC
+DTEND;TZID="Pacific":20040415T130000
+DTSTAMP:20040319T205045Z
+DTSTART;TZID="Pacific":20040415T120000
+ORGANIZER;CN="Gary Pope/Certicom":mailto:gpope@certicom.com
+SEQUENCE:0
+SUMMARY:hjold intyel
+TRANSP:OPAQUE
+UID:3E19204063C93D2388256E5C006BF8D9-Lotus_Notes_Generated
+X-LOTUS-BROADCAST:FALSE
+X-LOTUS-CHILD_UID:3E19204063C93D2388256E5C006BF8D9
+X-LOTUS-NOTESVERSION:2
+X-LOTUS-NOTICETYPE:I
+X-LOTUS-UPDATE-SEQ:1
+X-LOTUS-UPDATE-WISL:$S:1;$L:1;$B:1;$R:1;$E:1
+END:VEVENT
+END:VCALENDAR
+___
+
+Rep_1 =<<___
+BEGIN:VCALENDAR
+CALSCALE:GREGORIAN
+PRODID:-//Apple Computer\, Inc//iCal 1.5//EN
+VERSION:2.0
+METHOD:REPLY
+BEGIN:VEVENT
+ATTENDEE;CN="Sam Roberts/Certicom";PARTSTAT=ACCEPTED;ROLE=REQ-PARTICIPAN
+ T;RSVP=TRUE:mailto:SRoberts@certicom.com
+CLASS:PUBLIC
+DTEND;TZID=Pacific:20040415T130000
+DTSTAMP:20040319T205045Z
+DTSTART;TZID=Pacific:20040415T120000
+ORGANIZER;CN="Gary Pope/Certicom":mailto:gpope@certicom.com
+SEQUENCE:0
+SUMMARY:hjold intyel
+TRANSP:OPAQUE
+UID:3E19204063C93D2388256E5C006BF8D9-Lotus_Notes_Generated
+X-LOTUS-BROADCAST:FALSE
+X-LOTUS-CHILDUID:3E19204063C93D2388256E5C006BF8D9
+X-LOTUS-NOTESVERSION:2
+X-LOTUS-NOTICETYPE:I
+X-LOTUS-UPDATE-SEQ:1
+X-LOTUS-UPDATE-WISL:$S:1\;$L:1\;$B:1\;$R:1\;$E:1
+END:VEVENT
+END:VCALENDAR
+___
+
+class TestIcal < Test::Unit::TestCase
+
+  def assert_time(expected, actual, msg = nil)
+    assert_in_delta(expected, actual, 1, msg)
+  end
+
+  # Reported by Kyle Maxwell
+  def test_serialize_todo
+icstodo =<<___
+BEGIN:VCALENDAR
+VERSION:2.0
+BEGIN:VTODO
+END:VTODO
+END:VCALENDAR
+___
+
+    cal = Icalendar.decode(icstodo)
+    assert_equal(icstodo, cal.to_s)
+  end
+
+  # Tracker #18920
+  def test_recurring_todos
+icstodo =<<___
+BEGIN:VCALENDAR
+VERSION:2.0
+BEGIN:VTODO
+SUMMARY:todo
+DTSTART:20040415T120000
+RRULE:FREQ=WEEKLY;COUNT=2
+END:VTODO
+END:VCALENDAR
+___
+
+    cal = Icalendar.decode(icstodo).first
+    todo = cal.todos.first
+    assert(todo)
+    assert_equal(todo.occurrences.to_a.size, 2)
+  end
+
+  def test_1
+    req = Icalendar.decode(Req_1).first
+
+    req.components { }
+    req.components(Icalendar::Vevent) { }
+    req.components(Icalendar::Vjournal) { }
+    assert_equal(1, req.components.size)
+    assert_equal(1, req.components(Icalendar::Vevent).size)
+    assert_equal(0, req.components(Icalendar::Vjournal).size)
+
+    assert_equal(req.protocol, 'REQUEST')
+
+    event = req.events.first
+
+    assert(event)
+
+    assert( event.attendee?('mailto:sroberts@certicom.com'))
+    assert(!event.attendee?('mailto:sroberts@uniserve.com'))
+
+    me = event.attendees('mailto:sroberts@certicom.com').first
+
+    assert(me)
+    assert(me == 'mailto:sroberts@certicom.com')
+
+    reply = Icalendar.create_reply
+
+    reply.push(event.accept(me))
+
+    # puts "Reply=>"
+    # puts reply.to_s
+  end
+
+  def test_hal1
+    # Hal was encoding raw strings, here's how to do it with the API.
+
+    cal = Icalendar.create
+    
+    start = Time.now
+
+    event = Icalendar::Vevent.create(start,
+      'DTEND'    => start + 60 * 60,
+      'SUMMARY'  => "this is an event",
+      'RRULE'    =>  'freq=monthly;byday=2fr,4fr;count=5'
+      )
+
+    cal.push event
+
+    #puts cal.encode
+  end
+
+  # FIXME - test bad durations, like 'PT1D'
+
+  def test_event_duration
+    now = Time.now
+    event = Icalendar::Vevent.create(now)
+    assert_time(now, event.dtstart)
+    assert_nil(event.duration)
+    assert_nil(event.dtend)
+
+    event = Icalendar::Vevent.create(Date.new(2000, 1, 21),
+                                    'DURATION' => 'PT1H')
+    assert_equal(Time.gm(2000, 1, 21, 1),  event.dtend)
+
+    event = Icalendar::Vevent.create(Date.new(2000, 1, 21),
+                                    'DTEND' => Date.new(2000, 1, 22))
+    assert_equal(24*60*60, event.duration)
+  end
+
+  def test_todo_duration
+    todo = Icalendar::Vtodo.create()
+    assert_nil(todo.dtstart)
+    assert_nil(todo.duration)
+    assert_nil(todo.due)
+
+    todo = Icalendar::Vtodo.create('DTSTART' => Date.new(2000, 1, 21),
+                                    'DURATION' => 'PT1H')
+    assert_equal(Time.gm(2000, 1, 21, 1),  todo.due)
+
+    todo = Icalendar::Vtodo.create('DTSTART' => Date.new(2000, 1, 21),
+                                    'DUE' => Date.new(2000, 1, 22))
+    assert_equal(24*60*60, todo.duration)
+  end
+
+  def test_journal_create
+    vj = Icalendar::Vjournal.create('DESCRIPTION' => "description")
+    assert_equal("description", vj.description)
+  end
+
+  def TODO_test_occurrence_with_date_start
+    d = Date.new(2000, 1, 21)
+    event = Icalendar::Vevent.create(d)
+    d1 = event.occurences.to_a.first
+    assert_equal(d.class, d1.class)
+  end
+
+  def test_decode_duration_four_weeks
+    assert_equal 4*7*86400, Icalendar.decode_duration('P4W')
+  end
+
+  def test_decode_duration_negative_two_weeks
+    assert_equal(-2*7*86400, Icalendar.decode_duration('-P2W'))
+  end
+
+  def test_decode_duration_five_days
+    assert_equal 5*86400, Icalendar.decode_duration('P5D')
+  end
+
+  def test_decode_duration_one_hour
+    assert_equal 3600, Icalendar.decode_duration('PT1H')
+  end
+
+  def test_decode_duration_five_minutes
+    assert_equal 5*60, Icalendar.decode_duration('PT5M')
+  end
+
+  def test_decode_duration_ten_seconds
+    assert_equal 10, Icalendar.decode_duration('PT10S')
+  end
+
+  def test_decode_duration_with_leading_plus
+    assert_equal 10, Icalendar.decode_duration('+PT10S')
+  end
+
+  def test_decode_duration_with_composite_duration
+    assert_equal((15*86400+5*3600+20), Icalendar.decode_duration('P15DT5H0M20S'))
+  end
+
+  def test_create_with_prodid
+    prodid = "me//here/non-sgml"
+    cal = Icalendar.create2(prodid) do |cal|
+      assert_respond_to(cal, :push)
+    end
+    assert_equal(prodid, cal.producer)
+  end
+
+  def test_occurences
+    t0 = Time.now
+    vc = Icalendar.create2 do |vc|
+      vc.add_event do |ve|
+        ve.dtstart t0
+      end
+    end
+    ve = vc.components(Icalendar::Vevent).first
+    assert_time(t0, ve.occurences.select{true}.first)
+    ve.occurences do |t|
+      assert_time(t0, t)
+    end
+
+    vc = Icalendar.decode(<<__).first
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+END:VEVENT
+END:VCALENDAR
+__
+    ve = vc.components(Icalendar::Vevent).first
+    assert_raises(ArgumentError) { ve.occurences }
+  end
+
+  def test_each
+    vc = Icalendar.decode(<<__).first
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+END:VEVENT
+BEGIN:VTODO
+END:VTODO
+BEGIN:VJOURNAL
+END:VJOURNAL
+BEGIN:VTIMEZONE
+END:VTIMEZONE
+BEGIN:X-UNKNOWN
+END:X-UNKNOWN
+END:VCALENDAR
+__
+    count = Hash.new(0)
+
+    vc.each do |c| count[c.class] += 1 end
+
+    assert_equal(3, count.size)
+    count.each do |_,v| assert_equal(1, v) end
+
+    count = Hash.new(0)
+    vc.events do |c| count[c.class] += 1 end
+    vc.todos do |c| count[c.class] += 1 end
+    vc.journals do |c| count[c.class] += 1 end
+    assert_equal(3, count.size)
+    count.each do |_,v| assert_equal(1, v) end
+
+    assert_equal(3, vc.each.to_a.size)
+    assert_equal(1, vc.each.select{|c| Vpim::Icalendar::Vevent === c}.size)
+    assert_equal(1, vc.each.select{|c| Vpim::Icalendar::Vtodo === c}.size)
+    assert_equal(1, vc.each.select{|c| Vpim::Icalendar::Vjournal === c}.size)
+
+    assert_equal(1, vc.events.to_a.size)
+    assert_equal(1, vc.todos.to_a.size)
+    assert_equal(1, vc.journals.to_a.size)
+    
+    vc.to_s # Shouldn't raise...
+    # TODO - encode isn't round-tripping, unknown components are lost, which is
+    # not good.
+  end
+
+  def test_calscale
+    req = Icalendar.decode(<<__).first
+BEGIN:VCALENDAR
+END:VCALENDAR
+__
+    assert_equal("GREGORIAN", req.calscale)
+    req = Icalendar.decode(<<__).first
+BEGIN:VCALENDAR
+CALSCALE:GREGORIAN
+END:VCALENDAR
+__
+    assert_equal("GREGORIAN", req.calscale)
+  end
+
+  def test_version
+    req = Icalendar.decode(<<__).first
+BEGIN:VCALENDAR
+END:VCALENDAR
+__
+    assert_raises(InvalidEncodingError) { req.version }
+
+    req = Icalendar.decode(<<__).first
+BEGIN:VCALENDAR
+VERSION:2.0
+END:VCALENDAR
+__
+    assert_equal(20, req.version)
+  end
+
+  def test_protocol
+    req = Icalendar.decode(<<__).first
+BEGIN:VCALENDAR
+METHOD:GET
+END:VCALENDAR
+__
+    assert(req.protocol?("get"))
+    assert(!req.protocol?("set"))
+  end
+
+  def test_transparency
+    transparency = Icalendar.decode(<<__).first.to_a.first.transparency
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+END:VEVENT
+END:VCALENDAR
+__
+    assert_equal("OPAQUE", transparency, "check default")
+
+    transparency = Icalendar.decode(<<__).first.to_a.first.transparency
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+TRANSP:Opaque
+END:VEVENT
+END:VCALENDAR
+__
+    assert_equal("OPAQUE", transparency, "check opaque")
+
+    transparency = Icalendar.decode(<<__).first.to_a.first.transparency
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+TRANSP:TrANSPARENT
+END:VEVENT
+END:VCALENDAR
+__
+    assert_equal("TRANSPARENT", transparency, "check transparent")
+
+  end
+
+  def test_event_maker_w_rrule
+    vc = Icalendar.create2 do |vc|
+      vc.add_event do |m|
+        m.add_rrule("freq=monthly")
+        m.set_rrule do |_| _.frequency = "daily" end
+      end
+    end
+    assert_no_match(/RRULE:FREQ=MONTHLY/, vc.to_s)
+    assert_match(/RRULE:FREQ=DAILY/, vc.to_s)
+  end
+
+end
+