shortwave 0.0.1

data/test/build/facade_builder_test.rb

@@ -0,0 +1,23 @@
+require 'helper'
+require 'facade/build/facade_builder'
+
+class FacadeBuilderTest < TestCase
+  
+  test "remote method definitions can be loaded from file" do
+    expected = {"User" => {"foo.bar" => "/baz"}}
+    assert_equal( expected, FacadeBuilder.new.remote_method_definitions(File.dirname(__FILE__) + "/data/intro.yml") )
+  end
+
+  test "remote method defintions can be added to file" do
+    expected = {"A" => {"B" => "C"}}
+
+    File.expects(:exists?).returns(false)
+    DocumentationRemote.expects(:scrape_remote_method_index).returns(expected)
+    fh = mock()
+    fh.expects(:write).with("--- \nA: \n  B: C\n")
+    File.expects(:open).yields(fh)
+    
+    assert_equal( expected, FacadeBuilder.new.remote_method_definitions("non-existent") )
+  end
+
+end

data/test/build/parameter_test.rb

@@ -0,0 +1,43 @@
+require 'helper'
+require 'facade/build/facade_builder'
+
+class ParameterTest < TestCase
+
+  test "can be parsed from an html screen" do
+    assert_equal 2, make_parameters("user_getLovedTracks").size
+  end
+
+  test "have a name" do
+    assert_equal :user, make_parameters("user_getLovedTracks").first.name
+  end
+
+  test "can be required or optional" do
+    assert make_parameters("venue_search").first.required?
+    assert ! make_parameters("venue_search")[1].required?
+  end
+
+  test "can have a description" do
+    assert_equal "The venue name you would like to search for.", 
+      make_parameters("venue_search").first.description
+  end
+
+  test "copes with defaults in the optional section" do
+    assert ! make_parameters("tasteometer_compare")[4].required?
+  end
+
+  test "copes with multiple parameters defined as type[1|2]" do
+    assert_equal :type1, make_parameters("tasteometer_compare").first.name
+    assert_equal :type2, make_parameters("tasteometer_compare")[1].name
+  end
+
+  test "copes with extra information in the required string" do
+    assert make_parameters("tasteometer_compare").first.required?
+  end
+
+  private
+
+  def make_parameters(screen)
+    raw = File.read(File.dirname(__FILE__) + "/data/screens/#{screen}.html")
+    Shortwave::Facade::Build::Parameter.parse(raw)
+  end
+end

data/test/build/remote_method_test.rb

@@ -0,0 +1,47 @@
+require 'helper'
+require 'facade/build/facade_builder'
+
+class RemoteMethodTest < TestCase
+
+  test "parsed method has a description" do
+    make_builder "user_getLovedTracks"
+    assert_equal "Get the last 50 tracks loved by a user.", @method.description
+  end
+
+  test "parsed method has a remote name" do
+    make_builder "user_getLovedTracks"
+    assert_equal "user.getLovedTracks", @method.remote_name
+  end
+
+  test "parsed method has a name" do
+    make_builder "user_getLovedTracks"
+    assert_equal :loved_tracks, @method.name
+  end
+
+  test "parsed method has parameters" do
+    make_builder "user_getLovedTracks"
+    assert_equal [:user, :api_key], @method.parameters.map {|p| p.name }
+  end
+
+  test "read methods should use http GET" do
+    make_builder "user_getLovedTracks"
+    assert_equal :get, @method.http_method
+  end
+
+  test "write methods should use http POST" do
+    make_builder "album_addTags"
+    assert_equal :post, @method.http_method
+  end
+
+  test "parsed methods have sample response code" do
+    make_builder "album_addTags"
+    assert_equal "<lfm status=\"ok\">\n</lfm>", @method.sample_response
+  end
+
+  private
+
+  def make_builder(screen)
+    raw = File.read(File.dirname(__FILE__) + "/data/screens/#{screen}.html")
+    @method = Shortwave::Facade::Build::RemoteMethod.new(raw)
+  end
+end

data/test/build/ruby_class_test.rb

@@ -0,0 +1,12 @@
+require 'helper'
+require 'facade/build/facade_builder'
+
+include Shortwave::Facade::Build
+
+class RubyClassTest < TestCase
+
+  test "has a name" do
+    assert_equal "User", RubyClass.new("User").name
+  end
+
+end

data/test/build/ruby_method_test.rb

@@ -0,0 +1,137 @@
+require 'helper'
+require 'facade/build/facade_builder'
+
+include Shortwave::Facade::Build
+
+RemoteMethodStub = Struct.new(:remote_name, :name, :description, :sample_response, :parameters, :http_method)
+ParameterStub    = Struct.new(:name, :description, :required)
+
+class ParameterStub
+  def required?
+    required
+  end
+end
+
+class RubyMethodTest < TestCase
+
+  test "outputs a simple method signature with no arguments" do
+    method = RemoteMethodStub.new("user.getLovedTracks", :loved_tracks)
+    assert_equal "loved_tracks", RubyMethod.new(method).signature
+  end
+
+  test "outputs the description as first line of comment" do
+    method = RemoteMethodStub.new("user.getLovedTracks", :loved_tracks, "A user's loved tracks")
+    assert_equal "# A user's loved tracks", RubyMethod.new(method).comment.first
+  end
+
+  test "outputs parameter descriptions as a comment" do
+    method = RemoteMethodStub.new("user.getLovedTracks", 
+                                  :loved_tracks,
+                                  "Description",
+                                  nil,
+                                  [ParameterStub.new(:user, "A username", true),
+                                   ParameterStub.new(:optional, "Optional", false),
+                                   ParameterStub.new(:api_key, "api key", true)])
+
+    expected = ["# Description",
+                "#",
+                "# +user+:: A username",
+                "#",
+                "# <b>Options</b>",
+                "# +optional+:: Optional"]
+    assert_equal expected, RubyMethod.new(method).comment
+  end
+
+  test "adds required parameters to the method signature" do
+    method = RemoteMethodStub.new("user.getLovedTracks", 
+                                  :loved_tracks,
+                                  nil,
+                                  nil,
+                                  [ParameterStub.new(:user, "A username", true)])
+
+    assert_equal "loved_tracks(user)", RubyMethod.new(method).signature
+  end
+
+  [:api_key, :api_sig, :sk].each do |param|
+    test "#{param} parameter should not be part of the signature" do
+      method = RemoteMethodStub.new("user.getLovedTracks", 
+                                    :loved_tracks,
+                                    nil,
+                                    nil,
+                                    [ParameterStub.new(:user, "A username", true),
+                                     ParameterStub.new(param, "API key", true)])
+
+      assert_equal "loved_tracks(user)", RubyMethod.new(method).signature
+    end
+  end
+
+  test "optional parameters should be collapsed to an options hash" do
+    method = RemoteMethodStub.new("user.getLovedTracks", 
+                                  :loved_tracks,
+                                  nil,
+                                  nil,
+                                  [ParameterStub.new(:user, "A username", true),
+                                   ParameterStub.new(:number, "optional", false)])
+
+    assert_equal "loved_tracks(user, options={})", RubyMethod.new(method).signature
+  end
+
+  test "method body generates a GET request to the remote method" do
+    method = RemoteMethodStub.new("user.getLovedTracks", 
+                                  :loved_tracks,
+                                  nil,
+                                  nil,
+                                  [ParameterStub.new(:user, "A username", true)],
+                                  :get)
+    
+    expected = ["get(:standard, {:method => \"user.getLovedTracks\", :user => user})"]
+    assert_equal expected, RubyMethod.new(method).body
+  end
+
+  test "optional parameters are merged into the sent data" do
+    method = RemoteMethodStub.new("user.getLovedTracks", 
+                                  :loved_tracks,
+                                  nil,
+                                  nil,
+                                  [ParameterStub.new(:user, "A username", true),
+                                   ParameterStub.new(:number, "optional", false)],
+                                  :get)
+
+    expected = ["get(:standard, {:method => \"user.getLovedTracks\", :user => user}.merge(options))"]
+    assert_equal expected, RubyMethod.new(method).body
+  end
+
+  test "write methods are sent via POST" do
+    method = RemoteMethodStub.new("user.getLovedTracks", 
+                                  :loved_tracks,
+                                  nil,
+                                  nil,
+                                  [ParameterStub.new(:user, "A username", true),
+                                   ParameterStub.new(:number, "optional", false)],
+                                  :post)
+
+    assert_equal "post", RubyMethod.new(method).body.first[0..3]
+  end
+
+  test "method with an sk parameter should be a session method" do
+    method = RemoteMethodStub.new("user.getLovedTracks", 
+                                  :loved_tracks,
+                                  nil,
+                                  nil,
+                                  [ParameterStub.new(:sk, "sk", true)],
+                                  :get)
+    expected = ["get(:session, {:method => \"user.getLovedTracks\"})"]
+    assert_equal expected, RubyMethod.new(method).body
+  end
+
+  test "method with an api_sig but no sk parameter should be a signed method" do
+    method = RemoteMethodStub.new("user.getLovedTracks", 
+                                  :loved_tracks,
+                                  nil,
+                                  nil,
+                                  [ParameterStub.new(:api_sig, "api_sig", true)],
+                                  :get)
+    expected = ["get(:signed, {:method => \"user.getLovedTracks\"})"]
+    assert_equal expected, RubyMethod.new(method).body
+  end
+end

data/test/helper.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'test/unit'
+require 'mocha'
+require 'fakeweb'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'shortwave'
+
+FakeWeb.allow_net_connect = false
+TestCase = Test::Unit::TestCase
+
+class TestCase
+  def setup
+    FakeWeb.clean_registry
+  end
+
+  def self.test(name, &block)
+    test_name = "test_#{name.gsub(/\s+/, '_')}".to_sym
+    defined = instance_method(test_name) rescue false
+    raise "#{test_name} is already defined in #{self}" if defined
+
+    if block_given?
+      define_method(test_name, &block)
+    else
+      define_method(test_name) do
+        flunk "No implementation for #{test_name}"
+      end
+    end
+  end
+end
+
+include Shortwave
+require 'provider_test_helper'
+

data/test/model/album_test.rb

@@ -0,0 +1,62 @@
+require 'helper'
+
+class AlbumTest < TestCase
+  include ProviderTestHelper
+
+  def setup
+    super
+    @facade.stubs(:session).returns(stub(:album_facade => @facade, :merge! => nil, :signed_in? => true))
+    @album = Model::Album.parse(xml("album_info"), :single => true)
+    @album.session = @facade.session
+  end
+
+  test "has a name" do
+    assert_equal "Only Life", @album.name
+  end
+
+  test "has an id" do
+    assert_equal 2045356, @album.id
+  end
+
+  test "has a url" do
+    assert_equal "http://www.last.fm/music/The+Feelies/Only+Life", @album.url
+  end
+
+  test "has a release date" do
+    assert_equal Time.local(1987, 11, 30, 0, 0, 0), @album.release_date
+  end
+
+  test "has images" do
+    assert_equal 4, @album.images.size
+  end
+
+  test "has a musicbrainz id" do
+    assert_equal "464efacc-a133-4ae6-a9ff-7573c448eb32", @album.mbid
+  end
+
+  test "has listeners" do
+    assert_equal 10068, @album.listeners
+  end
+
+  test "has a play count" do
+    assert_equal 67545, @album.play_count
+  end
+
+  test "has tags" do
+    assert_equal 5, @album.tags.size
+  end
+
+  test "has an artist name" do
+    assert_equal "The Feelies", @album.artist_name
+  end
+
+  test "can be tagged by a user" do
+    @facade.expects(:add_tags).with("The Feelies", "Only Life", "tag1,tag2,tag3")
+    @album.add_tags("tag1", "tag2", "tag3")
+  end
+
+  test "can remove a user tag" do
+    @facade.expects(:remove_tag).with("The Feelies", "Only Life", "tag1")
+    @album.remove_tag("tag1")
+  end
+end

data/test/model/artist_test.rb

@@ -0,0 +1,103 @@
+require 'helper'
+
+class ArtistTest < TestCase
+  include ProviderTestHelper
+
+  def setup
+    super
+    @artist = Model::Artist.parse(xml("artist_info"), :single => true)
+  end
+
+  test "has a name" do
+    assert_equal "The Feelies", @artist.name
+  end
+
+  test "has a url" do
+    assert_equal "http://www.last.fm/music/The+Feelies", @artist.url
+  end
+
+  test "has a musicbrainz id" do
+    assert_equal "28c07254-aeae-42ad-beea-67f59c3c8baf", @artist.mbid
+  end
+
+  test "has listeners" do
+    assert_equal 43593, @artist.listeners
+  end
+
+  test "has a play count" do
+    assert_equal 498218, @artist.play_count
+  end
+
+  test "has a biography and summary" do
+    assert @artist.biography
+    assert @artist.biography_summary
+  end
+
+  test "has images" do
+    assert_equal 3, @artist.images.size
+  end
+
+  test "has user tags" do
+    @artist.session = StubSession.new
+    expect_get "method=artist.getTags&artist=The%20Feelies", :tag_search
+    @artist.my_tags
+  end
+
+  test "has shouts" do
+    @artist.session = StubSession.new
+    expect_get "method=artist.getShouts&artist=The%20Feelies", :artist_shouts
+    assert_equal 104, @artist.shouts.size
+  end
+
+  test "can be shouted at" do
+    @facade.stubs(:session).returns(stub(:artist_facade => @facade))
+    @artist.session = @facade.session
+    @facade.expects(:shout).with("The Feelies", "Hi there").returns(xml("ok"))
+    @artist.shout("Hi there")
+  end
+
+  test "can be shared with other users or email addresses" do
+    @facade.stubs(:session).returns(stub(:artist_facade => @facade))
+    @artist.session = @facade.session
+    args = ["The Feelies", "roland@example.com,kate", {:message => "This is awesome!"}]
+    @facade.expects(:share).with(*args).returns(xml("ok"))
+    # TODO should be a user object, not just a username
+    @artist.share(["roland@example.com", "kate"], "This is awesome!")
+  end
+
+  test "has events" do
+    @artist.session = StubSession.new
+    expect_get "method=artist.getEvents&artist=The%20Feelies", :venue_events
+    assert @artist.events.first.kind_of? Model::Event
+  end
+
+  test "has similar artists" do
+    @artist.session = StubSession.new
+    expect_get "method=artist.getSimilar&artist=The%20Feelies", :artist_search
+    assert @artist.similar.first.kind_of? Model::Artist
+  end
+
+  test "has albums" do
+    @artist.session = StubSession.new
+    expect_get "method=artist.getTopAlbums&artist=The%20Feelies", :album_search
+    assert @artist.albums.first.kind_of? Model::Album
+  end
+
+  test "has fans" do
+    @artist.session = StubSession.new
+    expect_get "method=artist.getTopFans&artist=The%20Feelies", :artist_top_fans
+    assert @artist.fans.first.kind_of? Model::User
+  end
+
+  test "has tags" do
+    @artist.session = StubSession.new
+    expect_get "method=artist.getTopTags&artist=The%20Feelies", :tag_search
+    assert @artist.tags.first.kind_of? Model::Tag
+  end
+
+  test "has tracks" do
+    @artist.session = StubSession.new
+    expect_get "method=artist.getTopTracks&artist=The%20Feelies", :track_search
+    assert @artist.tracks.first.kind_of? Model::Track
+  end
+end