bandsintown 0.1.4 → 0.2.0

data/spec/bandsintown/artist_spec.rb

@@ -112,7 +112,7 @@ describe Bandsintown::Artist do
     end
     it "should request and parse a call to the BIT artist events API method and the artist's api name" do
       @artist.should_receive(:api_name).and_return('Little%20Brother')
-      Bandsintown::Artist.should_receive(:request_and_parse).with("Little%20Brother/events").and_return([])
+      Bandsintown::Artist.should_receive(:request_and_parse).with(:get, "Little%20Brother/events").and_return([])
       @artist.events
     end
     it "should return an Array of Bandsintown::Event objects built from the response" do
@@ -157,7 +157,7 @@ describe Bandsintown::Artist do
       Bandsintown::Artist.get(@options)
     end
     it "should request and parse a call to the BIT artists - get API method using api_name" do
-      Bandsintown::Artist.should_receive(:request_and_parse).with(@artist.api_name).and_return('json')
+      Bandsintown::Artist.should_receive(:request_and_parse).with(:get, @artist.api_name).and_return('json')
       Bandsintown::Artist.get(@options)
     end
     it "should return the result of Bandsintown::Artist.build_from_json with the response data" do

data/spec/bandsintown/base_spec.rb

@@ -11,21 +11,37 @@ describe Bandsintown::Base do
     end
   end
   
-  describe ".request(api_method, args={})" do
-    it "should make a request to the connection url" do
-      resource_path = "events"
-      method        = "search"
-      args          = { :arg => "value" }
-      Bandsintown::Base.stub!(:resource_path).and_return(resource_path)
-      Bandsintown::Base.connection.should_receive(:request).with(resource_path, method, args)
-      Bandsintown::Base.request(method, args)
+  describe ".request(http_method, api_method, params={})" do
+    before(:each) do
+      Bandsintown::Base.stub!(:resource_path).and_return("events")
+    end
+    it "should make a GET request to the connection url using api_method and params when http_method == :get" do
+      http_method = :get 
+      api_method = "search"
+      params = { :arg => "value" }
+      Bandsintown::Base.stub!(:resource_path).and_return("events")
+      Bandsintown::Base.connection.should_receive(:get).with("events", api_method, params).and_return("response")
+      Bandsintown::Base.request(http_method, api_method, params).should == "response"
+    end
+    it "should make a POST request to the connection url using api_method and params when http_method == :post" do
+      http_method = :post 
+      api_method = "create"
+      params = { :arg => "value" }
+      Bandsintown::Base.connection.should_receive(:post).with("events", api_method, params).and_return("response")
+      Bandsintown::Base.request(http_method, api_method, params).should == "response"
+    end
+    it "should raise an error if http_method is not :get or :post" do
+      http_method = :delete
+      api_method = "search"
+      params = { :arg => "value" }
+      lambda { Bandsintown::Base.request(http_method, api_method, params) }.should raise_error(ArgumentError, "only :get and :post requests are supported")
     end
   end
   
   describe ".parse(response)" do
     it "should check the response for errors" do
       response = "response"
-      parsed   = mock("parsed json")
+      parsed = mock("parsed json")
       JSON.stub!(:parse).and_return(parsed)
       Bandsintown::Base.should_receive(:check_for_errors).with(parsed)
       Bandsintown::Base.parse(response)
@@ -36,23 +52,23 @@ describe Bandsintown::Base do
     end
   end
   
-  describe ".request_and_parse(api_method, args={})" do
+  describe ".request_and_parse(http_method, api_method, params={})" do
     before(:each) do
-      @resource_path = "events"
-      @method        = "search"
-      @args          = { :arg => "value" }
-      Bandsintown::Base.stub!(:resource_path).and_return(@resource_path)
-      @response = mock("WWW::Mechanize response")
+      @http_method = :get 
+      @api_method = "search"
+      @params = { :arg => "value" }
+      Bandsintown::Base.stub!(:resource_path).and_return("events")
+      @response = mock("HTTP response body")
     end
-    it "should make a request" do
-      Bandsintown::Base.should_receive(:request).with(@method, @args).and_return(@response)
+    it "should make a request with the http method, api method, and params" do
+      Bandsintown::Base.should_receive(:request).with(@http_method, @api_method, @params).and_return(@response)
       Bandsintown::Base.stub!(:parse)
-      Bandsintown::Base.request_and_parse(@method, @args)
+      Bandsintown::Base.request_and_parse(@http_method, @api_method, @params)
     end
     it "should parse the response" do
       Bandsintown::Base.stub!(:request).and_return(@response)
       Bandsintown::Base.should_receive(:parse).with(@response)
-      Bandsintown::Base.request_and_parse(@method, @args)
+      Bandsintown::Base.request_and_parse(@http_method, @api_method, @params)
     end
   end
   
@@ -67,4 +83,15 @@ describe Bandsintown::Base do
     end
   end
   
+  
+  describe "#to_hash" do
+    it "should return a hash from non-blank instance variables" do
+      class Bandsintown::TestObject < Bandsintown::Base; attr_accessor :one, :two, :three; end
+      test_object = Bandsintown::TestObject.new
+      test_object.one = '1'
+      test_object.two = 2
+      test_object.three = ''
+      test_object.to_hash.should == { :one => '1', :two => 2 }
+    end
+  end
 end

data/spec/bandsintown/connection_spec.rb

@@ -7,79 +7,102 @@ describe Bandsintown::Connection do
   end
   
   describe ".initialize(base_url)" do
+    before(:each) do
+      @connection = Bandsintown::Connection.new(@base_url)
+    end
     it "should set the base_url for the Connection" do
-      Bandsintown::Connection.new(@base_url).base_url.should == @base_url
+      @connection.base_url.should == @base_url
     end
   end
   
-  describe ".request(url_path, args = {}, method = :get)" do
+  describe ".get(resource_path, method_path, params = {})" do
     before(:each) do
       @connection = Bandsintown::Connection.new(@base_url)
-      @response = StringIO.new("response")
-      @connection.stub!(:open).and_return(@response)
+      RestClient.stub!(:get).and_return("response")
       @api_resource = "events"
       @api_method = "search"
     end
-    it "should convert args to url parameters when making a request" do
-      args         = { :artists => ["Little Brother", "Joe Scudda"], :location => "Boston, MA", :radius => 10 }
-      request_url  = "http://api.bandsintown.com/events/search?app_id=YOUR_APP_ID&artists%5B%5D=Little+Brother&artists%5B%5D=Joe+Scudda&format=json&location=Boston%2C+MA&radius=10"  
-      @connection.should_receive(:open).with(request_url).and_return(@response)
-      @connection.request(@api_resource, @api_method, args)  
+    it "should make a get request to the url constructed with resource path, method path, and encoded params" do
+      params = { :artists => ["Little Brother", "Joe Scudda"], :location => "Boston, MA", :radius => 10 }
+      request_url = "http://api.bandsintown.com/events/search?app_id=YOUR_APP_ID&artists%5B%5D=Little+Brother&artists%5B%5D=Joe+Scudda&format=json&location=Boston%2C+MA&radius=10"  
+      @connection.should_receive(:encode).with(params).and_return("app_id=YOUR_APP_ID&artists%5B%5D=Little+Brother&artists%5B%5D=Joe+Scudda&format=json&location=Boston%2C+MA&radius=10")
+      RestClient.should_receive(:get).with(request_url).and_return("response")
+      @connection.get(@api_resource, @api_method, params).should == "response"
     end
-    it "should convert args[:start_date] and args[:end_date] to a single args[:date] parameter when making a request" do
-      args         = { :start_date => "2009-01-01", :end_date => "2009-02-01" }
-      request_url  = "http://api.bandsintown.com/events/search?app_id=YOUR_APP_ID&date=2009-01-01%2C2009-02-01&format=json"
-      @connection.should_receive(:open).with(request_url).and_return(@response)
-      @connection.request(@api_resource, @api_method, args)
+    
+    it "should return the API error message instead of raising an error if there was a problem with the request (404 response)" do
+      error = RestClient::ResourceNotFound.new; error.response = "error message"
+      RestClient.stub!(:get).and_raise(error)
+      lambda { @connection.get("", "", {}) }.should_not raise_error
+      @connection.get("", "", {}).should == "error message"
     end
-    it "should allow date to be a Time object" do
-      args = { :date => Time.now.beginning_of_day }
-      request_url = "http://api.bandsintown.com/events/search?app_id=YOUR_APP_ID&date=#{Time.now.beginning_of_day.strftime("%Y-%m-%d")}&format=json"
-      @connection.should_receive(:open).with(request_url).and_return(@response)
-      @connection.request(@api_resource, @api_method, args)
+  end
+  
+  describe ".post(resource_path, method_path, body = {})" do
+   before(:each) do
+     @connection = Bandsintown::Connection.new(@base_url)
+     RestClient.stub!(:post).and_return("response")
+     @api_resource = "events"
+     @api_method = "create"
+     @body_params = { 
+       :event => { 
+         :artists => [{ :name => "Little Brother" }],
+         :datetime => "2010-06-01T19:30:00",
+         :venue => { :id => 123 }
+       }
+     }
+   end
+   it "should make a post request to the url constructed with resource path, method path, default encoded params, body converted to json, and application/json request headers" do
+     expected_url = "http://api.bandsintown.com/events/create?app_id=YOUR_APP_ID&format=json"
+     expected_body = @body_params.to_json
+     expected_headers = { :content_type => :json, :accept => :json }
+     @connection.should_receive(:encode).with({}).and_return("app_id=YOUR_APP_ID&format=json")
+     RestClient.should_receive(:post).with(expected_url, expected_body, expected_headers).and_return("response")
+     @connection.post(@api_resource, @api_method, @body_params).should == "response"
+   end
+   
+   it "should return the API error message instead of raising an error if there was a problem with the request (404 response)" do
+     error = RestClient::ResourceNotFound.new; error.response = "error message"
+     RestClient.stub!(:post).and_raise(error)
+     lambda { @connection.post(@api_resource, @api_method, @body_params) }.should_not raise_error
+     @connection.post(@api_resource, @api_method, @body_params).should == "error message"
+   end
+  end
+  
+  describe ".encode(params={})" do
+    before(:each) do
+      @connection = Bandsintown::Connection.new(@base_url)
     end
-    it "should allow date to be a Date object" do
-      args = { :date => Date.today }
-      request_url = "http://api.bandsintown.com/events/search?app_id=YOUR_APP_ID&date=#{Date.today.strftime("%Y-%m-%d")}&format=json"
-      @connection.should_receive(:open).with(request_url).and_return(@response)
-      @connection.request(@api_resource, @api_method, args)
+    it "should return a query param string including :app_id and :format => json without the user having to specify them" do
+      @connection.encode({}).should == "app_id=#{Bandsintown.app_id}&format=json"
     end
-    it "should allow date to be a String object" do
-      args = { :date => "2009-01-01" }
-      request_url = "http://api.bandsintown.com/events/search?app_id=YOUR_APP_ID&date=2009-01-01&format=json"
-      @connection.should_receive(:open).with(request_url).and_return(@response)
-      @connection.request(@api_resource, @api_method, args)
+    it "should convert params[:start_date] and params[:end_date] to a single params[:date] parameter" do
+      params = { :start_date => "2009-01-01", :end_date => "2009-02-01" }
+      @connection.encode(params).should == "app_id=#{Bandsintown.app_id}&date=2009-01-01%2C2009-02-01&format=json"
     end
-    it "should allow start date and end date to be Time objects" do
-      args         = { :start_date => 1.week.ago, :end_date => 1.week.from_now }
-      request_url  = "http://api.bandsintown.com/events/search?app_id=YOUR_APP_ID&date=#{1.week.ago.strftime('%Y-%m-%d')}%2C#{1.week.from_now.strftime('%Y-%m-%d')}&format=json"
-      @connection.should_receive(:open).with(request_url).and_return(@response)
-      @connection.request(@api_resource, @api_method, args)
+    it "should allow :date to be a Time object" do
+      params = { :date => Time.now.beginning_of_day }
+      @connection.encode(params).should == "app_id=#{Bandsintown.app_id}&date=#{Time.now.strftime("%Y-%m-%d")}&format=json"
     end
-    it "should allow start date and end date to be Date objects" do
-      args         = { :start_date => 1.week.ago.to_date, :end_date => 1.week.from_now.to_date }
-      request_url  = "http://api.bandsintown.com/events/search?app_id=YOUR_APP_ID&date=#{1.week.ago.to_date.strftime('%Y-%m-%d')}%2C#{1.week.from_now.to_date.strftime('%Y-%m-%d')}&format=json"
-      @connection.should_receive(:open).with(request_url).and_return(@response)
-      @connection.request(@api_resource, @api_method, args)
+    it "should allow :date to be a Date object" do
+      params = { :date => Date.today }
+      @connection.encode(params).should == "app_id=#{Bandsintown.app_id}&date=#{Date.today}&format=json"
     end
-    it "should allow start date and end date to be String objects" do
-      args         = { :start_date => "2009-01-01", :end_date => "2009-02-01" }
-      request_url  = "http://api.bandsintown.com/events/search?app_id=YOUR_APP_ID&date=2009-01-01%2C2009-02-01&format=json"
-      @connection.should_receive(:open).with(request_url).and_return(@response)
-      @connection.request(@api_resource, @api_method, args)
+    it "should allow :date to be a String object" do
+      params = { :date => "2009-01-01" }
+      @connection.encode(params).should == "app_id=#{Bandsintown.app_id}&date=2009-01-01&format=json"
     end
-    it "should return the API error message instead of raising an error if there was a problem with the request (404 response)" do
-      error = OpenURI::HTTPError.new('404', StringIO.new('error message'))
-      @connection.stub!(:open).and_raise(error)
-      lambda { @connection.request("", "", {}) }.should_not raise_error
-      error.io.rewind
-      @connection.request("", "", {}).should == 'error message'
+    it "should allow :start_date and :end_date to be Time objects" do
+      params = { :start_date => 1.week.ago, :end_date => 1.week.from_now }
+      @connection.encode(params).should == "app_id=#{Bandsintown.app_id}&date=#{1.week.ago.strftime("%Y-%m-%d")}%2C#{1.week.from_now.strftime("%Y-%m-%d")}&format=json"
+    end
+    it "should allow :start_date and :end_date to be Date objects" do
+      params = { :start_date => 1.week.ago.to_date, :end_date => 1.week.from_now.to_date }
+      @connection.encode(params).should == "app_id=#{Bandsintown.app_id}&date=#{1.week.ago.strftime("%Y-%m-%d")}%2C#{1.week.from_now.strftime("%Y-%m-%d")}&format=json"
     end
-    it "should set the format to json and the send app id without the user having to specify them" do
-      request_url = "http://api.bandsintown.com/events/search?app_id=#{Bandsintown.app_id}&format=json"
-      @connection.should_receive(:open).with(request_url).and_return(@response)
-      @connection.request(@api_resource, @api_method, {})
+    it "should allow :start_date and :end_date to be String objects" do
+      params = { :start_date => "2009-01-01", :end_date => "2009-02-01" }
+      @connection.encode(params).should == "app_id=#{Bandsintown.app_id}&date=2009-01-01%2C2009-02-01&format=json" 
     end
   end
-  
 end

data/spec/bandsintown/event/creation_helpers_spec.rb

@@ -0,0 +1,102 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Bandsintown::Event::CreationHelpers do
+  before(:each) do
+    class Bandsintown::ExtendedClass; include Bandsintown::Event::CreationHelpers; end
+  end
+  describe ".parse_datetime(datetime)" do
+    it "should return datetime when given a String object" do
+      datetime = "2010-06-01T20:30:00"
+      expected = datetime
+      Bandsintown::ExtendedClass.parse_datetime(datetime).should == expected
+    end
+    it "should return datetime formatted to ISO 8601 if given a Time object" do
+      datetime = Time.parse("2010-06-01 20:30")
+      expected = "2010-06-01T20:30:00"
+      Bandsintown::ExtendedClass.parse_datetime(datetime).should == expected
+    end
+    it "should return datetime formatted to ISO 8601 if given a DateTime object" do
+      datetime = DateTime.parse("2010-06-01 20:30")
+      expected = "2010-06-01T20:30:00"
+      Bandsintown::ExtendedClass.parse_datetime(datetime).should == expected
+    end
+    it "should return datetime formatted to ISO 8601 at 19:00 if given a Date object" do
+      datetime = Date.parse("2010-06-01")
+      expected = "2010-06-01T19:00:00"
+      Bandsintown::ExtendedClass.parse_datetime(datetime).should == expected
+    end
+  end
+  
+  describe ".parse_venue(venue_data)" do
+    describe "venue_data given as a hash" do
+      before(:each) do
+        @venue_data = { 
+          :name => "Paradise", 
+          :address => "967 Commonwealth Ave",
+          :city => "Boston", 
+          :region => "MA", 
+          :postalcode => "02215",
+          :country => "United States", 
+          :latitude => '',
+          :longitude => ''
+        }        
+      end
+      it "should return a hash with non-blank location data if venue_data is given as a hash without bandsintown id" do
+        Bandsintown::ExtendedClass.parse_venue(@venue_data).should == {
+          :name => "Paradise", 
+          :address => "967 Commonwealth Ave",
+          :city => "Boston", 
+          :region => "MA", 
+          :postalcode => "02215",
+          :country => "United States"
+        }
+      end
+      it "should return a hash with bandsintown id and no location data if venue_data is given as a hash with bandsintown id" do
+        @venue_data[:bandsintown_id] = 1700
+        Bandsintown::ExtendedClass.parse_venue(@venue_data).should == { :id => 1700 }
+      end
+    end
+    describe "venue_data given as a Bandsintown::Venue" do
+      before(:each) do
+        @venue = Bandsintown::Venue.new(1700)
+        @venue.name = "Paradise"
+        @venue.address = "967 Commonwealth Ave"
+        @venue.city = "Boston"
+        @venue.region = "MA"
+        @venue.country = "United States"
+      end
+      it "should return a hash with non-blank location data if venue_data is given as a Bandsintown::Venue without bandsintown id" do
+        @venue.bandsintown_id = ''
+        Bandsintown::ExtendedClass.parse_venue(@venue).should == {
+          :name => "Paradise", 
+          :address => "967 Commonwealth Ave",
+          :city => "Boston", 
+          :region => "MA", 
+          :country => "United States"
+        }
+      end
+      it "should return a hash with bandsintown id if venue_data is given as a Bandsintown::Venue with bandsintown id" do
+        Bandsintown::ExtendedClass.parse_venue(@venue).should == { :id => 1700 }
+      end
+    end
+  end
+
+  describe ".parse_artists(artist_data)" do
+    it "should return an array of { :name => name } when given strings" do
+      artist_data = ["Evidence", "Alchemist"]
+      Bandsintown::Event.parse_artists(artist_data).should == [{ :name => "Evidence" }, { :name => "Alchemist" }]
+    end
+    it "should return an array of { :name => name } when given Bandsintown::Artist instances without mbid" do
+      artist_data = [Bandsintown::Artist.new(:name => "Evidence"), Bandsintown::Artist.new(:name => "Alchemist")]
+      Bandsintown::Event.parse_artists(artist_data).should == [{ :name => "Evidence" }, { :name => "Alchemist" }]
+    end
+    it "should return an array of { :mbid => mbid } when given Bandsintown::Artist instance with mbid" do
+      artist_data = [Bandsintown::Artist.new(:mbid => "123"), Bandsintown::Artist.new(:mbid => "456")]
+      Bandsintown::Event.parse_artists(artist_data).should == [{ :mbid => "123" }, { :mbid => "456" }]
+    end
+    it "should work with different data types given" do
+      artist_data = ["Evidence", Bandsintown::Artist.new(:name => "Alchemist"), Bandsintown::Artist.new(:mbid => "123")]
+      Bandsintown::Event.parse_artists(artist_data).should == [{ :name => "Evidence" }, { :name => "Alchemist" }, { :mbid => "123" }]
+    end
+  end
+end

data/spec/bandsintown/event_spec.rb

@@ -1,6 +1,9 @@
 require File.dirname(__FILE__) + '/../spec_helper.rb'
 
 describe Bandsintown::Event do
+  it "should include the Bandsintown::Event::CreationHelpers module" do
+    Bandsintown::Event.included_modules.should include(Bandsintown::Event::CreationHelpers)
+  end
   
   describe ".resource_path" do
     it "should return the relative path to Event requests" do
@@ -13,7 +16,7 @@ describe Bandsintown::Event do
       @args = { :location => "Boston, MA", :date => "2009-01-01" }
     end
     it "should request and parse a call to the BIT events search api method" do
-      Bandsintown::Event.should_receive(:request_and_parse).with("search", @args).and_return([])
+      Bandsintown::Event.should_receive(:request_and_parse).with(:get, "search", @args).and_return([])
       Bandsintown::Event.search(@args)
     end
     it "should return an Array of Bandsintown::Event objects built from the response" do
@@ -32,7 +35,7 @@ describe Bandsintown::Event do
       @args = { :location => "Boston, MA", :date => "2009-01-01" }
     end
     it "should request and parse a call to the BIT recommended events api method" do
-      Bandsintown::Event.should_receive(:request_and_parse).with("recommended", @args).and_return([])
+      Bandsintown::Event.should_receive(:request_and_parse).with(:get, "recommended", @args).and_return([])
       Bandsintown::Event.recommended(@args)
     end
     it "should return an Array of Bandsintown::Event objects built from the response" do
@@ -48,7 +51,7 @@ describe Bandsintown::Event do
   
   describe ".daily" do
     it "should request and parse a call to the BIT daily events api method" do
-      Bandsintown::Event.should_receive(:request_and_parse).with("daily").and_return([])
+      Bandsintown::Event.should_receive(:request_and_parse).with(:get, "daily").and_return([])
       Bandsintown::Event.daily
     end
     it "should return an array of Bandsintown::Events built from the response" do
@@ -64,7 +67,7 @@ describe Bandsintown::Event do
       @args = { :location => "Boston, MA", :radius => 50, :date => "2010-03-02" }
     end
     it "should request and parse a call to the BIT on sale soon api method" do
-      Bandsintown::Event.should_receive(:request_and_parse).with("on_sale_soon", @args).and_return([])
+      Bandsintown::Event.should_receive(:request_and_parse).with(:get, "on_sale_soon", @args).and_return([])
       Bandsintown::Event.on_sale_soon(@args)
     end
     it "should return an array of Bandsintown::Events built from the response" do
@@ -111,7 +114,7 @@ describe Bandsintown::Event do
       @built_event = Bandsintown::Event.build_from_json(@event_hash)
     end
     it "should return a built Event" do
-      @built_event.class.should == Bandsintown::Event
+      @built_event.should be_instance_of(Bandsintown::Event)
     end
     it "should set the Event id" do
       @built_event.bandsintown_id.should == @event_id
@@ -139,18 +142,31 @@ describe Bandsintown::Event do
       Bandsintown::Event.build_from_json(@event_hash).on_sale_datetime.should be_nil
     end
     it "should set the Event's Venue" do
-      built_venue = mock(Bandsintown::Venue)
-      Bandsintown::Venue.should_receive(:new).with(@venue_hash).and_return(built_venue)
-      @built_event = Bandsintown::Event.build_from_json(@event_hash)
-      @built_event.venue.should == built_venue
+      venue = @built_event.venue
+      venue.should be_instance_of(Bandsintown::Venue)
+      venue.bandsintown_id.should == 327987
+      venue.bandsintown_url.should == "http://www.bandsintown.com/venue/327987"
+      venue.region.should == "MA"
+      venue.city.should == "Boston"
+      venue.name.should == "Paradise Rock Club"
+      venue.country.should == "United States"
+      venue.latitude.should == 42.37
+      venue.longitude.should == 71.03
     end
     it "should set the Event's Artists" do
-      built_artist_1 = mock(Bandsintown::Artist)
-      built_artist_2 = mock(Bandsintown::Artist)
-      Bandsintown::Artist.should_receive(:new).with(:name => @artist_1["name"], :url => @artist_1["url"], :mbid => @artist_1["mbid"]).and_return(built_artist_1)
-      Bandsintown::Artist.should_receive(:new).with(:name => @artist_2["name"], :url => @artist_2["url"], :mbid => @artist_2["mbid"]).and_return(built_artist_2)
-      @built_event = Bandsintown::Event.build_from_json(@event_hash)
-      @built_event.artists.should == [built_artist_1, built_artist_2]
+      artists = @built_event.artists
+      artists.should be_instance_of(Array)
+      artists.size.should == 2
+      
+      artists.first.should be_instance_of(Bandsintown::Artist)
+      artists.first.name.should == "Little Brother"
+      artists.first.bandsintown_url.should == "http://www.bandsintown.com/LittleBrother"
+      artists.first.mbid.should == "b929c0c9-5de0-4d87-8eb9-365ad1725629"
+      
+      artists.last.should be_instance_of(Bandsintown::Artist)
+      artists.last.name.should == "Joe Scudda"
+      artists.last.bandsintown_url.should == "http://www.bandsintown.com/JoeScudda"
+      artists.last.mbid.should be_nil          
     end
   end
   
@@ -166,4 +182,65 @@ describe Bandsintown::Event do
       event.tickets_available?.should be_false
     end
   end
-end
+  
+  describe ".create(options = {})" do
+    before(:each) do
+      @options = { :artists => [], :venue => {}, :datetime => '' }
+      @response = { "message" => "Event successfully submitted (pending approval)" }
+      Bandsintown::Event.stub!(:request_and_parse).and_return(@response)
+    end
+    it "should request and parse a call to the BIT events - create API mehod" do
+      Bandsintown::Event.should_receive(:request_and_parse).with(:post, "create", anything).and_return(@response)
+      Bandsintown::Event.create(@options)
+    end
+    it "should return the response message if an event was successfully submitted using a non-trusted app_id" do
+      Bandsintown::Event.should_not_receive(:build_from_json)
+      Bandsintown::Event.create(@options).should == @response["message"]
+    end
+    it "should return a Bandsintown::Event build from the response if an event was sucessfully submitted using a trusted app_id" do
+      Bandsintown::Event.stub!(:request_and_parse).and_return({ "event" => "data" })
+      event = mock(Bandsintown::Event)
+      Bandsintown::Event.should_receive(:build_from_json).with("data").and_return(event)
+      Bandsintown::Event.create(@options).should == event
+    end
+    describe "event options" do
+      before(:each) do
+        Bandsintown::Event.stub!(:parse_artists)
+        Bandsintown::Event.stub!(:parse_datetime)
+        Bandsintown::Event.stub!(:parse_venue)
+      end
+      
+      it "should parse the artists using parse_artists" do
+        @options = { :artists => ["Evidence", "Alchemist"] }
+        Bandsintown::Event.should_receive(:parse_artists).with(@options[:artists]).and_return('parsed')
+        expected_event_params = { :artists => 'parsed' }
+        Bandsintown::Event.should_receive(:request_and_parse).with(:post, "create", :event => hash_including(expected_event_params))
+      end
+      
+      it "should parse the datetime using parse_datetime" do
+        @options = { :datetime => "2010-06-01T20:30:00" }
+        Bandsintown::Event.should_receive(:parse_datetime).with(@options[:datetime]).and_return('parsed')
+        expected_event_params = { :datetime => "parsed" }
+        Bandsintown::Event.should_receive(:request_and_parse).with(:post, "create", :event => hash_including(expected_event_params))
+      end
+      
+      it "should parse the on_sale_datetime using parse_datetime" do
+        @options = { :on_sale_datetime => "2010-06-01T20:30:00" }
+        Bandsintown::Event.should_receive(:parse_datetime).with(@options[:on_sale_datetime]).and_return('parsed')
+        expected_event_params = { :on_sale_datetime => "parsed" }
+        Bandsintown::Event.should_receive(:request_and_parse).with(:post, "create", :event => hash_including(expected_event_params))
+      end
+      
+      it "should parse the venue using parse_venue" do
+        @options = { :venue => "data" }
+        Bandsintown::Event.should_receive(:parse_venue).with("data").and_return("venue")
+        expected_event_params = { :venue => "venue" }
+        Bandsintown::Event.should_receive(:request_and_parse).with(:post, "create", :event => hash_including(expected_event_params))
+      end
+      
+      after(:each) do
+        Bandsintown::Event.create(@options)
+      end
+    end
+  end
+end