ro-bundle 0.1.0 → 0.2.0

data/test/tc_aggregate.rb

@@ -1,5 +1,5 @@
 #------------------------------------------------------------------------------
-# Copyright (c) 2014 The University of Manchester, UK.
+# Copyright (c) 2014, 2015 The University of Manchester, UK.
 #
 # BSD Licenced. See LICENCE.rdoc for details.
 #
@@ -13,85 +13,90 @@ require "ro-bundle"
 class TestAggregate < Test::Unit::TestCase
 
   def test_simple_file
-    assert_nothing_raised(ROBundle::InvalidAggregateError) do
-      file = "/good.txt"
-      type = "text/plain"
-      agg = ROBundle::Aggregate.new(file, type)
-
-      assert_nil agg.uri
-      assert_equal file, agg.file
-      assert_equal type, agg.mediatype
-    end
+    file = "/good.txt"
+    type = "text/plain"
+    agg = ROBundle::Aggregate.new(file, type)
+
+    assert_equal file, agg.uri
+    assert_equal "good.txt", agg.file_entry
+    assert_equal type, agg.mediatype
   end
 
   def test_simple_uri
-    assert_nothing_raised(ROBundle::InvalidAggregateError) do
-      uri = "http://example.com/good.txt"
-      agg = ROBundle::Aggregate.new(uri)
-
-      assert_nil agg.file
-      assert_nil agg.mediatype
-      assert_equal uri, agg.uri
-    end
+    uri = "http://example.com/good.txt"
+    agg = ROBundle::Aggregate.new(uri)
+
+    assert_nil agg.mediatype
+    assert_nil agg.file_entry
+    assert_equal uri, agg.uri
   end
 
   def test_simple_uri_object
-    assert_nothing_raised(ROBundle::InvalidAggregateError) do
-      uri = URI.parse("http://example.com/good.txt")
-      agg = ROBundle::Aggregate.new(uri)
-
-      assert_nil agg.file
-      assert_nil agg.mediatype
-      assert_equal uri.to_s, agg.uri
-    end
+    uri = URI.parse("http://example.com/good.txt")
+    agg = ROBundle::Aggregate.new(uri)
+
+    assert_nil agg.mediatype
+    assert_nil agg.file_entry
+    assert_equal uri.to_s, agg.uri
   end
 
-  def test_bad_aggregates
-    assert_raise(ROBundle::InvalidAggregateError) do
-      ROBundle::Aggregate.new([])
-    end
+  def test_complex_file
+    file = "/good.txt"
+    type = "text/plain"
+
+    json = {
+      :uri => file,
+      :mediatype => type,
+      :createdOn => "2013-02-12T19:37:32.939Z",
+      :createdBy => { "name" => "Robert Haines" },
+      :authoredOn => "2013-02-12T19:37:32.939Z",
+      :authoredBy => { "name" => "Robert Haines" }
+    }
+
+    agg = ROBundle::Aggregate.new(json)
+
+    assert_equal file, agg.uri
+    assert_equal type, agg.mediatype
+    assert agg.created_on.instance_of?(Time)
+    assert agg.created_by.instance_of?(ROBundle::Agent)
+    assert agg.authored_on.instance_of?(Time)
+    assert agg.authored_by.instance_of?(Array)
+    assert agg.authored_by[0].instance_of?(ROBundle::Agent)
+  end
 
-    assert_raise(ROBundle::InvalidAggregateError) do
-      ROBundle::Aggregate.new({})
-    end
+  def test_filepath_encoding_handling
+    file = "file with spaces.txt"
+    agg = ROBundle::Aggregate.new(file)
+    assert_equal "/file%20with%20spaces.txt",agg.uri
+    assert_equal file,agg.file_entry
   end
 
-  def test_complex_file
-    assert_nothing_raised(ROBundle::InvalidAggregateError) do
-      file = "/good.txt"
-      type = "text/plain"
-
-      json = {
-        :file => file,
-        :mediatype => type,
-        :createdOn => "2013-02-12T19:37:32.939Z",
-        :createdBy => { "name" => "Robert Haines" }
-      }
-
-      agg = ROBundle::Aggregate.new(json)
-
-      assert_nil agg.uri
-      assert_equal file, agg.file
-      assert_equal type, agg.mediatype
-      assert agg.created_on.instance_of?(Time)
-      assert agg.created_by.instance_of?(ROBundle::Agent)
-    end
+  def test_encoded_uri
+    uri = "http://example.com/encoded%20uri"
+
+    json = {
+        :uri => uri
+    }
+    agg = ROBundle::Aggregate.new(json)
+
+    assert_equal uri, agg.uri
+
+    agg = ROBundle::Aggregate.new(uri)
+    assert_equal uri, agg.uri
   end
 
   def test_complex_uri
-    assert_nothing_raised(ROBundle::InvalidAggregateError) do
-      uri = "http://example.com/good.txt"
+    uri = "http://example.com/good.txt"
 
-      json = {
-        :uri => uri
-      }
+    json = {
+      :uri => uri
+    }
 
-      agg = ROBundle::Aggregate.new(json)
+    agg = ROBundle::Aggregate.new(json)
 
-      assert_nil agg.file
-      assert_nil agg.mediatype
-      assert_equal uri, agg.uri
-    end
+    assert_nil agg.file_entry
+    assert_nil agg.mediatype
+    assert_equal uri, agg.uri
   end
 
   def test_json_output_file
@@ -99,7 +104,7 @@ class TestAggregate < Test::Unit::TestCase
     type = "text/plain"
     time = "2013-02-12T19:37:32.939Z"
     json = {
-      :file => file,
+      :uri => file,
       :mediatype => type,
       :createdOn => time,
       :createdBy => { :name => "Robert Haines" }
@@ -108,7 +113,7 @@ class TestAggregate < Test::Unit::TestCase
     agg = ROBundle::Aggregate.new(json)
     json = JSON.parse(JSON.generate(agg))
 
-    assert_equal file, json["file"]
+    assert_equal file, json["uri"]
     assert_equal type, json["mediatype"]
     assert_equal time, json["createdOn"]
   end

data/test/tc_annotation.rb

@@ -1,5 +1,5 @@
 #------------------------------------------------------------------------------
-# Copyright (c) 2014 The University of Manchester, UK.
+# Copyright (c) 2014, 2015 The University of Manchester, UK.
 #
 # BSD Licenced. See LICENCE.rdoc for details.
 #
@@ -21,7 +21,7 @@ class TestAnnotation < Test::Unit::TestCase
     @json = {
       :about => @target,
       :content => @content,
-      :annotation => @id,
+      :uri => @id,
       :createdBy => { :name => @creator },
       :createdOn => @time
     }
@@ -32,7 +32,10 @@ class TestAnnotation < Test::Unit::TestCase
 
     assert_equal @target, an.target
     assert_nil an.content
-    assert_not_nil an.annotation_id
+    assert_not_nil an.uri
+    assert an.annotates?("/")
+    assert an.annotates?("/file.txt")
+    refute an.edited?
   end
 
   def test_create_with_content
@@ -40,7 +43,8 @@ class TestAnnotation < Test::Unit::TestCase
 
     assert_equal @target, an.target
     assert_equal @content, an.content
-    assert_not_nil an.annotation_id
+    assert_not_nil an.uri
+    refute an.edited?
   end
 
   def test_create_from_json
@@ -48,9 +52,20 @@ class TestAnnotation < Test::Unit::TestCase
 
     assert_equal @target, an.target
     assert_equal @content, an.content
-    assert_equal @id, an.annotation_id
+    assert_equal @id, an.uri
     assert an.created_on.instance_of?(Time)
     assert an.created_by.instance_of?(ROBundle::Agent)
+    refute an.edited?
+  end
+
+  def test_cannot_change_target_directly
+    an = ROBundle::Annotation.new(@json)
+
+    assert_equal 2, an.target.length
+    an.target << "/more.html"
+    assert_equal 2, an.target.length
+    refute an.edited?
+    refute an.annotates?("/more.html")
   end
 
   def test_change_content
@@ -59,26 +74,70 @@ class TestAnnotation < Test::Unit::TestCase
     an.content = new_content
 
     assert_equal new_content, an.content
+    assert an.edited?
   end
 
   def test_generate_annotation_id
     an = ROBundle::Annotation.new(@target)
-    id = an.annotation_id
+    id = an.uri
 
     assert id.instance_of?(String)
     assert id.start_with?("urn:uuid:")
-    assert_same id, an.annotation_id
+    assert_same id, an.uri
+    refute an.edited?
+  end
+
+  def test_json_output_single_target
+    an = ROBundle::Annotation.new("/")
+    json = JSON.parse(JSON.generate(an))
+
+    assert_equal "/", json["about"]
   end
 
-  def test_json_output
-    agent = ROBundle::Annotation.new(@json)
-    json = JSON.parse(JSON.generate(agent))
+  def test_json_output_multiple_targets
+    an = ROBundle::Annotation.new(@target)
+    json = JSON.parse(JSON.generate(an))
+
+    assert_equal @target, json["about"]
+  end
+
+  def test_full_json_output
+    an = ROBundle::Annotation.new(@json)
+    json = JSON.parse(JSON.generate(an))
 
     assert_equal @target, json["about"]
     assert_equal @content, json["content"]
-    assert_equal @id, json["annotation"]
+    assert_equal @id, json["uri"]
     assert_equal @time, json["createdOn"]
     assert_equal @creator, json["createdBy"]["name"]
   end
 
+  def test_add_targets
+    target1 = "/target.pdf"
+    target2 = "/more.html"
+    an = ROBundle::Annotation.new(target1)
+
+    assert_equal target1, an.target
+    an.add_target(target2)
+    assert an.annotates?("/more.html")
+    assert_equal [target1, target2], an.target
+    an.add_target(@target)
+    assert an.annotates?("/")
+    assert an.annotates?("/file.txt")
+    assert_equal [target1, target2] + @target, an.target
+  end
+
+  def test_remove_target
+    an = ROBundle::Annotation.new(@json)
+
+    assert an.target.instance_of?(Array)
+    assert_equal 2, an.target.length
+    rem = an.remove_target("/")
+    assert an.edited?
+    refute an.annotates?("/")
+    assert_equal "/", rem
+    assert an.target.instance_of?(String)
+    assert_equal "/file.txt", an.target
+  end
+
 end

data/test/tc_create.rb

@@ -1,5 +1,5 @@
 #------------------------------------------------------------------------------
-# Copyright (c) 2014 The University of Manchester, UK.
+# Copyright (c) 2014, 2015 The University of Manchester, UK.
 #
 # BSD Licenced. See LICENCE.rdoc for details.
 #
@@ -15,6 +15,20 @@ require "helpers/list_tests"
 class TestCreation < Test::Unit::TestCase
 
   def test_create_empty_bundle
+    Dir.mktmpdir do |dir|
+      filename = File.join(dir, "test.bundle")
+
+      bundle = ROBundle::File.create(filename)
+      refute bundle.commit_required?
+      bundle.close
+
+      assert_nothing_raised(ZipContainer::MalformedContainerError, ZipContainer::Error) do
+        ROBundle::File.verify!(filename)
+      end
+    end
+  end
+
+  def test_check_empty_bundle
     Dir.mktmpdir do |dir|
       filename = File.join(dir, "test.bundle")
 
@@ -32,16 +46,12 @@ class TestCreation < Test::Unit::TestCase
             b.id
           end
 
-          # Manifest has been accessed so has been populated with defaults.
-          assert b.commit_required?
-
-          b.file.open(".ro/manifest.json", "w") do |m|
-            m.puts "{ }"
-          end
+          # Manifest has been accessed but not changed.
+          refute b.commit_required?
         end
       end
 
-      assert_nothing_raised(ZipContainer::MalformedContainerError, ZipContainer::ZipError) do
+      assert_nothing_raised(ZipContainer::MalformedContainerError, ZipContainer::Error) do
         ROBundle::File.verify!(filename)
       end
     end
@@ -56,10 +66,10 @@ class TestCreation < Test::Unit::TestCase
       entry3 = "test3.json"
 
       assert_nothing_raised do
-        ROBundle::File.create(filename) do |b|
+        bundle = ROBundle::File.create(filename) do |b|
           assert b.aggregates.empty?
           assert_nil b.find_entry(entry1)
-          assert b.commit_required?
+          refute b.commit_required?
 
           agg = b.add(entry1, $man_ex3, :aggregate => false)
           assert b.aggregates.empty?
@@ -80,6 +90,8 @@ class TestCreation < Test::Unit::TestCase
           b.add_aggregate(new_agg)
           assert b.aggregate?(entry1)
         end
+
+        refute bundle.commit_required?
       end
 
       ROBundle::File.open(filename) do |b|
@@ -106,7 +118,7 @@ class TestCreation < Test::Unit::TestCase
       entry2 = URI.parse(entry1)
 
       assert_nothing_raised do
-        ROBundle::File.create(filename) do |b|
+        bundle = ROBundle::File.create(filename) do |b|
           agg = b.add_aggregate(entry1)
           assert b.aggregate?(entry1)
           assert_nil b.find_entry(entry1)
@@ -115,7 +127,10 @@ class TestCreation < Test::Unit::TestCase
           b.add_aggregate(entry2)
           assert b.aggregate?(entry2)
           assert_nil b.find_entry(entry2)
+          assert b.commit_required?
         end
+
+        refute bundle.commit_required?
       end
 
       ROBundle::File.open(filename) do |b|
@@ -139,7 +154,7 @@ class TestCreation < Test::Unit::TestCase
       entry2 = ".ro/test2.json"
 
       assert_nothing_raised do
-        ROBundle::File.create(filename) do |b|
+        bundle = ROBundle::File.create(filename) do |b|
           assert b.history.empty?
           assert_nil b.find_entry(entry1)
 
@@ -152,7 +167,10 @@ class TestCreation < Test::Unit::TestCase
 
           b.add_history(entry1)
           assert entry_in_history_list(entry1, b.history)
+          assert b.commit_required?
         end
+
+        refute bundle.commit_required?
       end
 
       ROBundle::File.open(filename) do |b|

data/test/tc_manifest.rb

@@ -1,5 +1,5 @@
 #------------------------------------------------------------------------------
-# Copyright (c) 2014 The University of Manchester, UK.
+# Copyright (c) 2014, 2015 The University of Manchester, UK.
 #
 # BSD Licenced. See LICENCE.rdoc for details.
 #
@@ -50,7 +50,7 @@ class TestManifest < Test::Unit::TestCase
   end
 
   def test_ensure_copied_lists
-    %w(authored_by history aggregates annotations).map(&:to_sym).each do |m|
+    %w(authored_by history).map(&:to_sym).each do |m|
       list = @manifest.send(m)
       list << "new item"
       assert_not_equal list, @manifest.send(m)
@@ -77,6 +77,22 @@ class TestManifest < Test::Unit::TestCase
     assert @manifest.edited?
   end
 
+  def test_change_aggregate
+    change = @manifest.aggregates[0]
+    change.add_author "Robert Haines"
+
+    assert @manifest.aggregates[0].edited?
+    assert @manifest.edited?
+  end
+
+  def test_change_annotation
+    change = @manifest.annotations[1]
+    change.content = "http://example.com/different"
+
+    assert @manifest.annotations[1].edited?
+    assert @manifest.edited?
+  end
+
   def test_remove_annotation_by_object
     remove = @manifest.annotations[0]
     assert_equal 3, @manifest.annotations.length
@@ -218,4 +234,11 @@ class TestManifest < Test::Unit::TestCase
     end
   end
 
+  def test_manifest_graph_statement_preserved
+    manifest = FakeManifest.new($man_ex6)
+
+    json = JSON.parse(JSON.generate(manifest))
+    assert_not_nil json["@graph"]
+  end
+
 end