rtm 0.3.0 → 0.3.1

data/spec/rtm/axes/topic_spec.rb

@@ -50,11 +50,11 @@ module RTM::Axes
     it "should be allowed to call #subtypes on a RTM::Axes::Topic" do
       @proxy.methods.should include("subtypes")
     end
-    it "should be allowed to call #reverse_subtypes on a RTM::Axes::Topic" do
-      @proxy.methods.should include("reverse_subtypes")
+    it "should not be allowed to call #reverse_subtypes on a RTM::Axes::Topic" do
+      @proxy.methods.should_not include("reverse_subtypes")
     end
-    it "should be allowed to call #reverse_supertypes on a RTM::Axes::Topic" do
-      @proxy.methods.should include("reverse_supertypes")
+    it "should not be allowed to call #reverse_supertypes on a RTM::Axes::Topic" do
+      @proxy.methods.should_not include("reverse_supertypes")
     end
     it "should be allowed to call #traverse on a RTM::Axes::Topic" do
       @proxy.methods.should include("traverse")

data/spec/rtm/axes/topics_spec.rb

@@ -53,11 +53,11 @@ module RTM::Axes
     it "should be allowed to call #subtypes on a RTM::TQML::Topics" do
       @proxy.methods.should include("subtypes")
     end
-    it "should be allowed to call #reverse_subtypes on a RTM::TQML::Topics" do
-      @proxy.methods.should include("reverse_subtypes")
+    it "should not be allowed to call #reverse_subtypes on a RTM::TQML::Topics" do
+      @proxy.methods.should_not include("reverse_subtypes")
     end
-    it "should be allowed to call #reverse_supertypes on a RTM::TQML::Topics" do
-      @proxy.methods.should include("reverse_supertypes")
+    it "should not be allowed to call #reverse_supertypes on a RTM::TQML::Topics" do
+      @proxy.methods.should_not include("reverse_supertypes")
     end
     it "should be allowed to call #traverse on a RTM::TQML::Topics" do
       @proxy.methods.should include("traverse")

data/spec/rtm/engine_spec.rb

@@ -10,7 +10,7 @@ module RTM
 
       describe "#identifier" do
         before(:all) do
-          @connection = RTM.connect(:implementation => implementation_for_spec)
+          @connection = get_used_tm_sys
           @tested = false
         end
         it "should return :ontopia if ontopia is used" do
@@ -32,6 +32,15 @@ module RTM
           elsif implementation_for_spec == :sesametm
             @connection.identifier.should == :sesametm
             @tested = true
+          elsif implementation_for_spec == :majortom
+            @connection.identifier.should == :majortom
+            @tested = true
+          elsif implementation_for_spec == :majortom_db
+            @connection.identifier.should == :majortom
+            @tested = true
+          elsif implementation_for_spec == :couchtm
+            @connection.identifier.should == :couchtm
+            @tested = true
           else
             # engine not found
           end

data/spec/rtm/io/tmapix_from_spec.rb

@@ -8,38 +8,68 @@ module RTM::IO::TmapiXFrom::TopicMap
   describe self do
     before(:each) do
       @tm = get_used_tm_sys_tm
+      @tm.topics.should be_empty
+      @tm.associations.should be_empty
+      @tm.names.should be_empty
+      @tm.occurrences.should be_empty
+      @tm.variants.should be_empty
+      @tm.roles.should be_empty
+      @test_size = false
     end
     after(:each) do
+      if @test_size
+        # This is just for testing if approx. everything was imported
+        @tm.topics.size.should >= 117
+        @tm.associations.size.should >= 58
+        @tm.names.size.should >= 169
+        @tm.occurrences.size.should == 28
+        @tm.variants.size.should == 44
+        @tm.roles.size.should >= 131
+      end
       @tm.close
     end
 
     describe "#from_ltm" do
       it "should import into an empty topic map" do
         @tm.from_ltm(File.dirname(__FILE__) + "/../../resources/toyTM.ltm")
+#        @tm.occurrences.each do |o|
+#          puts "Occurrence:"
+#          puts "Type: " + o.type.reference
+#          puts "Parent: " + o.parent.reference
+#        end
+        #@test_size = true
+      end
+      it "should load the pokemon.ltm map" do
+        @tm.from_ltm(File.dirname(__FILE__) + "/../../resources/pokemon.ltm")
       end
     end
 
     describe "#from_ctm" do
       it "should import into an empty topic map" do
         @tm.from_ctm(File.dirname(__FILE__) + "/../../resources/toyTM.ctm")
+        @test_size = true
       end
     end
 
     describe "#from_jtm" do
       it "should import into an empty topic map" do
-        #@tm.from_jtm(File.dirname(__FILE__) + "/../../resources/toyTM.jtm")
+        @tm.from_jtm(File.dirname(__FILE__) + "/../../resources/toyTM.jtm")
+        @test_size = true
       end
     end
 
     describe "#from_tmxml" do
       it "should import into an empty topic map" do
-        #@tm.from_tmxml(File.dirname(__FILE__) + "/../../resources/toyTM.tmxml")
+        pending "not working" do
+          @tm.from_tmxml(File.dirname(__FILE__) + "/../../resources/toyTM.tmxml")
+        end
       end
     end
 
     describe "#from_xtm10" do
       it "should import into an empty topic map" do
-        #@tm.from_xtm10(File.dirname(__FILE__) + "/../../resources/toyTM_xtm10.xtm")
+        @tm.from_xtm10(File.dirname(__FILE__) + "/../../resources/toyTM_xtm10.xtm")
+        @test_size = true
       end
       it "should provide an alias for from_xtm1" do
         @tm.method(:from_xtm1).should == @tm.method(:from_xtm10)
@@ -48,19 +78,21 @@ module RTM::IO::TmapiXFrom::TopicMap
 
     describe "#from_xtm20" do
       it "should import into an empty topic map" do
-        @tm.from_xtm20(File.dirname(__FILE__) + "/../../resources/toyTM.xtm")
+        @tm.from_xtm20(File.dirname(__FILE__) + "/../../resources/toyTM_xtm20.xtm")
+        @test_size = true
       end
       it "should provide an alias for from_xtm2" do
         @tm.method(:from_xtm2).should == @tm.method(:from_xtm20)
       end
     end
 
-    describe "#from_xtm" do
-      it "should import into an empty topic map from xtm v2.0" do
-        @tm.from_xtm20(File.dirname(__FILE__) + "/../../resources/toyTM.xtm")
+    describe "#from_xtm21" do
+      it "should import into an empty topic map from xtm v2.1" do
+        @tm.from_xtm21(File.dirname(__FILE__) + "/../../resources/toyTM.xtm")
+        @test_size = true
       end
-      it "should import into an empty topic map from xtm v1.0" do
-        #@tm.from_xtm10(File.dirname(__FILE__) + "/../../resources/toyTM_xtm10.xtm")
+      it "should provide an alias for from_xtm2" do
+        @tm.method(:from_xtm).should == @tm.method(:from_xtm20)
       end
     end
 

data/spec/rtm/io/tmapix_to_spec.rb

@@ -13,9 +13,33 @@ module RTM::IO::TmapiXTo::TopicMap
       @tm.close
     end
 
+    describe "#to_xtm21" do
+      before(:each) do
+        @tm.from_jtm(File.dirname(__FILE__) + "/../../resources/toyTM.jtm")
+      end
+      it "should serialize a topic map to String" do
+        @tm.to_xtm21.should be_a_kind_of String
+      end
+      it "should serialize a topic map to a file" do
+        @tm.to_xtm21(File.dirname(__FILE__) + "/../../resources/toyTM_after_spec.xtm21").should be_true
+      end
+      it "should serialize a topic map to a file given a base iri" do
+        @tm.to_xtm21(File.dirname(__FILE__) + "/../../resources/toyTM_after_spec.xtm20", "http://www.example.org/testtm").should be_true
+      end
+      it "should serialize a topic map to a Java::JavaIo::Stream" do
+        @tm.to_xtm21(Java::JavaIo::ByteArrayOutputStream.new).should be_true
+      end
+      it "should be the case that the xtm21 writer does not respond to :setProperty" do
+        Java::OrgTmapixIo::XTM2TopicMapWriter.new(Java::JavaIo::ByteArrayOutputStream.new,"http://www.example.org/testtm",Java::OrgTmapixIo::XTMVersion::XTM_2_1).should_not respond_to(:setProperty)
+      end
+      it "should provide an alias for to_xtm" do
+        @tm.method(:to_xtm).should == @tm.method(:to_xtm21)
+      end
+    end
+
     describe "#to_xtm20" do
       before(:each) do
-        @tm.from_ctm(File.dirname(__FILE__) + "/../../resources/toyTM.ctm")
+        @tm.from_jtm(File.dirname(__FILE__) + "/../../resources/toyTM.jtm")
       end
       it "should serialize a topic map to String" do
         @tm.to_xtm20.should be_a_kind_of String
@@ -30,10 +54,7 @@ module RTM::IO::TmapiXTo::TopicMap
         @tm.to_xtm20(Java::JavaIo::ByteArrayOutputStream.new).should be_true
       end
       it "should be the case that the xtm20 writer does not respond to :setProperty" do
-        Java::OrgTmapixIo::XTM20TopicMapWriter.new(Java::JavaIo::ByteArrayOutputStream.new,"http://www.example.org/testtm").should_not respond_to(:setProperty)
-      end
-      it "should provide an alias for to_xtm" do
-        @tm.method(:to_xtm).should == @tm.method(:to_xtm20)
+        Java::OrgTmapixIo::XTM2TopicMapWriter.new(Java::JavaIo::ByteArrayOutputStream.new,"http://www.example.org/testtm",Java::OrgTmapixIo::XTMVersion::XTM_2_1).should_not respond_to(:setProperty)
       end
       it "should provide an alias for to_xtm2" do
         @tm.method(:to_xtm2).should == @tm.method(:to_xtm20)
@@ -42,7 +63,7 @@ module RTM::IO::TmapiXTo::TopicMap
 
     describe "#to_xtm10" do
       before(:each) do
-        @tm.from_ctm(File.dirname(__FILE__) + "/../../resources/toyTM.ctm")
+        @tm.from_jtm(File.dirname(__FILE__) + "/../../resources/toyTM.jtm")
       end
       it "should serialize a topic map to String" do
         @tm.to_xtm10.should be_a_kind_of String
@@ -66,7 +87,7 @@ module RTM::IO::TmapiXTo::TopicMap
 
     describe "#to_jtm" do
       before(:each) do
-        @tm.from_ctm(File.dirname(__FILE__) + "/../../resources/toyTM.ctm")
+        @tm.from_jtm(File.dirname(__FILE__) + "/../../resources/toyTM.jtm")
       end
       it "should serialize a topic map to String" do
         @tm.to_jtm.should be_a_kind_of String
@@ -83,14 +104,16 @@ module RTM::IO::TmapiXTo::TopicMap
       it "should be the case that the jtm writer does not respond to :setProperty" do
         Java::OrgTmapixIo::JTMTopicMapWriter.new(Java::JavaIo::ByteArrayOutputStream.new,"http://www.example.org/testtm").should_not respond_to(:setProperty)
       end
-      it "should provide an alias for to_json" do
-        @tm.method(:to_json).should == @tm.method(:to_jtm)
+      unless implementation_for_spec == :couchtm
+        it "should provide an alias for to_json" do
+          @tm.method(:to_json).should == @tm.method(:to_jtm)
+        end
       end
     end
 
     describe "#to_ltm" do
       before(:each) do
-        @tm.from_ctm(File.dirname(__FILE__) + "/../../resources/toyTM.ctm")
+        @tm.from_jtm(File.dirname(__FILE__) + "/../../resources/toyTM.jtm")
       end
       it "should serialize a topic map to String" do
         @tm.to_ltm.should be_a_kind_of String
@@ -109,30 +132,30 @@ module RTM::IO::TmapiXTo::TopicMap
       end
     end
 
-#    describe "#to_tmxml" do
-#      before(:each) do
-#        @tm.from_tmxml(File.dirname(__FILE__) + "/../../resources/toyTM.tmxml")
-#      end
-#      it "should serialize a topic map to String" do
-#        @tm.to_tmxml.should be_a_kind_of String
-#      end
-#      it "should serialize a topic map to a file" do
-#        @tm.to_tmxml(File.dirname(__FILE__) + "/../../resources/toyTM_after_spec.tmxml").should be_true
-#      end
-#      it "should serialize a topic map to a file given a base iri" do
-#        @tm.to_tmxml(File.dirname(__FILE__) + "/../../resources/toyTM_after_spec.tmxml", "http://www.example.org/testtm").should be_true
-#      end
-#      it "should serialize a topic map to a Java::JavaIo::Stream" do
-#        @tm.to_tmxml(Java::JavaIo::ByteArrayOutputStream.new).should be_true
-#      end
-#      it "should be the case that the tmxml writer does not respond to :setProperty" do
-#        Java::OrgTmapixIo::TMXMLTopicMapWriter.new(Java::JavaIo::ByteArrayOutputStream.new,"http://www.example.org/testtm").should_not respond_to(:setProperty)
-#      end
-#    end
+    describe "#to_tmxml" do
+      before(:each) do
+        @tm.from_jtm(File.dirname(__FILE__) + "/../../resources/toyTM.jtm")
+      end
+      it "should serialize a topic map to String" do
+        @tm.to_tmxml.should be_a_kind_of String
+      end
+      it "should serialize a topic map to a file" do
+        @tm.to_tmxml(File.dirname(__FILE__) + "/../../resources/toyTM_after_spec.tmxml").should be_true
+      end
+      it "should serialize a topic map to a file given a base iri" do
+        @tm.to_tmxml(File.dirname(__FILE__) + "/../../resources/toyTM_after_spec.tmxml", "http://www.example.org/testtm").should be_true
+      end
+      it "should serialize a topic map to a Java::JavaIo::Stream" do
+        @tm.to_tmxml(Java::JavaIo::ByteArrayOutputStream.new).should be_true
+      end
+      it "should be the case that the tmxml writer does not respond to :setProperty" do
+        Java::OrgTmapixIo::TMXMLTopicMapWriter.new(Java::JavaIo::ByteArrayOutputStream.new,"http://www.example.org/testtm").should_not respond_to(:setProperty)
+      end
+    end
 
-    describe "#to_ctm" do
+    describe "#to_jtm" do
       before(:each) do
-        @tm.from_xtm(File.dirname(__FILE__) + "/../../resources/toyTM.xtm")
+        @tm.from_jtm(File.dirname(__FILE__) + "/../../resources/toyTM.jtm")
       end
       it "should serialize a topic map to String" do
         @tm.to_ctm.should be_a_kind_of String
@@ -151,6 +174,9 @@ module RTM::IO::TmapiXTo::TopicMap
       end
       it "should read it afterwards" do
         emptyTM = get_used_tm_sys.create("http://blub.org/")
+        if implementation_for_spec == :majortom_db
+          emptyTM.clear
+        end
         emptyTM.from_ctm(File.dirname(__FILE__) + "/../../resources/toyTM_after_spec.ctm")
       end
     end

data/spec/rtm/io/to_rdf_spec.rb

@@ -8,7 +8,7 @@ module RTM::IO::ToRDF::TopicMap
   describe self do
     before(:each) do
       @tm = get_used_tm_sys_tm
-      @tm.from_ctm(File.dirname(__FILE__) + "/../../resources/toyTM.ctm")
+      @tm.from_jtm(File.dirname(__FILE__) + "/../../resources/toyTM.jtm")
     end
     after(:each) do
       @tm.close
@@ -17,8 +17,10 @@ module RTM::IO::ToRDF::TopicMap
     describe "#to_rdf" do
       it "should be callable on an Ontopia topic map" do
         if implementation_for_spec == :ontopia
-          lambda{@tm.to_rdf}.should_not raise_error
-          @tm.to_rdf.should be_a_kind_of String
+          pending "should fail wihtout lucene" do
+            lambda{@tm.to_rdf}.should_not raise_error
+            @tm.to_rdf.should be_a_kind_of String
+          end
         else
           lambda{@tm.to_rdf}.should raise_error
         end
@@ -28,7 +30,9 @@ module RTM::IO::ToRDF::TopicMap
     describe "#to_rdf_ontopia" do
       it "should be callable on an Ontopia topic map" do
         if implementation_for_spec == :ontopia
-          @tm.to_rdf_ontopia.should be_a_kind_of String
+          pending "should fail wihtout lucene" do
+            @tm.to_rdf_ontopia.should be_a_kind_of String
+          end
         end
       end
     end

data/spec/rtm/javatmapi_spec.rb

@@ -6,28 +6,27 @@ require File.dirname(__FILE__) + '/../spec_helper'
 module RTM
 
   describe "JavaTMAPI" do
+    before(:each) do
+      @base_iri = "http://www.exampl.org/test/"
+      @engine = get_used_tm_sys
+      @tm = @engine.create(@base_iri)
+    end
 
     describe "#create" do
       it "should give always give back the same topic map" do
-        tm_identifier = "http://www.exampl.org/test/"
-        engine = RTM.connect(:implementation => implementation_for_spec)
-        tm = engine.create(tm_identifier)
         1000.times do
-          tm_other = engine.create(tm_identifier)
-          tm_other.should == tm
+          tm_other = @engine.create(@base_iri)
+          tm_other.should == @tm
           tm_other.engine.should_not be_nil
           tm_other.prefixes.should_not be_empty
         end
       end
-      it "should raise an error if topic map identifier is relative" do
-        tm_identifier = "www.exampl.org/test/"
-        engine = RTM.connect(:implementation => implementation_for_spec)
+      it "should raise an error if the topic map base_iri is relative" do
+        rel_base_iri = "www.exampl.org/test/"
         if implementation_for_spec == :tinytim
-          pending do
-            lambda{engine.create(tm_identifier)}.should raise_error
-          end
+          lambda{@engine.create(rel_base_iri)}.should_not raise_error
         else
-          lambda{engine.create(tm_identifier)}.should raise_error
+          lambda{@engine.create(rel_base_iri)}.should raise_error
         end
       end
       it "should be tested"
@@ -35,30 +34,41 @@ module RTM
 
     describe "#delete" do
       it "should delete a topic map" do
-        tm_identifier = "http://www.exampl.org/test/"
-        engine = RTM.connect(:implementation => implementation_for_spec)
-        tm = engine.create(tm_identifier)
-        tm.should be_a_kind_of RTM::TopicMap
-        tm.create_topic
-        tm.create_association(tm.create_topic)
-        engine.tms.getTopicMap(tm_identifier).should_not be_nil
-        engine.delete(tm_identifier)
-        engine.tms.getTopicMap(tm_identifier).should be_nil
+        @tm.should be_a_kind_of RTM::TopicMap
+        @tm.create_topic
+        @tm.create_association(@tm.create_topic)
+        @engine.tms.getTopicMap(@base_iri).should_not be_nil
+        @engine.delete(@base_iri)
+        @engine.tms.getTopicMap(@base_iri).should be_nil
+      end
+      it "should delete the toyTM" do
+        @tm.from_xtm(File.dirname(__FILE__) + "/../resources/toyTM.xtm")
+        @engine.delete(@base_iri)
       end
     end
 
     describe "#existing?" do
       it "should tell if the map is existing" do
-        tm_identifier = "http://www.exampl.org/test/"
-        engine = RTM.connect(:implementation => implementation_for_spec)
-        engine.existing?(tm_identifier).should_not be_true
-        tm = engine.create(tm_identifier)
-        engine.existing?(tm_identifier).should be_true
-        engine.delete(tm_identifier)
-        engine.existing?(tm_identifier).should_not be_true
+        @engine.existing?("http://not.existing").should_not be_true
+        @engine.existing?(@base_iri).should be_true
+        @engine.delete(@base_iri)
+        @engine.existing?(@base_iri).should_not be_true
       end
     end
-      
+
+    describe "#topic_map" do
+      it "should return nil if no topic map exists with the given base_iri" do
+        @engine.topic_map("http://not.existing").should be_nil
+        @engine.topic_map(@engine.create_locator("http://also.not.existing")).should be_nil
+      end
+      it "should return the topic map if it is existing" do
+        tm = @engine.topic_map(@base_iri)
+        tm.should == @tm
+        tm.engine.should_not be_nil
+        tm.prefixes.should_not be_empty
+      end
+    end
+
   end # of describe self
     
 end

data/spec/rtm/navigation/topic/characteristics_spec.rb

@@ -20,7 +20,6 @@ module RTM::Navigation::Topic
         topic.characteristics.size.should == 0
         occ1 = topic.create_occurrence("Gruendungsjahr", "1409")
         topic.characteristics("super_Gruendungsjahr").size.should == 0
-        topic.characteristics("super_Gruendungsjahr").include?(occ1).should be_false
       end
       it "should give back the values of the Names and Occurrences included in Characteristics" do
         topic = @tm.create_topic_by("Uni_Leipzig")
@@ -31,21 +30,17 @@ module RTM::Navigation::Topic
         topic.characteristics.size.should == 4
         topic.characteristics.should include name1, name2, occ1, occ2
       end
-      
-      it "should give back  Names and Occurrences of the subtype of the given argument" do
-        topic = @tm.create_topic_by("Uni_Leipzig")
-        name1 = topic.create_name("a_type","Universität Leipzig")
-        @tm.get("a_type").add_supertype("a_super_type")
-        topic.names.size.should == 1
-        topic.names.first.type.should == @tm.get("a_type")
-        topic.names.first.type.supertypes.size.should == 1  
-        topic.names.first.type.supertypes.first.should == @tm.get("a_super_type") 
-        topic.characteristics("a_super_type").size.should == 1
-        topic.characteristics("a_super_type").include?(name1).should be_true
-        occ1 = topic.create_occurrence("Gruendungsjahr", "1409")
-        @tm.get("Gruendungsjahr").add_supertype("super_Gruendungsjahr")
-        topic.characteristics("super_Gruendungsjahr").size.should == 1
-        topic.characteristics("super_Gruendungsjahr").include?(occ1).should be_true
+
+      it "should give back  Names and Occurrences with a type of the subtype of the given argument" do
+        topic = @tm.get!("Uni_Leipzig")
+        name = topic.create_name("university name", "Universität Leipzig")
+        @tm.get!("name").add_subtype("university name")
+        topic.characteristics("name").size.should == 1
+        topic.characteristics("name").should include(name)
+        occ = topic.create_occurrence("Gruendungsjahr", "1409")
+        @tm.get!("Jahr").add_subtype("Gruendungsjahr")
+        topic.characteristics("Jahr").size.should == 1
+        topic.characteristics("Jahr").should include(occ)
       end
       
     end #of describe "#characteristics"