basuco 0.0.3

data/test/integration/ken_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+
+class KenTest < Test::Unit::TestCase
+  context "Ken.get" do
+    setup do
+      Ken::Session.new('http://www.freebase.com', 'ma', 'xxxxx')
+    end
+    
+    should 'return a Ken::Resource' do
+      the_police = Ken.get("/en/the_police")
+      the_police.should be_kind_of(Ken::Resource)
+    end
+    
+    should 'raise a Ken::ResourceNotFound error if id does not exist' do
+      lambda { Ken.get("/en/non_existent_resource") }.should raise_error(Ken::ResourceNotFound)
+    end
+  end
+  
+  context "Ken.all" do
+    should "return a Ken::Collection of Ken::Resources" do
+      resources = Ken.all(:name => "Apple")
+      resources.should be_kind_of(Ken::Collection)
+      resources.first.should be_kind_of(Ken::Resource)
+    end
+      
+    should "work with a limit specified" do
+      resources = Ken.all(:name => "Apple", :limit => 3)
+      resources.length.should == 3
+    end
+    
+    should "be able to return more than 100 resources (using cursored queries) " do
+      Ken.all({:type => '/chemistry/chemical_element'}).length.should > 100
+    end
+    
+    should "work with a type specified" do
+      resources = Ken.all(:name => "Apple", :type => "/music/album")
+      resources.length.should >= 1
+      resources.each {|r| r.types.select {|t| t.id == "/music/album"}.length.should == 1 }
+    end
+      
+    should "understand nested queries" do
+      query = {
+        :directed_by => "George Lucas",
+        :starring => [
+          {
+            :actor => "Harrison Ford"
+          }
+        ],
+        :type => "/film/film"
+      }
+  
+      resources = Ken.all(query)
+      resources.length.should == 3
+      resources.first.name.should == "Star Wars Episode IV: A New Hope"
+      resources.last.name.should == "The Star Wars Holiday Special"
+    end
+  end
+  
+  context "A Ken::Resource Instance" do
+    setup do
+      @the_police = Ken.get("/en/the_police")
+    end
+    
+    should "provide attributes" do
+      @the_police.attributes.length.should >= 1
+      @the_police.attributes.first.should be_kind_of(Ken::Attribute)
+    end
+    
+    should "have views" do
+      @the_police.views.length.should >= 1
+      @the_police.views.first.should be_kind_of(Ken::View)
+      @the_police.views.first.type.should be_kind_of(Ken::Type)
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'pathname'
+require 'json'
+require 'matchy'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+TEST_ROOT = Pathname(__FILE__).dirname.expand_path
+require TEST_ROOT.parent + 'lib/ken'
+
+def load_fixture(fixture_name)
+  fname = "#{File.dirname(__FILE__)}/fixtures/#{fixture_name}.json"
+  unless File.exists?(fname)
+    open(fname, "w") do |file|
+      puts "WARNING: Fixtures could not be loaded."
+    end
+  end
+  JSON.parse open(fname,"r").read
+end
+
+class Test::Unit::TestCase
+  custom_matcher :be_nil do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be nil but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be nil but it was"
+    receiver.nil?
+  end
+
+  custom_matcher :have do |receiver, matcher, args|
+    count = args[0]
+    something = matcher.chained_messages[0].name
+    actual = receiver.send(something).size
+    actual == count
+  end
+
+  custom_matcher :be_true do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be true but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be true but it was"
+    receiver.eql?(true)
+  end
+
+  custom_matcher :be_false do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be false but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be false but it was"
+    receiver.eql?(false)
+  end
+end
+
+class Object
+  # nice for debugging
+  # usage: print_call_stack(:method_name, 2, 10)
+  def print_call_stack(from = 2, to = nil, html = false)
+    (from..(to ? to : caller.length)).each do |idx|
+      p "[#{idx}]: #{caller[idx]}#{html ? '<br />' : ''}"
+    end
+  end
+end

data/test/unit/attribute_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class AttributeTest < Test::Unit::TestCase
+  context "An Attribute instance" do
+    setup do
+      data = load_fixture('the_police')
+      @the_police = Ken::Resource.new(data)
+      
+      @attribute = @unique_value_attribute = @the_police.views[0].active_start
+      @unique_object_attribute = @the_police.views[0].origin
+      @unique_object_attribute.unique?
+      @non_unique_value_attribute = @the_police.views[1].alias
+      @non_unique_object_attribute = @the_police.views[0].album
+    end
+  
+    should "should have values" do
+      @attribute.should have(1).values
+      @non_unique_object_attribute.should have(14).values
+    end
+    
+    context "with unique value type" do
+      should "be unique and no object_type" do
+        @unique_value_attribute.unique?.should == true
+        @unique_value_attribute.object_type?.should == false
+      end
+    end
+    
+    context "with unique object type" do
+      should "be unique and an object type" do
+        @unique_object_attribute.unique?.should == true
+        @unique_object_attribute.object_type?.should == true
+      end
+    end
+    
+    context "with non-unique value type" do
+      should "not be unique and not an object type" do
+        @non_unique_value_attribute.unique?.should == false
+        @non_unique_value_attribute.object_type?.should == false
+      end
+    end
+    
+    context "with non-unique object type" do
+      should "be unique and an object type" do
+        @non_unique_object_attribute.unique?.should == false
+        @non_unique_object_attribute.object_type?.should == true
+      end
+    end
+  end # context
+end # AttributeTest

data/test/unit/property_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class PropertyTest < Test::Unit::TestCase
+  context "A Property instance" do
+    setup do
+      data = load_fixture('music_artist')
+      @type = Ken::Type.new(data)
+      @value_property = @type.properties[1]
+      @object_property = @type.properties[3]
+    end
+    
+    should 'be a valid property instance' do
+      @value_property.should be_kind_of(Ken::Property)
+      @object_property.should be_kind_of(Ken::Property)
+    end
+  
+    should 'have a type' do
+      @value_property.type.should be_kind_of(Ken::Type)
+      @object_property.type.should be_kind_of(Ken::Type)
+    end
+  
+    should 'distinguish wheter it is an object or value type' do
+      @value_property.object_type?.should == false
+      @object_property.object_type?.should == true
+    end
+  end # context
+end # PropertyTest

data/test/unit/resource_test.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+class ResourceTest < Test::Unit::TestCase
+  context "A Resource instance" do
+    setup do
+      data = load_fixture('the_police')
+      @the_police = Ken::Resource.new(data)
+    end
+  
+    should "have types" do
+      @the_police.should have(6).types
+      @the_police.types.first.should be_kind_of(Ken::Type)
+    end
+    
+    should "have views" do
+      @the_police.should have(6).views
+      @the_police.views.first.should be_kind_of(Ken::View)
+      @the_police.views.first.type.should be_kind_of(Ken::Type)
+    end
+    
+    should "return individual view based requested type id" do
+      @the_police.view('/music/artist').should be_kind_of(Ken::View)
+      @the_police.view('/location/location').should be_nil # not existent view
+    end
+    
+    should "return individual type based requested type id" do
+      @the_police.type('/music/artist').should be_kind_of(Ken::Type)
+      @the_police.type('/location/location').should be_nil # not existent type
+    end
+    
+    should 'have a full set of attributes' do
+      @the_police.attributes.should_not be_nil
+    end
+    
+    should "have id and name properties" do
+      @the_police.id.should be_kind_of(String)
+      @the_police.name.should be_kind_of(String)
+    end
+    
+    should 'load attributes only on demand' do
+      @the_police.attributes_loaded?.should == false
+      @the_police.attributes
+      @the_police.attributes_loaded?.should == true
+    end
+    
+    should 'load schema only on demand when calling types' do
+      @the_police.schema_loaded?.should == false
+      @the_police.types
+      @the_police.schema_loaded?.should == true
+    end
+
+    should 'load schema only on demand when calling views' do
+      @the_police.schema_loaded?.should == false
+      @the_police.views
+      @the_police.schema_loaded?.should == true
+    end
+  end # context
+end # ResourceTest

data/test/unit/session_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+class SessionTest < Test::Unit::TestCase
+  context "A Session instance" do
+    setup do
+      # Ken::Logger.new(STDOUT, :info)
+      Ken::Session.new('http://www.freebase.com', 'ma', 'xxxxx')
+    end
+    
+    should 'return the correct set of types' do
+      result = Ken.session.mqlread({:id => "/en/the_police", :type => []})
+      result['type'].length.should >= 1
+    end
+    
+    should 'raise a Ken::MqlReadError if node does not exist' do
+      lambda { Ken.session.mqlread({:id => "/en/the_police", :evil_property => []}) }.should raise_error(Ken::ReadError)
+    end
+    
+    should 'do uncursored queries' do
+      Ken.session.mqlread([{:type => '/chemistry/chemical_element'}]).length == 100
+    end
+    
+    should 'do cursored queries' do
+      Ken.session.mqlread([{:type => '/chemistry/chemical_element'}], :cursor => true).length.should >= 117
+    end
+    
+    should 'do raw content requests' do
+      Ken.session.raw_content("/guid/9202a8c04000641f800000000002c4f3").length.should >= 50
+    end
+    
+    should 'do blurb content requests' do
+      Ken.session.blurb_content("/guid/9202a8c04000641f800000000002c4f3", :maxlength => 200).length.should >= 50
+    end
+    
+    should 'do topic requests' do
+      Ken.session.topic("/en/the_police")
+    end
+    
+    should 'do search requests' do
+      Ken.session.search("the police").length.should >= 1
+    end
+    
+  end # context
+end # SessionTest

data/test/unit/topic_test.rb

@@ -0,0 +1,92 @@
+require 'test_helper'
+
+class TopicTest < Test::Unit::TestCase
+  context "A Topic instance" do
+    setup do
+      data = load_fixture('the_police_topic')
+      @the_police = Ken::Topic.new(data)
+    end
+    
+    should "have an id" do
+      @the_police.id.should == "/en/the_police"
+    end
+    
+    should "have aliases" do
+      @the_police.aliases.length.should >= 1
+    end
+    
+    should "have a text/name" do
+      @the_police.text.should == "The Police"
+      @the_police.name.should == "The Police"
+    end
+    
+    should "have a thumbnail" do
+      @the_police.thumbnail.should == "http://api.freebase.com/api/trans/image_thumb/en/the_police"
+    end
+    
+    should "have webpages" do
+      @the_police.webpages.length.should == 5
+    end
+    
+    should "have types" do
+      @the_police.types.length.should == 7
+      @the_police.types.first.should be_kind_of(Ken::Type)
+    end
+    
+    should "have properties" do
+      @the_police.properties.length.should >= 1
+      @the_police.properties.first.should be_kind_of(Ken::Property)      
+    end
+    
+    should "have attributes" do
+      @the_police.attributes.first.should be_kind_of(Ken::Attribute)
+      
+      # TODO support mediator properties (CVT's)
+      # @the_police.attributes.length.should == @the_police.properties.length
+    end
+    
+    should "have views" do
+      @the_police.should have(7).views
+      @the_police.views.first.should be_kind_of(Ken::View)
+      @the_police.views.first.type.should be_kind_of(Ken::Type)
+    end
+    
+    should "return individual view based requested type id" do
+      @the_police.view('/music/artist').should be_kind_of(Ken::View)
+      @the_police.view('/music/artist').attributes.length.should == 9
+      @the_police.view('/location/location').should be_nil # not existent view
+    end
+    
+    should "return individual type based requested type id" do
+      @the_police.type('/music/artist').should be_kind_of(Ken::Type)
+      @the_police.type('/location/location').should be_nil # not existent type
+    end
+    
+    should 'have a full set of attributes' do
+      @the_police.attributes.should_not be_nil
+    end
+    
+    should "have id and name properties" do
+      @the_police.id.should be_kind_of(String)
+      @the_police.name.should be_kind_of(String)
+    end
+    
+    should 'load attributes only on demand' do
+      @the_police.attributes_loaded?.should == false
+      @the_police.attributes
+      @the_police.attributes_loaded?.should == true
+    end
+    
+    should 'load schema only on demand when calling types' do
+      @the_police.schema_loaded?.should == false
+      @the_police.types
+      @the_police.schema_loaded?.should == true
+    end
+    
+    should 'load schema only on demand when calling views' do
+      @the_police.schema_loaded?.should == false
+      @the_police.views
+      @the_police.schema_loaded?.should == true
+    end
+  end # context
+end # TopicTest

data/test/unit/type_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class TypeTest < Test::Unit::TestCase
+  context "A Session instance" do
+    setup do
+      data = load_fixture('the_police')
+      @type = Ken::Resource.new(data).types.first
+    end
+  
+    should 'have an id and a name' do
+      @type.id.should be_kind_of(String)
+      @type.name.should be_kind_of(String)
+    end
+
+    should 'have properties' do
+      @type.should have(16).properties
+    end
+    
+    context "when accessing a property directly" do
+      setup do
+        @genre = @type.genre
+        @album = @type.album
+      end
+      
+      should "be kind of Ken::Property" do
+        @genre.should be_kind_of(Ken::Property)
+        @album.should be_kind_of(Ken::Property)
+      end
+      
+      should "raise AttributeNotFound when invalid propertyname is supplied" do
+        lambda { @type.not_existing_property }.should raise_error(Ken::PropertyNotFound)
+      end
+    end # context
+  end # context
+end # TypeTest