thetvdb_party 0.0.12.pre → 0.0.13.pre

data/lib/thetvdb_party/client.rb

@@ -22,8 +22,10 @@ module TheTvDbParty
     @language = nil
 
     # Creates a new TheTvDb client with the given API key
-    # apikey::  The API key to use when accessing the ThTvDb programmers API
-    def initialize(apikey)
+    # Parameters::
+    #   +apikey+::  Optional. The API key to use when accessing the ThTvDb programmers API
+    # Remarks::     if +apikey+ is +nil+, only the #get_series and #search methods will work, as they do not require an API key.
+    def initialize(apikey = nil)
       @apikey = apikey
     end
 

data/lib/thetvdb_party/searchseriesrecord.rb

@@ -54,19 +54,30 @@ module TheTvDbParty
 
     private
     def read_hash_values
-      def client; @client end
-      def id; @hashValues["id"] ? @hashValues["id"].to_i : -1 end
-      def seriesid; @hashValues["seriesid"] ? @hashValues["seriesid"].to_i : -1 end
-      def language; @hashValues["language"] end
-      def seriesname; @hashValues["SeriesName"] end
-      def aliasnames; @hashValues["AliasNames"] ? @hashValues["AliasNames"].split('|').reject { |a| a.nil? || a.empty? } : [] end
-      def bannerpath_relative; @hashValues["banner"] end
-      def overview; @hashValues["Overview"] end
-      def firstaired; @hashValues["FirstAired"] ? Date.parse(@hashValues["FirstAired"]) : nil end
-      def imdb_id; @hashValues["IMDB_ID"] end
-      def zap2it_id; @hashValues["zap2it_id"] end
-      def network; @hashValues["Network"] end
-      def bannerpath_full; bannerpath_relative ? URI::join(BASE_URL, "banners/", bannerpath_relative) : nil end
+      begin
+        @id = @hashValues["id"] ? Integer(@hashValues["id"]) : -1
+      rescue ArgumentError
+        @id = -1
+      end
+      begin
+        @seriesid = @hashValues["seriesid"] ? Integer(@hashValues["seriesid"]) : -1
+      rescue ArgumentError
+        @seriesid = -1
+      end
+      @language = @hashValues["language"]
+      @seriesname = @hashValues["SeriesName"]
+      @aliasnames = @hashValues["AliasNames"] ? @hashValues["AliasNames"].split('|').reject { |a| a.nil? || a.empty? } : []
+      @bannerpath_relative = @hashValues["banner"]
+      @overview = @hashValues["Overview"]
+      begin
+        @firstaired = @hashValues["FirstAired"] ? Date.parse(@hashValues["FirstAired"]) : nil
+      rescue ArgumentError
+        @firstaired = nil
+      end
+      @imdb_id = @hashValues["IMDB_ID"]
+      @zap2it_id = @hashValues["zap2it_id"]
+      @network = @hashValues["Network"]
+      @bannerpath_full = bannerpath_relative ? URI::join(BASE_URL, "banners/", bannerpath_relative) : nil
 
       nil
     end

data/lib/thetvdb_party/version.rb

@@ -1,4 +1,4 @@
 module TheTvDbParty
   # The current version of the *thetvdb_party* gem
-  VERSION = "0.0.12.pre"
+  VERSION = "0.0.13.pre"
 end

data/spec/thetvdb_party/actor_spec.rb

@@ -26,16 +26,16 @@ describe 'TheTvDbParty::Actor' do
 
   it 'should have a relative/full image path' do
     record = TheTvDbParty::Actor.new(nil, { "Image" => "actors/27747.jpg" })
-    expect(record.imagepath_relative).to be_an_instance_of(String)
-    expect(record.imagepath_full).to be_an_instance_of(URI)
-    expect(record.imagepath_relative).to eq("actors/27747.jpg")
-    expect(record.imagepath_full).to eq(URI::join(TheTvDbParty::BASE_URL, 'banners/', 'actors/27747.jpg'))
+    expect(record.image_path_relative).to be_an_instance_of(String)
+    expect(record.image_path_full).to be_a(URI::Generic)
+    expect(record.image_path_relative).to eq("actors/27747.jpg")
+    expect(record.image_path_full).to eq(URI::join(TheTvDbParty::BASE_URL, 'banners/', 'actors/27747.jpg'))
   end
 
   it 'should have a nil relative/full image path, if not specified' do
     record = TheTvDbParty::Actor.new(nil, {})
-    expect(record.imagepath_relative).to be_nil
-    expect(record.imagepath_full).to be_nil
+    expect(record.image_path_relative).to be_nil
+    expect(record.image_path_full).to be_nil
   end
 
   it 'should have a name field' do
@@ -51,23 +51,23 @@ describe 'TheTvDbParty::Actor' do
 
   it 'should have a sorting order between 0-3' do
     record = TheTvDbParty::Actor.new(nil, { "SortOrder" => "2" })
-    expect(record.sortOrder).to be_an_instance_of(Fixnum)
-    expect(record.sortOrder).to be_between(0, 3).inclusive
-    expect(record.sortOrder).to eq(2)
+    expect(record.sort_order).to be_an_instance_of(Fixnum)
+    expect(record.sort_order).to be_between(0, 3).inclusive
+    expect(record.sort_order).to eq(2)
   end
 
   it 'should have a 0 sorting order, if invalid specified' do
     record = TheTvDbParty::Actor.new(nil, { "SortOrder" => "INVALID_SORT_ORDER" })
-    expect(record.sortOrder).to be_an_instance_of(Fixnum)
-    expect(record.sortOrder).to be_between(0, 3).inclusive
-    expect(record.sortOrder).to eq(0)
+    expect(record.sort_order).to be_an_instance_of(Fixnum)
+    expect(record.sort_order).to be_between(0, 3).inclusive
+    expect(record.sort_order).to eq(0)
   end
 
   it 'should have a 0 sorting order, if invalid specified' do
     record = TheTvDbParty::Actor.new(nil, {  })
-    expect(record.sortOrder).to be_an_instance_of(Fixnum)
-    expect(record.sortOrder).to be_between(0, 3).inclusive
-    expect(record.sortOrder).to eq(0)
+    expect(record.sort_order).to be_an_instance_of(Fixnum)
+    expect(record.sort_order).to be_between(0, 3).inclusive
+    expect(record.sort_order).to eq(0)
   end
 
   it 'should not instantiate when created without hash values' do

data/spec/thetvdb_party/banner_spec.rb

@@ -26,62 +26,62 @@ describe 'TheTvDbParty::Banner' do
 
   it 'should have a relative/full banner path' do
     record = TheTvDbParty::Banner.new(nil, { "BannerPath" => "text/80348.jpg" })
-    expect(record.bannerpath_relative).to be_an_instance_of(String)
-    expect(record.bannerpath_full).to be_an_instance_of(URI)
-    expect(record.bannerpath_relative).to eq("text/80348.jpg")
-    expect(record.bannerpath_full).to eq(URI::join(TheTvDbParty::BASE_URL, 'banners/', "text/80348.jpg"))
+    expect(record.banner_path_relative).to be_an_instance_of(String)
+    expect(record.banner_path_full).to be_a(URI::Generic)
+    expect(record.banner_path_relative).to eq("text/80348.jpg")
+    expect(record.banner_path_full).to eq(URI::join(TheTvDbParty::BASE_URL, 'banners/', "text/80348.jpg"))
   end
 
   it 'should have a nil relative/full banner path, if not specified' do
     record = TheTvDbParty::Banner.new(nil, {})
-    expect(record.bannerpath_relative).to be_nil
-    expect(record.bannerpath_full).to be_nil
+    expect(record.banner_path_relative).to be_nil
+    expect(record.banner_path_full).to be_nil
   end
 
   it 'should have a relative/full thumbnail path' do
     record = TheTvDbParty::Banner.new(nil, { "ThumbnailPath" => "_cache/fanart/original/80348-49.jpg" })
-    expect(record.bannerpath_relative).to be_an_instance_of(String)
-    expect(record.bannerpath_full).to be_an_instance_of(URI)
-    expect(record.bannerpath_relative).to eq("_cache/fanart/original/80348-49.jpg")
-    expect(record.bannerpath_full).to eq(URI::join(TheTvDbParty::BASE_URL, 'banners/', "_cache/fanart/original/80348-49.jpg"))
+    expect(record.thumbnail_path_relative).to be_an_instance_of(String)
+    expect(record.thumbnail_path_full).to be_a(URI::Generic)
+    expect(record.thumbnail_path_relative).to eq("_cache/fanart/original/80348-49.jpg")
+    expect(record.thumbnail_path_full).to eq(URI::join(TheTvDbParty::BASE_URL, 'banners/', "_cache/fanart/original/80348-49.jpg"))
   end
 
   it 'should have a nil relative/full thumbnail path, if not specified' do
     record = TheTvDbParty::Banner.new(nil, {})
-    expect(record.bannerpath_relative).to be_nil
-    expect(record.bannerpath_full).to be_nil
+    expect(record.thumbnail_path_relative).to be_nil
+    expect(record.thumbnail_path_full).to be_nil
   end
 
   it 'should have a relative/full vignette path' do
     record = TheTvDbParty::Banner.new(nil, { "VignettePath" => "fanart/vignette/80348-49.jpg" })
-    expect(record.bannerpath_relative).to be_an_instance_of(String)
-    expect(record.bannerpath_full).to be_an_instance_of(URI)
-    expect(record.bannerpath_relative).to eq("fanart/vignette/80348-49.jpg")
-    expect(record.bannerpath_full).to eq(URI::join(TheTvDbParty::BASE_URL, 'banners/', "fanart/vignette/80348-49.jpg"))
+    expect(record.vignette_path_relative).to be_an_instance_of(String)
+    expect(record.vignette_path_full).to be_a(URI::Generic)
+    expect(record.vignette_path_relative).to eq("fanart/vignette/80348-49.jpg")
+    expect(record.vignette_path_full).to eq(URI::join(TheTvDbParty::BASE_URL, 'banners/', "fanart/vignette/80348-49.jpg"))
   end
 
   it 'should have a nil relative/full vignette path, if not specified' do
     record = TheTvDbParty::Banner.new(nil, {})
-    expect(record.bannerpath_relative).to be_nil
-    expect(record.bannerpath_full).to be_nil
+    expect(record.vignette_path_relative).to be_nil
+    expect(record.vignette_path_full).to be_nil
   end
 
   it 'should have a banner type' do
     [ "poster", "fanart", "series", "season" ].each do |expected_valid_bannertype|
       record = TheTvDbParty::Banner.new(nil, { "BannerType" => expected_valid_bannertype })
-      expect(record.bannertype).to be_an_instance_of(String)
-      expect(record.bannertype).to eq(expected_valid_bannertype)
+      expect(record.banner_type).to be_an_instance_of(String)
+      expect(record.banner_type).to eq(expected_valid_bannertype)
     end
   end
 
   it 'should have a nil banner type, if specified is invalid' do
     record = TheTvDbParty::Banner.new(nil, { "BannerType" => "INVALID_BANNERTYPE_STRING" })
-    expect(record.bannertype).to be_nil
+    expect(record.banner_type).to be_nil
   end
 
   it 'should have a nil banner type, if not specified' do
     record = TheTvDbParty::Banner.new(nil, {})
-    expect(record.bannertype).to be_nil
+    expect(record.banner_type).to be_nil
   end
 
   it 'should have a secondary banner type' do
@@ -93,25 +93,25 @@ describe 'TheTvDbParty::Banner' do
     }.each do |expected_valid_bannertype, expected_valid_bannerytype2s|
       expected_valid_bannerytype2s.each do |expected_valid_bannerytype2|
         record = TheTvDbParty::Banner.new(nil, { "BannerType" => expected_valid_bannertype, "BannerType2" => expected_valid_bannerytype2 })
-        expect(record.bannertype2).to be_an_instance_of(String)
-        expect(record.bannertype2).to eq(expected_valid_bannerytype2)
+        expect(record.banner_type_2).to be_an_instance_of(String)
+        expect(record.banner_type_2).to eq(expected_valid_bannerytype2)
       end
     end
   end
 
   it 'should have a nil secondary banner type, if the primary banner type is valid, but the specified secondary banner type is invalid' do
     record = TheTvDbParty::Banner.new(nil, { "BannerType" => "poster", "BannerType2" => "abcdef" })
-    expect(record.bannertype2).to be_nil
+    expect(record.banner_type_2).to be_nil
   end
 
   it 'should have a nil secondary banner type, if the primary banner type is valid, but the specified secondary banner type is invalid for that primary banner type' do
     record = TheTvDbParty::Banner.new(nil, { "BannerType" => "poster", "BannerType2" => "seasonwide" })
-    expect(record.bannertype2).to be_nil
+    expect(record.banner_type_2).to be_nil
   end
 
   it 'should have a nil secondary banner type, if the primary banner type is nil' do
     record = TheTvDbParty::Banner.new(nil, { "BannerType2" => "seasonwide" })
-    expect(record.bannertype2).to be_nil
+    expect(record.banner_type_2).to be_nil
   end
 
   it 'should have a language associated with it' do
@@ -144,6 +144,12 @@ describe 'TheTvDbParty::Banner' do
     expect(record.rating).to be 6.6667
   end
 
+  it 'should have a zero rating, if invalid specified' do
+    record = TheTvDbParty::Banner.new(nil, { "Rating" => "INVALID_RATING" })
+    expect(record.rating).to be_an_instance_of(Float)
+    expect(record.rating).to be 0.0
+  end
+
   it 'should have a zero rating, if it is not specified' do
     record = TheTvDbParty::Banner.new(nil, {  })
     expect(record.rating).to be_an_instance_of(Float)
@@ -152,41 +158,41 @@ describe 'TheTvDbParty::Banner' do
 
   it 'should have a rating count' do
     record = TheTvDbParty::Banner.new(nil, { "RatingCount" => "6" })
-    expect(record.rating).to be_an_instance_of(Fixnum)
-    expect(record.rating).to be >= 0
-    expect(record.rating).to be >= 6
+    expect(record.rating_count).to be_an_instance_of(Fixnum)
+    expect(record.rating_count).to be >= 0
+    expect(record.rating_count).to eq(6)
   end
 
   it 'should have a zero rating count, if it is not specified' do
     record = TheTvDbParty::Banner.new(nil, {  })
-    expect(record.rating).to be_an_instance_of(Fixnum)
-    expect(record.rating).to be 0
+    expect(record.rating_count).to be_an_instance_of(Fixnum)
+    expect(record.rating_count).to be 0
   end
 
   it 'should have a true series name flag' do
     record = TheTvDbParty::Banner.new(nil, { "BannerType" => "fanart", "SeriesName" => "true" })
-    expect(record.seriesName).to be_an_instance_of(TrueClass).or be_an_instance_of(FalseClass)
-    expect(record.seriesName).to be true
+    expect(record.series_name).to be_an_instance_of(TrueClass).or be_an_instance_of(FalseClass)
+    expect(record.series_name).to be true
   end
 
   it 'should have a false series name flag, if banner type is not fanart' do
     [ "poster", "series", "season" ].each do |expected_valid_bannertype|
       record = TheTvDbParty::Banner.new(nil, { "BannerType" => expected_valid_bannertype, "SeriesName" => "true" })
-      expect(record.seriesName).to be_an_instance_of(TrueClass).or be_an_instance_of(FalseClass)
-      expect(record.seriesName).to be false
+      expect(record.series_name).to be_an_instance_of(TrueClass).or be_an_instance_of(FalseClass)
+      expect(record.series_name).to be false
     end
   end
 
   it 'should have a false series name flag, if it is not specified' do
-    record = TheTvDbParty::Banner.new(nil, { "BannerType" => "fanart", "SeriesName" => "true" })
-    expect(record.seriesName).to be_an_instance_of(TrueClass).or be_an_instance_of(FalseClass)
-    expect(record.seriesName).to be false
+    record = TheTvDbParty::Banner.new(nil, { "BannerType" => "fanart" })
+    expect(record.series_name).to be_an_instance_of(TrueClass).or be_an_instance_of(FalseClass)
+    expect(record.series_name).to be false
   end
 
   it 'should have a zero rating count, if it is not specified' do
     record = TheTvDbParty::Banner.new(nil, {  })
-    expect(record.rating).to be_an_instance_of(Fixnum)
-    expect(record.rating).to be 0
+    expect(record.rating_count).to be_an_instance_of(Fixnum)
+    expect(record.rating_count).to be 0
   end
 
   it 'should have the color fields' do
@@ -195,36 +201,36 @@ describe 'TheTvDbParty::Banner' do
     expect(record.light_accent_color).to match_array([81, 81, 81])
     expect(record.dark_accent_color).to be_an_instance_of(Array)
     expect(record.dark_accent_color).to match_array([15, 15, 15])
-    expect(record.midtone_color).to be_an_instance_of(Array)
-    expect(record.midtone_color).to match_array([201, 226, 246])
+    expect(record.neutral_midtone_color).to be_an_instance_of(Array)
+    expect(record.neutral_midtone_color).to match_array([201, 226, 246])
   end
 
   it 'should have nil color fields, if banner type is not fanart' do
     record = TheTvDbParty::Banner.new(nil, { "Colors" => "|81,81,81|15,15,15|201,226,246|" })
     expect(record.light_accent_color).to be_nil
     expect(record.dark_accent_color).to be_nil
-    expect(record.midtone_color).to be_nil
+    expect(record.neutral_midtone_color).to be_nil
   end
 
   it 'should have nil color fields, if invalid colors are specified' do
     record = TheTvDbParty::Banner.new(nil, { "Colors" => "INVALID_COLORS" })
     expect(record.light_accent_color).to be_nil
     expect(record.dark_accent_color).to be_nil
-    expect(record.midtone_color).to be_nil
+    expect(record.neutral_midtone_color).to be_nil
   end
 
   it 'should have nil color fields, if no colors are specified' do
     record = TheTvDbParty::Banner.new(nil, {  })
     expect(record.light_accent_color).to be_nil
     expect(record.dark_accent_color).to be_nil
-    expect(record.midtone_color).to be_nil
+    expect(record.neutral_midtone_color).to be_nil
   end
 
   it 'should have nil color fields, if colors are specified, but at least one of the colors does not have exactly three elements' do
-    record = TheTvDbParty::Banner.new(nil, { "Colors" => "|81,81,81,4|15,15,15|201,226,246|" })
+    record = TheTvDbParty::Banner.new(nil, { "BannerType" => "fanart", "Colors" => "|81,81,81,4|15,15,15|201,226,246|" })
     expect(record.light_accent_color).to be_nil
     expect(record.dark_accent_color).to be_nil
-    expect(record.midtone_color).to be_nil
+    expect(record.neutral_midtone_color).to be_nil
   end
 
   it 'should not instantiate when created without hash values' do

data/spec/thetvdb_party/baseepisoderecord_spec.rb

@@ -109,20 +109,20 @@ describe 'TheTvDbParty::BaseEpisodeRecord' do
 
   it 'should have a DVD season number' do
     record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "DVD_season" => "1" })
-    expect(record.dvd_episodenumber).to be_an_instance_of(Fixnum)
-    expect(record.dvd_episodenumber).to eq(1.2)
+    expect(record.dvd_season).to be_an_instance_of(Fixnum)
+    expect(record.dvd_season).to eq(1)
   end
 
   it 'should have a negative DVD season number, if invalid specified' do
     record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "DVD_season" => "INVALID_DVD_SEASON" })
-    expect(record.dvd_episodenumber).to be_an_instance_of(Fixnum)
-    expect(record.dvd_episodenumber).to be < 0
+    expect(record.dvd_season).to be_an_instance_of(Fixnum)
+    expect(record.dvd_season).to be < 0
   end
 
   it 'should have a negative DVD season number, if not specified' do
     record = TheTvDbParty::BaseEpisodeRecord.new(nil, {  })
-    expect(record.dvd_episodenumber).to be_an_instance_of(Fixnum)
-    expect(record.dvd_episodenumber).to be < 0
+    expect(record.dvd_season).to be_an_instance_of(Fixnum)
+    expect(record.dvd_season).to be < 0
   end
 
   it 'should have a single element array for the director, if only one name is specified' do
@@ -145,6 +145,404 @@ describe 'TheTvDbParty::BaseEpisodeRecord' do
     expect(record.director).to be_empty
   end
 
+  it 'should have a episode image flag' do
+    (1..6).to_a.each do |expected_valid_epimgflag|
+      record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "EpImgFlag" => expected_valid_epimgflag.to_s })
+      expect(record.epimgflag).to be_an_instance_of(Fixnum)
+      expect(record.epimgflag).to eq(expected_valid_epimgflag)
+    end
+  end
+
+  it 'should have a zero episode image flag, if invalid specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "EpImgFlag" => "INVALID_EPIMGFLAG" })
+    expect(record.epimgflag).to be_an_instance_of(Fixnum)
+    expect(record.epimgflag).to eq(0)
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "EpImgFlag" => "9" })
+    expect(record.epimgflag).to be_an_instance_of(Fixnum)
+    expect(record.epimgflag).to eq(0)
+  end
+
+  it 'should have a zero episode image flag, if not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {  })
+    expect(record.epimgflag).to be_an_instance_of(Fixnum)
+    expect(record.epimgflag).to eq(0)
+  end
+
+  it 'should have an episode name' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "EpisodeName" => "White Orchids" })
+    expect(record.episodename).to be_an_instance_of(String)
+    expect(record.episodename).to eq("White Orchids")
+  end
+
+  it 'should have a nil episode name, if not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {  })
+    expect(record.episodename).to be_nil
+  end
+
+  it 'should have an episode number' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "EpisodeNumber" => "1" })
+    expect(record.episodenumber).to be_an_instance_of(Fixnum)
+    expect(record.episodenumber).to eq(1)
+  end
+
+  it 'should have a negative episode number, if invalid specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "EpisodeNumber" => "INVALID_EPISODENUMBER" })
+    expect(record.episodenumber).to be_an_instance_of(Fixnum)
+    expect(record.episodenumber).to be < 0
+  end
+
+  it 'should have a negative episode number, if not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {  })
+    expect(record.episodenumber).to be_an_instance_of(Fixnum)
+    expect(record.episodenumber).to be < 0
+  end
+
+  it 'should have a first aired date' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "FirstAired" => "2009-11-15" })
+    expect(record.firstaired).to be_an_instance_of(Date)
+    expect(record.firstaired).to eq(Date.new(2009, 11, 15))
+  end
+
+  it 'should have a nil first aired date, if invalid specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "FirstAired" => "INVALID_FIRSTAIRED" })
+    expect(record.firstaired).to be_nil
+  end
+
+  it 'should have a nil first aired date, if not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {  })
+    expect(record.firstaired).to be_nil
+  end
+
+  it 'should have a single element array for the guest stars, if only one name is specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "GuestStars" => "Lindsay Duncan" })
+    expect(record.gueststars).to match_array(["Lindsay Duncan"])
+  end
+
+  it 'should have a multi element array for the guest stars, if a pipe-delimited list is specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "GuestStars" => "Lindsay Duncan|Peter O'Brien|Sharon Duncan Brewster" })
+    expect(record.gueststars).to match_array(["Lindsay Duncan", "Peter O'Brien", "Sharon Duncan Brewster"])
+  end
+
+  it 'should have a multi element array for the guest stars, if a pipe-surrounded list is specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "GuestStars" => "|Lindsay Duncan|Peter O'Brien|Sharon Duncan Brewster|" })
+    expect(record.gueststars).to match_array(["Lindsay Duncan", "Peter O'Brien", "Sharon Duncan Brewster"])
+  end
+
+  it 'should have an empty array for guest stars, if none is specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {  })
+    expect(record.gueststars).to be_empty
+  end
+
+  it 'should have an IMDB id' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {"IMDB_ID" => "abcd1234"})
+    expect(record.imdb_id).to be_an_instance_of(String)
+    expect(record.imdb_id).to eq("abcd1234")
+  end
+
+  it 'should have a nil IMDB id, if none specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { })
+    expect(record.imdb_id).to be_nil
+  end
+
+  it 'should have a language associated with the record' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {"Language" => "en"})
+    expect(record.language).to be_a(String)
+    expect(record.language).to eq("en")
+  end
+
+  it 'should have a nil language associated with the record, if not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {})
+    expect(record.language).to be_nil
+  end
+
+  it 'should have an overview' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {"Overview" => "Location: Bowie Base One, Mars Date: 21st November 2059 Enemies: The Flood The Doctor..."})
+    expect(record.overview).to be_a(String)
+    expect(record.overview).to eq("Location: Bowie Base One, Mars Date: 21st November 2059 Enemies: The Flood The Doctor...")
+  end
+
+  it 'should have a nil overview, if not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { })
+    expect(record.overview).to be_nil
+  end
+
+  it 'should have an production code' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {"ProductionCode" => "abcd1234"})
+    expect(record.productioncode).to be_an_instance_of(String)
+    expect(record.productioncode).to eq("abcd1234")
+  end
+
+  it 'should have a nil production code, if none specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { })
+    expect(record.productioncode).to be_nil
+  end
+
+  it 'should have a rating' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "Rating" => "6.6667" })
+    expect(record.rating).to be_an_instance_of(Float)
+    expect(record.rating).to be >= 0.0
+    expect(record.rating).to be 6.6667
+  end
+
+  it 'should have a zero rating, if invalid specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "Rating" => "INVALID_RATING" })
+    expect(record.rating).to be_an_instance_of(Float)
+    expect(record.rating).to be 0.0
+  end
+
+  it 'should have a zero rating, if it is not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {  })
+    expect(record.rating).to be_an_instance_of(Float)
+    expect(record.rating).to be 0.0
+  end
+
+  it 'should have a rating count' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "RatingCount" => "6" })
+    expect(record.ratingcount).to be_an_instance_of(Fixnum)
+    expect(record.ratingcount).to be >= 0
+    expect(record.ratingcount).to eq(6)
+  end
+
+  it 'should have a zero rating count, if invalid specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "RatingCount" => "INVALID_RATINGCOUNT" })
+    expect(record.ratingcount).to be_an_instance_of(Fixnum)
+    expect(record.ratingcount).to be 0
+  end
+
+  it 'should have a zero rating count, if it is not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {  })
+    expect(record.ratingcount).to be_an_instance_of(Fixnum)
+    expect(record.ratingcount).to be 0
+  end
+
+  it 'should have an season number' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "SeasonNumber" => "1" })
+    expect(record.seasonnumber).to be_an_instance_of(Fixnum)
+    expect(record.seasonnumber).to eq(1)
+  end
+
+  it 'should have a negative season number, if invalid specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "SeasonNumber" => "INVALID_SEASONNUMBER" })
+    expect(record.seasonnumber).to be_an_instance_of(Fixnum)
+    expect(record.seasonnumber).to be < 0
+  end
+
+  it 'should have a negative season number, if not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {  })
+    expect(record.seasonnumber).to be_an_instance_of(Fixnum)
+    expect(record.seasonnumber).to be < 0
+  end
+
+  it 'should have a single element array for the writer, if only one name is specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "Writer" => "Russell T Davies" })
+    expect(record.writer).to match_array(["Russell T Davies"])
+  end
+
+  it 'should have a multi element array for the writer, if a pipe-delimited list is specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "Writer" => "Russell T Davies|Phil Ford" })
+    expect(record.writer).to match_array(["Russell T Davies", "Phil Ford"])
+  end
+
+  it 'should have a multi element array for the writer, if a pipe-surrounded list is specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "Writer" => "|Russell T Davies|Phil Ford|" })
+    expect(record.writer).to match_array(["Russell T Davies", "Phil Ford"])
+  end
+
+  it 'should have an empty array for writer, if none is specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {  })
+    expect(record.writer).to be_empty
+  end
+
+  it 'should have an absolute number' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {"absolute_number" => "151"})
+    expect(record.absolute_number).to be_a(Fixnum)
+    expect(record.absolute_number).to eq(151)
+  end
+
+  it 'should have a negative absolute number, if invalid specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {"absolute_number" => "INVALID_ABSOLUTENUMBER"})
+    expect(record.absolute_number).to be_a(Fixnum)
+    expect(record.absolute_number).to be < 0
+  end
+
+  it 'should have a negative absolute number, if not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { })
+    expect(record.absolute_number).to be_a(Fixnum)
+    expect(record.absolute_number).to be < 0
+  end
+
+  it 'should have an airs after season number' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {"airsafter_season" => "2"})
+    expect(record.airsafter_season).to be_a(Fixnum)
+    expect(record.airsafter_season).to eq(2)
+  end
+
+  it 'should have a negative airs after season number, if invalid specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {"airsafter_season" => "INVALID_AIRSAFTER_SEASON"})
+    expect(record.airsafter_season).to be_a(Fixnum)
+    expect(record.airsafter_season).to be < 0
+  end
+
+  it 'should have a negative airs after season number, if not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { })
+    expect(record.airsafter_season).to be_a(Fixnum)
+    expect(record.airsafter_season).to be < 0
+  end
+
+  it 'should have an airs before episode number' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {"airsbefore_episode" => "2"})
+    expect(record.airsbefore_episode).to be_a(Fixnum)
+    expect(record.airsbefore_episode).to eq(2)
+  end
+
+  it 'should have a negative airs before episode number, if invalid specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {"airsbefore_episode" => "INVALID_AIRSBEFORE_EPISODE"})
+    expect(record.airsbefore_episode).to be_a(Fixnum)
+    expect(record.airsbefore_episode).to be < 0
+  end
+
+  it 'should have a negative airs before episode number, if not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { })
+    expect(record.airsbefore_episode).to be_a(Fixnum)
+    expect(record.airsbefore_episode).to be < 0
+  end
+
+  it 'should have an airs before season number' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {"airsbefore_season" => "2"})
+    expect(record.airsbefore_season).to be_a(Fixnum)
+    expect(record.airsbefore_season).to eq(2)
+  end
+
+  it 'should have a negative airs before season number, if invalid specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {"airsbefore_season" => "INVALID_AIRSBEFORE_SEASON"})
+    expect(record.airsbefore_season).to be_a(Fixnum)
+    expect(record.airsbefore_season).to be < 0
+  end
+
+  it 'should have a negative airs before season number, if not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { })
+    expect(record.airsbefore_season).to be_a(Fixnum)
+    expect(record.airsbefore_season).to be < 0
+  end
+
+  it 'should have a relative/full episode image path' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {"filename" => "episodes/82459/5038185.jpg"})
+    expect(record.imagepath_relative).to be_a(String)
+    expect(record.imagepath_full).to be_a(URI::Generic)
+    expect(record.imagepath_relative).to eq("episodes/82459/5038185.jpg")
+    expect(record.imagepath_full).to eq(URI::join(TheTvDbParty::BASE_URL, 'banners/', "episodes/82459/5038185.jpg"))
+  end
+
+  it 'should have a nil relative/full episode image path, if not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { })
+    expect(record.imagepath_relative).to be_nil
+    expect(record.imagepath_full).to be_nil
+  end
+
+  it 'should have a last updated timestamp' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "lastupdated" => "1424691313" })
+    expect(record.lastupdated).to be_a(DateTime)
+    expect(record.lastupdated).to eq(Time.at(1424691313).to_datetime)
+  end
+
+  it 'should have a nil last updated timestamp, if invalid specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "lastupdated" => "INVALID_LASTUPDATED" })
+    expect(record.lastupdated).to be_nil
+  end
+
+  it 'should have a nil last updated timestamp, if not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {  })
+    expect(record.lastupdated).to be_nil
+  end
+
+  it 'should have a season number' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {"seasonid" => "2"})
+    expect(record.seasonid).to be_a(Fixnum)
+    expect(record.seasonid).to eq(2)
+  end
+
+  it 'should have a negative season number, if invalid specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {"seasonid" => "INVALID_SEASONID"})
+    expect(record.seasonid).to be_a(Fixnum)
+    expect(record.seasonid).to be < 0
+  end
+
+  it 'should have a negative airs before season number, if not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { })
+    expect(record.seasonid).to be_a(Fixnum)
+    expect(record.seasonid).to be < 0
+  end
+
+  it 'should have a series id' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {"seriesid" => "82459"})
+    expect(record.seriesid).to be_a(Fixnum)
+    expect(record.seriesid).to eq(82459)
+  end
+
+  it 'should have a negative series id, if invalid specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {"seriesid" => "INVALID_SERIESID"})
+    expect(record.seriesid).to be_a(Fixnum)
+    expect(record.seriesid).to be < 0
+  end
+
+  it 'should have a negative series id, if not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { })
+    expect(record.seriesid).to be_a(Fixnum)
+    expect(record.seriesid).to be < 0
+  end
+
+  it 'should have a thumbnail added date' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "thumb_added" => "2015-02-11 09:28:28" })
+    expect(record.thumb_added).to be_a(DateTime)
+    # expect(record.thumb_added).to eq(DateTime.new(2015, 02, 11, 9, 28, 28))
+  end
+
+  it 'should have a nil thumbnail added date, if invalid specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "thumb_added" => "INVALID_THUMB_ADDED" })
+    expect(record.thumb_added).to be_nil
+  end
+
+  it 'should have a nil thumbnail added date, if not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {  })
+    expect(record.thumb_added).to be_nil
+  end
+
+  it 'should have thumbnail height field' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "thumb_height" => "225" })
+    expect(record.thumb_height).to be_a(Fixnum)
+    expect(record.thumb_height).to eq(225)
+  end
+
+  it 'should have a zero thumbnail height, if invalid specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "thumb_width" => "INVALID_THUMB_HEIGHT" })
+    expect(record.thumb_height).to be_a(Fixnum)
+    expect(record.thumb_height).to eq(0)
+  end
+
+  it 'should have a zero thumbnail height, if not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {  })
+    expect(record.thumb_height).to be_a(Fixnum)
+    expect(record.thumb_height).to eq(0)
+  end
+
+  it 'should have thumbnail width field' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "thumb_width" => "400" })
+    expect(record.thumb_width).to be_a(Fixnum)
+    expect(record.thumb_width).to eq(400)
+  end
+
+  it 'should have a zero thumbnail width, if invalid specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, { "thumb_width" => "INVALID_THUMB_WIDTH" })
+    expect(record.thumb_width).to be_a(Fixnum)
+    expect(record.thumb_width).to eq(0)
+  end
+
+  it 'should have a zero thumbnail width, if not specified' do
+    record = TheTvDbParty::BaseEpisodeRecord.new(nil, {  })
+    expect(record.thumb_width).to be_a(Fixnum)
+    expect(record.thumb_width).to eq(0)
+  end
+
   it 'should not instantiate when created without hash values' do
     expect { TheTvDbParty::BaseEpisodeRecord.new(nil, nil) }.to raise_error
   end