tivohmo 0.2.3 → 0.3.0

data/lib/tivohmo/config.rb

@@ -0,0 +1,157 @@
+require 'hashie'
+
+module TivoHMO
+
+  class Config
+    include GemLogger::LoggerSupport
+    include Singleton
+
+    def initialize
+      super
+      @primary_data = Data.new
+      @secondary_data = Data.new
+    end
+
+
+    def setup(primary_filename, secondary_filename=nil)
+      @primary_file = primary_filename
+      @secondary_file = secondary_filename
+
+      @primary_data = Data.new
+      @secondary_data = Data.new
+
+      if File.exist?(@primary_file.to_s)
+        logger.info "Loading primary config from: '#{@primary_file}'"
+        @primary_data = Data.load(@primary_file)
+      else
+        logger.info "No primary config at file: '#{@primary_file}'"
+      end
+
+      # get secondary config from primary if present and not set explictly
+      secondary = get(:settings)
+      @secondary_file ||= File.expand_path(secondary) if secondary
+
+      if File.exist?(@secondary_file.to_s)
+        logger.info "Loading secondary config from: '#{@secondary_file}'"
+        @secondary_data = Data.load(@secondary_file)
+      else
+        logger.info "No secondary config at file: '#{@secondary_file}'"
+      end
+    end
+
+    def reset
+      @primary_file = @secondary_file = nil
+      @primary_data = @secondary_data = nil
+      @known_config = nil
+    end
+
+    def known_config
+      @known_config ||= {}
+    end
+
+    def get(scoped_key)
+      scoped_key = Array(scoped_key)
+      result = nil
+
+      key = scoped_key.pop
+      path = scoped_key
+      (0..path.size).to_a.reverse.each do |i|
+        partial = path[0, i] << key
+
+        begin
+          result = @secondary_data.deep_fetch(*partial)
+        rescue Data::UndefinedPathError
+          begin
+            result = @primary_data.deep_fetch(*partial)
+          rescue Data::UndefinedPathError
+          end
+        end
+
+        break if ! result.nil?
+      end
+
+      if result.nil?
+        registered = known_config[key]
+        result = registered[:default_value] if registered
+      end
+
+      result
+    end
+
+    def set(scoped_key, value, persist=true)
+      scoped_key = Array(scoped_key)
+      key = scoped_key.pop
+
+      val_hash = {key => value}
+      scoped_key.reverse.each do |k|
+        val_hash = {k => val_hash}
+      end
+
+      @secondary_data = @secondary_data.deep_merge(val_hash)
+      File.write(@secondary_file, YAML.dump(@secondary_data)) if persist && @secondary_file
+
+      registered = known_config[key]
+      if registered && registered[:on_change]
+        registered[:on_change].call
+      end
+    end
+
+    class Data < ::Hash
+      include Hashie::Extensions::IndifferentAccess
+      include Hashie::Extensions::DeepFetch
+
+      def self.load(filename)
+        h = Hashie::Extensions::Parsers::YamlErbParser.perform(filename)
+        new.replace(h)
+      end
+    end
+
+    module Mixin
+      extend ActiveSupport::Concern
+
+      included do
+        delegate :config_register,
+                 :config_get,
+                 :config_set,
+                 :to => "self.class"
+
+      end
+
+      module ClassMethods
+
+        def config_register(key, default_value, description, &on_change_block)
+          raise ArgumentError, "Config '#{key}' already registered" if Config.instance.known_config[key]
+
+          Config.instance.known_config[key] = {
+              default_value: default_value,
+              description: description,
+              source_path: config_path,
+              on_change: on_change_block
+          }
+        end
+
+        def config_get(key)
+          scoped_key = config_path << key
+          result = Config.instance.get(scoped_key)
+          result
+        end
+
+        def config_set(key, value)
+          Config.instance.set(key, value)
+        end
+
+        private
+
+        def config_path
+          path = self.name.underscore
+          path = path.sub(/.*tivo_hmo\//, '')
+          pieces = path.split('/')
+          pieces
+        end
+
+      end
+    end
+
+  end
+
+end

data/lib/tivohmo/server/views/_container.builder

@@ -5,7 +5,7 @@ xml.Item do
     xml.ContentType container.content_type
     xml.SourceFormat container.source_format
     xml.UniqueId format_uuid(container.uuid)
-    xml.TotalItems container.children.size
+    xml.TotalItems container.child_count
     xml.LastCaptureDate format_date(container.created_at) if container.created_at
   end
 

data/lib/tivohmo/server.rb

@@ -12,6 +12,10 @@ module TivoHMO
   # tivo format
   class Server < Sinatra::Base
     include GemLogger::LoggerSupport
+    include TivoHMO::Config::Mixin
+
+    config_register(:force_grouping, true,
+                    "Force groups/folders regardless of parameters supplied by the tivo request")
 
     disable :logging
     set :root, File.expand_path("../server", __FILE__)
@@ -211,8 +215,7 @@ module TivoHMO
       item_count = (params['ItemCount'] || 8).to_i
 
       # Yes or No, default no
-      # TODO: fix this when tivo side is fixed or config mechanism added to globally disable recurse
-      recurse = false #(params['Recurse'] == 'Yes')
+      recurse = config_get(:force_grouping) ? false : (params['Recurse'] == 'Yes')
 
       # csv of Type, Title, CreationDate, LastChangeDate, Random
       # reverse with preceding !
@@ -250,7 +253,7 @@ module TivoHMO
 
           children = select_all_items(children) if recurse
 
-          children = sort(children, sort_order) if sort_order
+          children = sort(children, sort_order) if sort_order && ! container.presorted
 
           if anchor_item
             anchor = server.find(anchor_item)

data/lib/tivohmo/version.rb

@@ -1,3 +1,3 @@
 module TivoHMO
-  VERSION = "0.2.3"
+  VERSION = "0.3.0"
 end

data/lib/tivohmo.rb

@@ -1,5 +1,6 @@
 require 'gem_logger'
 require "tivohmo/version"
 require "tivohmo/api"
+require "tivohmo/config"
 require "tivohmo/server"
 require "tivohmo/beacon"

data/spec/adapters/filesystem/file_item_spec.rb

@@ -20,7 +20,7 @@ describe TivoHMO::Adapters::Filesystem::FileItem do
         file = __FILE__
         subject = described_class.new(file)
         expect(subject).to be_a described_class
-        expect(subject.full_path).to eq File.expand_path(file)
+        expect(subject.file).to eq File.expand_path(file)
         expect(subject.title).to eq File.basename(file)
         expect(subject.modified_at).to_not be_nil
         expect(subject.created_at).to_not be_nil

data/spec/adapters/plex/application_spec.rb

@@ -1,7 +1,7 @@
 require_relative "../../spec_helper"
 require 'tivohmo/adapters/plex'
 
-describe TivoHMO::Adapters::Plex::Application do
+describe TivoHMO::Adapters::Plex::Application, :vcr do
 
 
   describe "#initialize" do
@@ -17,4 +17,13 @@ describe TivoHMO::Adapters::Plex::Application do
 
   end
 
+  describe "#children" do
+
+    it "should get children" do
+      app = described_class.new('localhost')
+      expect(app.children).to_not be_empty
+    end
+
+  end
+
 end

data/spec/adapters/plex/category_spec.rb

@@ -1,9 +1,9 @@
 require_relative "../../spec_helper"
 require 'tivohmo/adapters/plex'
 
-describe TivoHMO::Adapters::Plex::Category do
+describe TivoHMO::Adapters::Plex::Category, :vcr do
 
-  let(:plex_delegate) { plex_stub(::Plex::Section) }
+  let(:plex_delegate) { plex_movie_section }
 
   describe "#initialize" do
 
@@ -15,9 +15,10 @@ describe TivoHMO::Adapters::Plex::Category do
         expect(category).to be_a TivoHMO::API::Container
         expect(category.category_type).to eq(:newest)
         expect(category.category_value).to be_nil
+        expect(category.presorted).to eq(false)
         expect(category.title).to eq('Newest')
         expect(category.identifier).to eq(plex_delegate.key)
-        expect(category.modified_at).to eq(Time.at(plex_delegate.updated_at))
+        expect(category.modified_at).to eq(Time.at(plex_delegate.updated_at.to_i))
         expect(category.created_at).to eq(now)
       end
 
@@ -31,38 +32,110 @@ describe TivoHMO::Adapters::Plex::Category do
       expect(category.title).to eq('MyTitle')
     end
 
+    it "should set presorted if present" do
+      cval = {title: 'MyTitle', key: '/plex/key'}
+      category = described_class.new(plex_delegate, :by_year, nil, true)
+      expect(category.presorted).to eq(true)
+    end
+
   end
 
   describe "#children" do
 
     it "should memoize" do
-      listing = [plex_stub(::Plex::Movie, originally_available_at: "2013-01-02")]
-      allow(plex_delegate).to receive(:newest).and_return(listing)
       section = described_class.new(plex_delegate, :newest)
       expect(section.children.object_id).to eq(section.children.object_id)
     end
 
     it "should have children" do
-      listing = [
-          plex_stub(::Plex::Movie, originally_available_at: "2013-01-02"),
-          plex_stub(::Plex::Episode, originally_available_at: "2013-01-02"),
-          plex_stub(::Plex::Show)
-      ]
-      allow(plex_delegate).to receive(:newest).and_return(listing)
       section = described_class.new(plex_delegate, :newest)
-      expect(section.children.size).to eq(3)
+
+      expect(section.children.size).to_not be(0)
+
+      keys = section.children.collect(&:delegate).collect(&:key)
+      expected_keys = plex_delegate.newest.collect(&:key)
+      expect(keys).to include(*expected_keys)
+    end
+
+    it "should display non-zero child_count once children fetched" do
+      section = described_class.new(plex_delegate, :newest)
+
+      expect(section.child_count).to be(0)
+      section.children
+      expect(section.child_count).to_not be(0)
+      expect(section.child_count).to eq(section.children.size)
+    end
+
+    it "should have children with subtitles" do
+      section = described_class.new(plex_delegate, :newest)
+
+      subgroup = section.children.find {|c| c.is_a?(TivoHMO::Adapters::Plex::Group) }
+      expect(subgroup).to_not be_nil
+      primary = subgroup.children[0]
+      sub = subgroup.children[1]
+      expect(primary.title).to_not match(/sub\]/)
+      expect(sub.title).to match(primary.title)
+      expect(sub.title).to match(/sub\]/)
+      expect(sub.subtitle.language).to_not be_nil
+      expect(sub.subtitle.language_code).to_not be_nil
+      expect(sub.subtitle.location).to_not be_nil
+
+      withoutsub = section.children.find {|c| ! c.is_a?(TivoHMO::Adapters::Plex::Group) }
+      expect(withoutsub).to_not be_nil
+    end
+
+    it "should have children with embedded subtitles" do
+      section = described_class.new(plex_delegate, :newest)
+
+      subgroup = section.children.find {|c|
+        c.is_a?(TivoHMO::Adapters::Plex::Group) &&
+            c.children.any? {|m| m.subtitle && m.subtitle.language == 'Embedded' }
+      }
+      expect(subgroup).to_not be_nil
+      primary = subgroup.children[0]
+      sub = subgroup.children[1]
+      expect(primary.title).to_not match(/sub\]/)
+      expect(sub.title).to match(primary.title)
+      expect(sub.title).to match(/sub\]/)
+      expect(sub.subtitle.language).to eq('Embedded')
+      expect(sub.subtitle.language_code).to_not be_nil
+      expect(sub.subtitle.location).to eq(0)
+    end
+
+    it "should allow disabling subtitles" do
+      section = described_class.new(plex_delegate, :newest)
+      described_class.config_set(:enable_subtitles, false)
+      withsub = section.children.find {|c| c.is_a?(TivoHMO::Adapters::Plex::Group) }
+      expect(withsub).to be_nil
     end
 
+    it "should refresh children when config changes" do
+      described_class.config_set(:enable_subtitles, false)
+      section = described_class.new(plex_delegate, :newest)
+
+      withsub = section.children.select {|c| c.is_a?(TivoHMO::Adapters::Plex::Group) }
+      withoutsub = section.children.select {|c| ! c.is_a?(TivoHMO::Adapters::Plex::Group) }
+      expect(withsub).to be_empty
+      expect(withoutsub).to_not be_empty
+
+      described_class.config_set(:enable_subtitles, true)
+
+      withsub = section.children.select {|c| c.is_a?(TivoHMO::Adapters::Plex::Group) }
+      withoutsub = section.children.select {|c| ! c.is_a?(TivoHMO::Adapters::Plex::Group) }
+      expect(withsub).to_not be_empty
+      expect(withoutsub).to_not be_empty
+    end
+
+
     it "should use category_value for children" do
-      listing = [
-          plex_stub(::Plex::Movie, originally_available_at: "2013-01-02"),
-          plex_stub(::Plex::Episode, originally_available_at: "2013-01-02"),
-          plex_stub(::Plex::Show)
-      ]
-      cval = {title: 'Title', key: 'key'}
-      allow(plex_delegate).to receive(:by_year).with('key').and_return(listing)
+      cval = plex_delegate.years.first
       section = described_class.new(plex_delegate, :by_year, cval)
-      expect(section.children.size).to eq(3)
+
+      expect(section.children.size).to_not be(0)
+
+      keys = section.children.collect(&:delegate).collect(&:key)
+      expected_keys = plex_delegate.by_year(cval[:key]).collect(&:key)
+      expect(keys).to include(*expected_keys)
     end
 
   end

data/spec/adapters/plex/episode_spec.rb

@@ -1,15 +1,14 @@
 require_relative "../../spec_helper"
 require 'tivohmo/adapters/plex'
 
-describe TivoHMO::Adapters::Plex::Episode do
+describe TivoHMO::Adapters::Plex::Episode, :vcr do
 
-  let(:plex_delegate) { plex_stub(::Plex::Episode,
-                                  content_rating: 'G',
-                                  index: 2,
-                                  parent_index: 1,
-                                  grandparent_title: 'ShowTitle',
-                                  guid: "com.plexapp.agents.thetvdb://269650/1/2?lang=en",
-                                  originally_available_at: "2014-06-04") }
+  let(:plex_delegate) {
+    section = plex_tv_section
+    show = section.all.first
+    season = show.seasons.first
+    season.episodes.first
+  }
 
   describe "#initialize" do
 
@@ -19,7 +18,9 @@ describe TivoHMO::Adapters::Plex::Episode do
       expect(episode).to be_a TivoHMO::API::Item
       expect(episode.title).to eq(plex_delegate.title)
       expect(episode.identifier).to eq(plex_delegate.key)
-      expect(episode.modified_at).to eq(Time.at(plex_delegate.updated_at))
+      expect(episode.file).to be_truthy
+      expect(episode.subtitle).to be_nil
+      expect(episode.modified_at).to eq(Time.at(plex_delegate.updated_at.to_i))
       expect(episode.created_at).to eq(Time.parse(plex_delegate.originally_available_at))
     end
 
@@ -32,13 +33,31 @@ describe TivoHMO::Adapters::Plex::Episode do
       episode.app = TivoHMO::Adapters::Plex::Application.new('localhost')
       md = episode.metadata
       expect(md.original_air_date).to eq(Time.parse(plex_delegate.originally_available_at))
-      expect(md.tv_rating).to eq({name: 'G', value: 3})
+      rating = plex_delegate.content_rating.upcase
+      expect(md.tv_rating).to eq({name: rating,
+                                  value: TivoHMO::API::Metadata::TV_RATINGS[rating]})
       expect(md.is_episode).to eq(true)
-      expect(md.episode_number).to eq("102")
-      expect(md.series_title).to eq("ShowTitle")
-      expect(md.episode_title).to eq("102 - Title")
-      expect(md.title).to eq("ShowTitle - Title")
-      expect(md.series_id).to eq("SH269650")
+      epnum = "%i%02i" % [plex_delegate.parent_index, plex_delegate.index]
+      expect(md.episode_number).to eq(epnum)
+      expect(md.series_title).to eq(plex_delegate.grandparent_title)
+      expect(md.episode_title).to eq("#{epnum} - #{plex_delegate.title}")
+      expect(md.title).to eq("#{plex_delegate.grandparent_title} - #{plex_delegate.title}")
+      expect(md.series_id).to match(/SH[0-9]+/)
+    end
+
+    it "should allow disabling series id in metadata" do
+      described_class.config_set(:group_with_zap2it, true)
+      episode = described_class.new(plex_delegate)
+      episode.app = TivoHMO::Adapters::Plex::Application.new('localhost')
+      md = episode.metadata
+      normal_series_id = md.series_id
+      expect(normal_series_id).to match(/SH[0-9]+/)
+
+      described_class.config_set(:group_with_zap2it, false)
+      md = episode.metadata
+      zap2it_series_id = md.series_id
+      expect(zap2it_series_id).to match(/SH[0-9]+/)
+      expect(zap2it_series_id).to_not eq(normal_series_id)
     end
 
   end

data/spec/adapters/plex/metadata_spec.rb

@@ -1,12 +1,9 @@
 require_relative "../../spec_helper"
 require 'tivohmo/adapters/plex'
 
-describe TivoHMO::Adapters::Plex::Metadata do
+describe TivoHMO::Adapters::Plex::Metadata, :vcr do
 
-  let(:plex_delegate) { plex_stub(::Plex::Movie,
-                                  summary: 'Summary',
-                                  duration: 10000,
-                                  rating: 10) }
+  let(:plex_delegate) { plex_movie_section.all.first }
 
   let(:item) { double('item', delegate: plex_delegate)}
 
@@ -16,9 +13,10 @@ describe TivoHMO::Adapters::Plex::Metadata do
       md = described_class.new(item)
       expect(md).to be_a described_class
       expect(md).to be_a TivoHMO::API::Metadata
-      expect(md.duration).to eq(plex_delegate.duration / 1000)
+      expect(md.duration).to eq(plex_delegate.duration.to_i / 1000)
       expect(md.description).to eq plex_delegate.summary
-      expect(md.star_rating).to eq({name: 4, value: 7})
+      expect(md.star_rating[:name]).to be_nonzero
+      expect(md.star_rating[:value]).to be_nonzero
     end
 
   end

data/spec/adapters/plex/movie_spec.rb

@@ -1,11 +1,9 @@
 require_relative "../../spec_helper"
 require 'tivohmo/adapters/plex'
 
-describe TivoHMO::Adapters::Plex::Movie do
+describe TivoHMO::Adapters::Plex::Movie, :vcr do
 
-  let(:plex_delegate) { plex_stub(::Plex::Movie,
-                                  originally_available_at: "2013-01-02",
-                                  content_rating: 'G') }
+  let(:plex_delegate) { plex_movie_section.all.first }
 
   describe "#initialize" do
 
@@ -15,7 +13,9 @@ describe TivoHMO::Adapters::Plex::Movie do
       expect(movie).to be_a TivoHMO::API::Item
       expect(movie.title).to eq(plex_delegate.title)
       expect(movie.identifier).to eq(plex_delegate.key)
-      expect(movie.modified_at).to eq(Time.at(plex_delegate.updated_at))
+      expect(movie.file).to be_truthy
+      expect(movie.subtitle).to be_nil
+      expect(movie.modified_at).to eq(Time.at(plex_delegate.updated_at.to_i))
       expect(movie.created_at).to eq(Time.parse(plex_delegate.originally_available_at))
     end
 
@@ -27,8 +27,11 @@ describe TivoHMO::Adapters::Plex::Movie do
       movie = described_class.new(plex_delegate)
       movie.app = TivoHMO::Adapters::Plex::Application.new('localhost')
       md = movie.metadata
-      expect(md.movie_year).to eq(2013)
-      expect(md.mpaa_rating).to eq({name: 'G', value: 1})
+      expect(md.movie_year).to eq(plex_delegate.year.to_i)
+      rating = plex_delegate.content_rating.upcase
+      expect(md.mpaa_rating).to eq({name: rating,
+                                    value: TivoHMO::API::Metadata::MPAA_RATINGS[rating]})
+
     end
 
   end

data/spec/adapters/plex/qualified_category_spec.rb

@@ -1,9 +1,9 @@
 require_relative "../../spec_helper"
 require 'tivohmo/adapters/plex'
 
-describe TivoHMO::Adapters::Plex::QualifiedCategory do
+describe TivoHMO::Adapters::Plex::QualifiedCategory, :vcr do
 
-  let(:plex_delegate) { plex_stub(::Plex::Section) }
+  let(:plex_delegate) { plex_movie_section }
 
 
   describe "#initialize" do
@@ -16,9 +16,10 @@ describe TivoHMO::Adapters::Plex::QualifiedCategory do
         expect(qcat).to be_a TivoHMO::API::Container
         expect(qcat.title).to eq("By Year")
         expect(qcat.category_qualifier).to eq('2000')
+        expect(qcat.presorted).to eq(true)
         expect(qcat.title).to eq("By Year")
         expect(qcat.identifier).to eq(plex_delegate.key)
-        expect(qcat.modified_at).to eq(Time.at(plex_delegate.updated_at))
+        expect(qcat.modified_at).to eq(Time.at(plex_delegate.updated_at.to_i))
         expect(qcat.created_at).to eq(now)
       end
     end
@@ -28,27 +29,26 @@ describe TivoHMO::Adapters::Plex::QualifiedCategory do
   describe "#children" do
 
     it "should memoize" do
-      listing = [
-          {title: 'Title1', key: 'key1'}
-      ]
-      allow(plex_delegate).to receive(:years).and_return(listing)
       section = described_class.new(plex_delegate, :by_year, :years)
       expect(section.children.object_id).to eq(section.children.object_id)
     end
 
     it "should have children" do
-      listing = [
-          {title: 'Title1', key: 'key1'},
-          {title: 'Title2', key: 'key2'}
-      ]
-      allow(plex_delegate).to receive(:years).and_return(listing)
       section = described_class.new(plex_delegate, :by_year, :years)
-      expect(section.children.size).to eq(2)
-      expect(section.children[0]).to be_instance_of(TivoHMO::Adapters::Plex::Category)
-      expect(section.children[0].category_type).to be(:by_year)
+      expect(section.children).to_not be_empty
+      section.children.all? {|c| expect(c).to be_instance_of(TivoHMO::Adapters::Plex::Category) }
+      section.children.all? {|c| expect(c.category_type).to be(:by_year) }
       # reverse order due to sorting by title reversed to work with tivo newest first sorting
-      expect(section.children[0].category_value).to eq(listing[1])
-      expect(section.children[1].category_value).to eq(listing[0])
+      expect(section.children[1].category_value[:key]).to be > section.children[0].category_value[:key]
+    end
+
+    it "should display non-zero child_count once children fetched" do
+      section = described_class.new(plex_delegate, :by_year, :years)
+
+      expect(section.child_count).to be(0)
+      section.children
+      expect(section.child_count).to_not be(0)
+      expect(section.child_count).to eq(section.children.size)
     end
 
   end

data/spec/adapters/plex/season_spec.rb

@@ -1,9 +1,13 @@
 require_relative "../../spec_helper"
 require 'tivohmo/adapters/plex'
 
-describe TivoHMO::Adapters::Plex::Season do
+describe TivoHMO::Adapters::Plex::Season, :vcr do
 
-  let(:plex_delegate) { plex_stub(::Plex::Season) }
+  let(:plex_delegate) {
+    section = plex_tv_section
+    show = section.all.first
+    show.seasons.first
+  }
 
   describe "#initialize" do
 
@@ -13,10 +17,25 @@ describe TivoHMO::Adapters::Plex::Season do
       expect(season).to be_a TivoHMO::API::Container
       expect(season.title).to eq(plex_delegate.title)
       expect(season.identifier).to eq(plex_delegate.key)
-      # expect(app.modified_at).to eq(Time.at(plex_delegate.updated_at))
-      # expect(app.created_at).to eq(Time.at(plex_delegate.added_at))
+      expect(season.modified_at).to eq(Time.at(plex_delegate.updated_at.to_i))
+      expect(season.created_at).to eq(Time.at(plex_delegate.added_at.to_i))
     end
 
   end
 
+  describe "#children" do
+
+    it "should memoize" do
+      season = described_class.new(plex_delegate)
+      expect(season.children.object_id).to eq(season.children.object_id)
+    end
+
+    it "should have children" do
+      season = described_class.new(plex_delegate)
+      expect(season.children).to_not be_empty
+      season.children.all? {|c| expect(c).to be_instance_of(TivoHMO::Adapters::Plex::Episode) }
+    end
+
+  end
+  
 end

data/spec/adapters/plex/section_spec.rb

@@ -1,9 +1,9 @@
 require_relative "../../spec_helper"
 require 'tivohmo/adapters/plex'
 
-describe TivoHMO::Adapters::Plex::Section do
+describe TivoHMO::Adapters::Plex::Section, :vcr do
 
-  let(:plex_delegate) { plex_stub(::Plex::Section) }
+  let(:plex_delegate) { plex_movie_section }
 
   describe "#initialize" do
 
@@ -15,7 +15,7 @@ describe TivoHMO::Adapters::Plex::Section do
         expect(section).to be_a TivoHMO::API::Container
         expect(section.title).to eq(plex_delegate.title)
         expect(section.identifier).to eq(plex_delegate.key)
-        expect(section.modified_at).to eq(Time.at(plex_delegate.updated_at))
+        expect(section.modified_at).to eq(Time.at(plex_delegate.updated_at.to_i))
         expect(section.created_at).to eq(now)
       end
     end
@@ -31,7 +31,7 @@ describe TivoHMO::Adapters::Plex::Section do
 
     it "should have category children" do
       section = described_class.new(plex_delegate)
-      expect(section.children.size).to eq(11)
+      expect(section.children.size).to_not be(0)
       classes = [TivoHMO::Adapters::Plex::Category, TivoHMO::Adapters::Plex::QualifiedCategory]
       expect(section.children.collect(&:class).uniq.sort_by(&:name)).to eq(classes.sort_by(&:name))
     end