ro-bundle 0.1.0

data/test/tc_agent.rb

@@ -0,0 +1,63 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2014 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+require 'test/unit'
+require "ro-bundle"
+
+class TestAgent < Test::Unit::TestCase
+
+  def setup
+    @name = "Robert Haines"
+    @uri = "https://github.com/hainesr"
+    @orcid = "http://orcid.org/0000-0002-9538-7919"
+
+    @json = { :name => @name, :uri => @uri, :orcid => @orcid }
+  end
+
+  def test_create_from_json_hash
+    agent = ROBundle::Agent.new(@json)
+
+    assert_equal @name, agent.name
+    assert_equal @uri, agent.uri
+    assert_equal @orcid, agent.orcid
+  end
+
+  def test_create_from_empty_json_hash
+    agent = ROBundle::Agent.new({})
+
+    assert_nil agent.name
+    assert_nil agent.uri
+    assert_nil agent.orcid
+  end
+
+  def test_create_from_parameters
+    agent = ROBundle::Agent.new(@name, @uri, @orcid)
+
+    assert_equal @name, agent.name
+    assert_equal @uri, agent.uri
+    assert_equal @orcid, agent.orcid
+  end
+
+  def test_create_from_parameters_with_uris
+    agent = ROBundle::Agent.new(@name, URI.parse(@uri), URI.parse(@orcid))
+
+    assert_equal @name, agent.name
+    assert_equal @uri, agent.uri
+    assert_equal @orcid, agent.orcid
+  end
+
+  def test_json_output
+    agent = ROBundle::Agent.new(@json)
+    json = JSON.parse(JSON.generate(agent))
+
+    assert_equal @name, json["name"]
+    assert_equal @uri, json["uri"]
+    assert_equal @orcid, json["orcid"]
+  end
+
+end

data/test/tc_aggregate.rb

@@ -0,0 +1,116 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2014 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+
+require 'test/unit'
+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
+  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
+  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
+  end
+
+  def test_bad_aggregates
+    assert_raise(ROBundle::InvalidAggregateError) do
+      ROBundle::Aggregate.new([])
+    end
+
+    assert_raise(ROBundle::InvalidAggregateError) do
+      ROBundle::Aggregate.new({})
+    end
+  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
+  end
+
+  def test_complex_uri
+    assert_nothing_raised(ROBundle::InvalidAggregateError) do
+      uri = "http://example.com/good.txt"
+
+      json = {
+        :uri => uri
+      }
+
+      agg = ROBundle::Aggregate.new(json)
+
+      assert_nil agg.file
+      assert_nil agg.mediatype
+      assert_equal uri, agg.uri
+    end
+  end
+
+  def test_json_output_file
+    file = "/good.txt"
+    type = "text/plain"
+    time = "2013-02-12T19:37:32.939Z"
+    json = {
+      :file => file,
+      :mediatype => type,
+      :createdOn => time,
+      :createdBy => { :name => "Robert Haines" }
+    }
+
+    agg = ROBundle::Aggregate.new(json)
+    json = JSON.parse(JSON.generate(agg))
+
+    assert_equal file, json["file"]
+    assert_equal type, json["mediatype"]
+    assert_equal time, json["createdOn"]
+  end
+
+end

data/test/tc_annotation.rb

@@ -0,0 +1,84 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2014 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+require 'test/unit'
+require "ro-bundle"
+
+class TestAnnotation < Test::Unit::TestCase
+
+  def setup
+    @target = [ "/", "/file.txt" ]
+    @content = "http://www.example.com/example.txt"
+    @id = UUID.generate(:urn)
+    @creator = "Robert Haines"
+    @time = "2014-08-20T11:30:00+01:00"
+
+    @json = {
+      :about => @target,
+      :content => @content,
+      :annotation => @id,
+      :createdBy => { :name => @creator },
+      :createdOn => @time
+    }
+  end
+
+  def test_create
+    an = ROBundle::Annotation.new(@target)
+
+    assert_equal @target, an.target
+    assert_nil an.content
+    assert_not_nil an.annotation_id
+  end
+
+  def test_create_with_content
+    an = ROBundle::Annotation.new(@target, @content)
+
+    assert_equal @target, an.target
+    assert_equal @content, an.content
+    assert_not_nil an.annotation_id
+  end
+
+  def test_create_from_json
+    an = ROBundle::Annotation.new(@json)
+
+    assert_equal @target, an.target
+    assert_equal @content, an.content
+    assert_equal @id, an.annotation_id
+    assert an.created_on.instance_of?(Time)
+    assert an.created_by.instance_of?(ROBundle::Agent)
+  end
+
+  def test_change_content
+    an = ROBundle::Annotation.new(@json)
+    new_content = "/file.txt"
+    an.content = new_content
+
+    assert_equal new_content, an.content
+  end
+
+  def test_generate_annotation_id
+    an = ROBundle::Annotation.new(@target)
+    id = an.annotation_id
+
+    assert id.instance_of?(String)
+    assert id.start_with?("urn:uuid:")
+    assert_same id, an.annotation_id
+  end
+
+  def test_json_output
+    agent = ROBundle::Annotation.new(@json)
+    json = JSON.parse(JSON.generate(agent))
+
+    assert_equal @target, json["about"]
+    assert_equal @content, json["content"]
+    assert_equal @id, json["annotation"]
+    assert_equal @time, json["createdOn"]
+    assert_equal @creator, json["createdBy"]["name"]
+  end
+
+end

data/test/tc_create.rb

@@ -0,0 +1,170 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2014 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+require "test/unit"
+require "tmpdir"
+require "ro-bundle"
+
+require "helpers/list_tests"
+
+class TestCreation < Test::Unit::TestCase
+
+  def test_create_empty_bundle
+    Dir.mktmpdir do |dir|
+      filename = File.join(dir, "test.bundle")
+
+      assert_nothing_raised do
+        ROBundle::File.create(filename) do |b|
+          assert(b.on_disk?)
+          refute(b.in_memory?)
+          refute b.commit_required?
+
+          assert(b.find_entry("mimetype").local_header_offset == 0)
+          assert_equal("application/vnd.wf4ever.robundle+zip", b.mimetype)
+
+          # Try and get something from the manifest before it exists
+          assert_nothing_raised(Errno::ENOENT) do
+            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
+        end
+      end
+
+      assert_nothing_raised(ZipContainer::MalformedContainerError, ZipContainer::ZipError) do
+        ROBundle::File.verify!(filename)
+      end
+    end
+  end
+
+  def test_add_file_aggregates
+    Dir.mktmpdir do |dir|
+      filename = File.join(dir, "test.bundle")
+
+      entry1 = "test1.json"
+      entry2 = "test2.json"
+      entry3 = "test3.json"
+
+      assert_nothing_raised do
+        ROBundle::File.create(filename) do |b|
+          assert b.aggregates.empty?
+          assert_nil b.find_entry(entry1)
+          assert b.commit_required?
+
+          agg = b.add(entry1, $man_ex3, :aggregate => false)
+          assert b.aggregates.empty?
+          assert_not_nil b.find_entry(entry1)
+          assert b.commit_required?
+          assert_nil agg
+
+          agg = b.add(entry2, $man_ex3)
+          assert b.aggregate?(entry2)
+          assert_not_nil b.find_entry(entry2)
+          assert agg.instance_of?(ROBundle::Aggregate)
+
+          b.add_aggregate(entry3, $man_ex3)
+          assert b.aggregate?(entry3)
+          assert_not_nil b.find_entry(entry3)
+
+          new_agg = ROBundle::Aggregate.new("/#{entry1}")
+          b.add_aggregate(new_agg)
+          assert b.aggregate?(entry1)
+        end
+      end
+
+      ROBundle::File.open(filename) do |b|
+        refute b.aggregates.empty?
+        refute b.commit_required?
+
+        assert b.aggregate?(entry1)
+        assert_not_nil b.find_entry(entry1)
+
+        assert b.aggregate?(entry2)
+        assert_not_nil b.find_entry(entry2)
+
+        assert b.aggregate?(entry3)
+        assert_not_nil b.find_entry(entry3)
+      end
+    end
+  end
+
+  def test_add_uri_aggregates
+    Dir.mktmpdir do |dir|
+      filename = File.join(dir, "test.bundle")
+
+      entry1 = "http://www.example.com/example"
+      entry2 = URI.parse(entry1)
+
+      assert_nothing_raised do
+        ROBundle::File.create(filename) do |b|
+          agg = b.add_aggregate(entry1)
+          assert b.aggregate?(entry1)
+          assert_nil b.find_entry(entry1)
+          assert agg.instance_of?(ROBundle::Aggregate)
+
+          b.add_aggregate(entry2)
+          assert b.aggregate?(entry2)
+          assert_nil b.find_entry(entry2)
+        end
+      end
+
+      ROBundle::File.open(filename) do |b|
+        refute b.aggregates.empty?
+        refute b.commit_required?
+
+        assert b.aggregate?(entry1)
+        assert_nil b.find_entry(entry1)
+
+        assert b.aggregate?(entry2)
+        assert_nil b.find_entry(entry2)
+      end
+    end
+  end
+
+  def test_add_history
+    Dir.mktmpdir do |dir|
+      filename = File.join(dir, "test.bundle")
+
+      entry1 = "test1.json"
+      entry2 = ".ro/test2.json"
+
+      assert_nothing_raised do
+        ROBundle::File.create(filename) do |b|
+          assert b.history.empty?
+          assert_nil b.find_entry(entry1)
+
+          b.add(entry1, $man_ex3, :aggregate => false)
+          assert_not_nil b.find_entry(entry1)
+
+          b.add_history(entry2, $man_ex3)
+          assert_not_nil b.find_entry(entry2)
+          assert entry_in_history_list(entry2, b.history)
+
+          b.add_history(entry1)
+          assert entry_in_history_list(entry1, b.history)
+        end
+      end
+
+      ROBundle::File.open(filename) do |b|
+        refute b.history.empty?
+
+        assert entry_in_history_list(entry1, b.history)
+        assert_not_nil b.find_entry(entry1)
+
+        assert_not_nil b.find_entry(entry2)
+        assert entry_in_history_list(entry2, b.history)
+      end
+    end
+  end
+
+end

data/test/tc_manifest.rb

@@ -0,0 +1,221 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2014 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+require 'test/unit'
+require "ro-bundle"
+require "helpers/fake_manifest"
+
+class TestManifest < Test::Unit::TestCase
+
+  def setup
+    @manifest = FakeManifest.new($man_ex3)
+  end
+
+  def test_top_level
+    assert @manifest.context.instance_of?(Array)
+
+    assert_equal("/", @manifest.id)
+
+    assert @manifest.created_on.instance_of?(Time)
+    assert_nil @manifest.authored_on
+
+    creator = @manifest.created_by
+    assert creator.instance_of?(ROBundle::Agent)
+
+    authors = @manifest.authored_by
+    assert authors.instance_of?(Array)
+
+    history = @manifest.history
+    assert history.instance_of?(Array)
+    history.each do |h|
+      assert h.instance_of?(String)
+    end
+
+    aggregates = @manifest.aggregates
+    assert aggregates.instance_of?(Array)
+    aggregates.each do |a|
+      assert a.instance_of?(ROBundle::Aggregate)
+    end
+
+    annotations = @manifest.annotations
+    assert annotations.instance_of?(Array)
+    annotations.each do |a|
+      assert a.instance_of?(ROBundle::Annotation)
+    end
+  end
+
+  def test_ensure_copied_lists
+    %w(authored_by history aggregates annotations).map(&:to_sym).each do |m|
+      list = @manifest.send(m)
+      list << "new item"
+      assert_not_equal list, @manifest.send(m)
+    end
+  end
+
+  def test_change_context
+    old = @manifest.context
+    context = "http://example.com/context"
+    @manifest.add_context(context)
+
+    assert @manifest.context.include?(context)
+    assert @manifest.context.include?(old[0])
+    assert_equal old[0], @manifest.context[1]
+    assert @manifest.edited?
+  end
+
+  def test_change_id
+    old = @manifest.id
+    @manifest.id = "/new"
+
+    assert_equal "/new", @manifest.id
+    assert_not_equal old, @manifest.id
+    assert @manifest.edited?
+  end
+
+  def test_remove_annotation_by_object
+    remove = @manifest.annotations[0]
+    assert_equal 3, @manifest.annotations.length
+
+    @manifest.remove_annotation(remove)
+    assert_equal 1, @manifest.annotations.length
+    assert @manifest.edited?
+
+    @manifest.remove_annotation(remove)
+    assert_equal 1, @manifest.annotations.length
+    assert @manifest.edited?
+  end
+
+  def test_remove_annotation_by_id
+    id = "urn:uuid:d67466b4-3aeb-4855-8203-90febe71abdf"
+    assert_equal 3, @manifest.annotations.length
+
+    @manifest.remove_annotation(id)
+    assert_equal 1, @manifest.annotations.length
+    assert @manifest.edited?
+
+    @manifest.remove_annotation(id)
+    assert_equal 1, @manifest.annotations.length
+    assert @manifest.edited?
+  end
+
+  def test_remove_annotation_by_about
+    about = "/folder/soup.jpeg"
+    assert_equal 3, @manifest.annotations.length
+
+    @manifest.remove_annotation(about)
+    assert_equal 1, @manifest.annotations.length
+    assert @manifest.edited?
+
+    @manifest.remove_annotation(about)
+    assert_equal 1, @manifest.annotations.length
+    assert @manifest.edited?
+  end
+
+  def test_remove_non_existent_annotations
+    about = "not-here!"
+    id = about
+    assert_equal 3, @manifest.annotations.length
+
+    @manifest.remove_annotation(about)
+    assert_equal 3, @manifest.annotations.length
+    refute @manifest.edited?
+
+    @manifest.remove_annotation(id)
+    assert_equal 3, @manifest.annotations.length
+    refute @manifest.edited?
+  end
+
+  def test_remove_aggregate_by_object
+    remove = @manifest.aggregates[0]
+    assert_equal 4, @manifest.aggregates.length
+    assert_equal 3, @manifest.annotations.length
+
+    @manifest.remove_aggregate(remove)
+    assert_equal 3, @manifest.aggregates.length
+    assert_equal 1, @manifest.annotations.length
+    assert @manifest.edited?
+
+    @manifest.remove_aggregate(remove)
+    assert_equal 3, @manifest.aggregates.length
+    assert_equal 1, @manifest.annotations.length
+    assert @manifest.edited?
+  end
+
+  def test_remove_aggregate_by_file
+    remove = "/folder/soup.jpeg"
+    assert_equal 4, @manifest.aggregates.length
+    assert_equal 3, @manifest.annotations.length
+
+    @manifest.remove_aggregate(remove)
+    assert_equal 3, @manifest.aggregates.length
+    assert_equal 1, @manifest.annotations.length
+    assert @manifest.edited?
+
+    @manifest.remove_aggregate(remove)
+    assert_equal 3, @manifest.aggregates.length
+    assert_equal 1, @manifest.annotations.length
+    assert @manifest.edited?
+  end
+
+  def test_remove_aggregate_by_uri
+    remove = "http://example.com/blog/"
+    assert_equal 4, @manifest.aggregates.length
+    assert_equal 3, @manifest.annotations.length
+
+    @manifest.remove_aggregate(remove)
+    assert_equal 3, @manifest.aggregates.length
+    assert_equal 3, @manifest.annotations.length
+    assert @manifest.edited?
+
+    @manifest.remove_aggregate(remove)
+    assert_equal 3, @manifest.aggregates.length
+    assert_equal 3, @manifest.annotations.length
+    assert @manifest.edited?
+  end
+
+  def test_remove_non_existent_aggregates
+    file = "not-here!"
+    uri = "http://example.com/not-here"
+    assert_equal 4, @manifest.aggregates.length
+
+    @manifest.remove_aggregate(file)
+    assert_equal 4, @manifest.aggregates.length
+    refute @manifest.edited?
+
+    @manifest.remove_aggregate(uri)
+    assert_equal 4, @manifest.aggregates.length
+    refute @manifest.edited?
+  end
+
+  def test_empty_manifest
+    manifest = FakeManifest.new($man_empty)
+
+    assert manifest.context.instance_of?(Array)
+    assert manifest.edited?
+
+    assert_equal("/", manifest.id)
+
+    assert_nil manifest.created_on
+    assert_nil manifest.authored_on
+    assert_nil manifest.created_by
+    assert manifest.authored_by.instance_of?(Array)
+
+    assert manifest.history.instance_of?(Array)
+    assert manifest.aggregates.instance_of?(Array)
+    assert manifest.annotations.instance_of?(Array)
+  end
+
+  def test_invalid_manifest
+    manifest = FakeManifest.new($man_invalid)
+
+    assert_raises(JSON::ParserError) do
+      assert manifest.context.instance_of?(Array)
+    end
+  end
+
+end